# Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

package Cl_arm;

my $ToolPrefix='';

my %PlatOpt=(

	'Dlltool'=>'',

	'Entry'=>'-e',

	'Ld'=>'',

	'Elftran'=>'',

);

# takes an 'expression'  to evaluate with $_ bound to each of the 

# remaining args

sub PrintList

{

    my $expr = shift @_;

    foreach (@_) {

	my $str = eval($expr);

	&main::Output($str);

    }

}

# specify floating point model here

my $floatingpointmodel = "softvfp";

if (&main::ARMFPU && (&main::ARMFPU =~ /^VFPV2$/i)) {

	$floatingpointmodel = "vfpv2";

}

my $Archive;

my $Link;

my $Objcopy;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMPlatProcessMmp

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMStartSrc

		PMAifBld

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

	PMPrefixFile

	PMSupportsFeatureVariants

);

use Cwd;

use Armutl;

use RVCT_plat2set;

use cl_generic;

use E32env;

use Genutl;

use constant NOCOMPRESSIONMETHOD => 0;

use constant INFLATECOMPRESSIONMETHOD => 1;

use constant BYTEPAIRCOMPRESSIONMETHOD => 2;

use constant NON_DEBUGGABLE => 0;

use constant DEBUGGABLE => 1;

use constant DEBUGGABLE_UDEBONLY => 2;

use constant NOTPAGED => 0;

use constant UNPAGED => 1;

use constant PAGED => 2;

sub PMHelp_Mmp {

    &Armutl_Help_Mmp;

}

my $Plat=main::Plat();

my ($RVCTMajorVersion, $RVCTMinorVersion, $RVCTBuildNumber) = RVCT_plat2set::get_version_list($Plat); 

my $RVCTVersion = "${RVCTMajorVersion}_${RVCTMinorVersion}";

my $ARMCCVersion = "${RVCTMajorVersion}${RVCTMinorVersion}0${RVCTBuildNumber}";

my $oP = '--';

$oP = '-' if ($RVCTMajorVersion == 2 && $RVCTMinorVersion < 2);

#Check if Function call Logger is enabled

my $Function_Call_Logger=&main::IsFunctionCallLogging();

# Get the information regarding supporting Compiler Wrapper Option

my $IsCompilerWrapperOption=&main::CompilerWrapperOption();

#Check the existence of elf2e32.exe in the system path

my $IsExistELF2E32EXE = 0;

    open ELF2E32PIPE, "elf2e32 2>&1 |";

    while (<ELF2E32PIPE>) {

	if($_=~/^Symbian Post Linker\, Elf2E32/) {

	    $IsExistELF2E32EXE = 1;

	    last;

	}

	next;

    }

    close ELF2E32PIPE;

my $ArmIncDir;

my @ArmLibList;

my $ArmRT = 0;

my %AsmFiles = ();

my %AsmDirs = ();

my $oe_options = '';

my $NamedSymLkup = 0;

my $symNameLkupOpt = '';

sub PMPlatProcessMmp (@) {

        &Armutl_DoMmp(@_);

	$ArmIncDir = RVCT_plat2set::get_inc_path($Plat);

	&main::SetStdIncPaths($ArmIncDir);

	@ArmLibList = &Armutl_ArmLibList;

	$ArmRT = &Armutl_ArmRT;

	my @AsmFileList = &Armutl_AsmFileList;

	foreach (@AsmFileList) { $AsmFiles{ucfirst lc $_} = 1; }

}

sub SysTrg () {

	return 1 if &main::SystemTrg;

	my $ExportLibrary=&main::ExportLibrary;

	return 1 if ($ExportLibrary =~ /EKERN/i);

	my $Trg=&main::Trg;

	return 1 if ($Trg =~ /KSRT/i);

	return 0;

}

my $RVCT20 = 0; 

# suppress these warnings & errors

#Warning: #66-D: enumeration value is out of "int" range 

# "EUSER\CBASE\Ub_act.cpp", line 20: Warning:  #161-D: unrecognized #pragma

# 611: overloaded virtual function "entity" is only partially overridden in <entitykind> "entity"

# "EUSER\CBASE\Ub_act.cpp", line 256: Warning:  #654-D: declaration modifiers are incompatible with previous declaration

# 997: <entity-kind> "entity" is hidden by "entity" -- virtual function override intended?

# "EPOC32\include\s32stor.h", line 354: Error:  #1152-D: polymorphic base classes need to be exported as well

# "INCLUDE\e32base.h", line 31: Warning:  #1300-D: ~CBufBase inherits implicit virtual

#"COMPSUPP\\RVCT2_1\\Dfpaeabi.cpp", line 87: Warning: A1488W: PROC/FUNC at line 9 without matching ENDP/ENDFUNC

#"COMPSUPP\\RVCT2_1\\Dfpaeabi.cpp", line 85: Warning: A1464W: ENDP/ENDFUNC without corresponding PROC/FUNC

#Warning: L6318W: _integrator_cm1136_ekern.in(.text) contains branch to a non-code symbol FindMostSignificantOne(unsigned long).

my $diag_suppressions = '--diag_suppress 66,161,611,654,997,1152,1300,1464,1488,6318,6331';

# downgrade from errors to warnings

my $diag_warnings = '';

# upgrade from warnings to errors

# Warning:  #1267-D: Implicit physical register R0 should be defined as a variable

my $diag_errors = '--diag_error 1267';

my $commonOptions = $RVCT20 ?

  "$diag_suppressions $diag_warnings $diag_errors" :

  "$diag_suppressions $diag_warnings $diag_errors";  

my @mmpOption = &main::ReplaceOptions("ARMCC");

my $CompilerOption = &main::CompilerOption("ARMCC");

my $contingentOptions;

my $thumbOptions = $RVCT20 ? '-thumb' : '--thumb ';

my $armOptions = $RVCT20 ? '-arm' : '--arm ';

my $kernelOptions = $RVCT20 ? '-arm' : '--arm --no_exceptions --no_exceptions_unwind';

my $invariantOptions = $RVCT20 ? 

  '-cpu 5T --enum_is_int -Ono_known_library --export_vtbl -apcs /inter' :

  '--cpu 5T --enum_is_int -Ono_known_library --fpmode ieee_no_fenv --export_all_vtbl --no_vfe --apcs /inter';

$invariantOptions .= ' --dllimport_runtime' unless ($RVCTMajorVersion == 2 && $RVCTMinorVersion < 2);  

my $exceptions = $RVCT20 ? '' : ' --exceptions --exceptions_unwind';

my $floatingpoint = $RVCT20 ? '' : ' --fpu '.$floatingpointmodel.'';

my @FCLogger_Macros; # Macros required to be passed to the FCLogger

my $useLinkerFeedBack = 0;

sub LinkerFeedBackFile() {

  return unless $useLinkerFeedBack;

  my $Trg = &main::Trg;

  return "$Trg.lfb";

}

sub LinkerFeedBackOption() {

  return "" unless $useLinkerFeedBack;

  my $BasicTrgType=&main::BasicTrgType;

  return "" unless ($BasicTrgType=~/^(DLL|EXE)/o);

  my $file = LinkerFeedBackFile();

  return "--feedback $file ";

}

my %BSF_keywords = (

		    COMMON_OPTIONS => 1,

		    THUMB_OPTIONS => 1,

		    ARM_OPTIONS => 1,

		    KERNEL_OPTIONS => 1,

		    INVARIANT_OPTIONS => 1

		   );

sub Read_BSF_Options() {

        my %plat = (main::PlatRec());

	my @Customization_Data = split(/\n/,$plat{'CUSTOMIZATION_DATA'});

	foreach my $option (@Customization_Data) {

			next if ($option =~ /^$/);

	        warn "Unrecognized BSF syntax: $option.\n"

		        unless ($option =~ /\s*(\S+)\s+(.+)$/);

		my $key = uc $1;

		my $val = $2;

	        warn "Unrecognized BSF keyword: $key.\n"

		        unless ($BSF_keywords{$key});

		if ($key =~ /COMMON_OPTIONS/) {

		        Set_BSF_Options(\$commonOptions,$val);

			next;

		}

		if ($key =~ /THUMB_OPTIONS/) {

		        Set_BSF_Options(\$thumbOptions,$val);

			next;

		}

		if ($key =~ /ARM_OPTIONS/) {

		        Set_BSF_Options(\$armOptions,$val);

			next;

		}

		if ($key =~ /KERNEL_OPTIONS/) {

		        Set_BSF_Options(\$kernelOptions,$val);

			next;

		}

		if ($key =~ /INVARIANT_OPTIONS/) {

		        Set_BSF_Options(\$invariantOptions,$val);

			next;

		}

	}		

}

# Set the options passed from BSF file 

# @param OptionName    - BSF Keyword using which the options would be overridden in the BSF file

# @param Options       - List of options read from the BSF keyword

sub Set_BSF_Options($$)

{

	my ($OptionName,$Options) = @_;

	my @Fragments=();

	# Check if the value of BSF option is to be set or added/removed.

	if($Options =~ /\+\[.*\]\+|\-\[.*\]\-/)

	{

		if (@Fragments = Split_BSF_Options($Options,'RemoveOptions'))

		{

			foreach my $Opt (@Fragments) 

			{

				# Remove trailing white spaces

				$Opt =~ s/\s+$//;				

				$$OptionName =~ s/$Opt//g;

			}					

			@Fragments=();

		}

		if (@Fragments = Split_BSF_Options($Options,'AddOptions')) 

		{

			$$OptionName .= " @Fragments";

			@Fragments=();

		}		

		# Warn if options are not present in the form '+[...]+' or '-[...]-'

		$Options =~ s/\+\[.*?\]\+|\-\[.*?\]\-//g;

		if($Options !~ /^\s*$/)

		{

			print "Warning: Ignoring option(s) \"$Options\" specified in BSF as option(s) should be in the form '+[...]+' or '-[...]-.\n";

		}

	}

	else

	{

		$$OptionName = $Options;

	}		

	&main::Output(					

		"\n"

	);

}

# Split BSF options to find options which are to be added/removed

# @param String      - List of options present in form '+[...]+' or '-[....]-'

# @param $Task       - Variable to decide whether to return options to be addded or options to be removed

sub Split_BSF_Options($$)

{

	my ($String,$Task) = @_;

    my @Result = ();

	my @Fragments = ();

	my $Pattern = '';

	if ($Task eq 'AddOptions')

	{

		# Get the options which are to be added (present in the form '+[...]+')

		@Fragments = $String =~ /\+\[(.*?)\]\+/g;	

	}

	elsif ($Task eq 'RemoveOptions') 

	{

		# Get the options which are to be removed (present in the form '-[...]-')

		@Fragments = $String =~ /\-\[(.*?)\]\-/g;

	}	

	# Set the value of '$Pattern' which is required to segregate one option from another based on the option prefix.

	# Option prefix for RVCT can be '-' or '--'.

	$Pattern = '-{1,2}\S+\s*(?!-)\S*';	

	foreach my $Val (@Fragments) 

	{

		my @Opt = $Val =~ /$Pattern/g;

		push @Result,@Opt;		 		

	}

	return @Result;	

}

sub ComputeCompilerOpts() {

	my %plat = &main::PlatRec();

	Read_BSF_Options() if ($plat{'CUSTOMIZES'});

	my $ABI=&main::ABI;

	my $TrgType=&main::TrgType;

	if (SysTrg()) {

	        $contingentOptions = $kernelOptions.$floatingpoint;

        } elsif (main::BuildAsARM() or ($ABI eq 'ARMV4')) {

	        $contingentOptions = $armOptions.$floatingpoint.$exceptions;

	    } else {

			$contingentOptions = $thumbOptions.$floatingpoint.$exceptions.' -D__MARM_THUMB__';	

			push @FCLogger_Macros, '__MARM_THUMB__';

	}

	# support for ARMV4

	my $invopts = "$invariantOptions";

	if ($ABI eq 'ARMV4') {

		$invopts =~ s/5T/4/;

		$invopts =~ s/inter/nointer/;

	} else {

		$contingentOptions .= ' -D__MARM_INTERWORK__';

		push @FCLogger_Macros, '__MARM_INTERWORK__';

	}

	#Options to export all the external symbols for OE DLL , OE Exe and OE Static Lib

	if ($TrgType=~/^STDDLL$/o || $TrgType=~/^STDEXE$/o || $TrgType=~/^STDLIB$/o) {

		$oe_options=' --no_hide_all';

	}

	return $commonOptions.' '.$contingentOptions.' '.$invopts.' '.$oe_options.' '.&main::CompilerOption("ARMCC");

}

my $Makecmd;

sub PMStartBldList($) {

	($Makecmd) = @_;

	my $ABI=&main::ABI;

	my $BaseTrg=&main::BaseTrg;

	my $BasicTrgType=&main::BasicTrgType;

	my @BldList=&main::BldList;

	my @ChopSysIncPaths=&main::Path_Chop(&main::SysIncPaths);

	my @ChopUserIncPaths=&main::Path_Chop(&main::UserIncPaths);

	my $DefFile=&main::DefFile;

	my $EPOCPath=&main::EPOCPath;

	my $LinkAs=&main::LinkAs;

	my $LibPath=&main::LibPath.'LIB\\';

	my @MacroList=&main::MacroList();

	push @MacroList, "__SUPPORT_CPP_EXCEPTIONS__";

	my $VariantFile=&main::VariantFile();

	my $Plat=&main::Plat;

	my $Trg=&main::Trg;

	if ($RVCTMajorVersion == 2 && $RVCTMinorVersion < 2) {

		if ($BasicTrgType=~/^LIB$/o) {

			# Temporary Workaround for RVCT2.1 static libs problem with RVCT2.2 builds

			# Rename all the static libs produced with RVCT2.1 as {libname}2_1.lib

		        if ($Trg=~/^\s*(\S+)(\.lib)$/io) {

			        if ($1!~/$RVCTVersion/i) {

				        $Trg=$1.$RVCTVersion.".lib";

				}

			}

			if ($BaseTrg!~/$RVCTVersion/i) {

			        $BaseTrg .= $RVCTVersion;

			}

		}

	}

	my $TrgType=&main::TrgType;

	my @UidList=&main::UidList;	

    my $SystemTrg = &main::SystemTrg;

    my $ExportLibrary=&main::ExportLibrary;

    my $NoExportLibrary=&main::NoExportLibrary;

    # N.B. should get better way to detect kernel probably!!

    $SystemTrg = 1 if ($ExportLibrary =~ /EKERN/i);

    # N.B. should get better way to detect this

    $SystemTrg = 1 if ($Trg =~ /KSRT/i);

	my %Version = &main::Version();

	my $ExtraExportLibrary;

	my $PrimaryExportLibrary = $ExportLibrary;

	unless ($Version{explicit}) {

		$ExtraExportLibrary = $ExportLibrary;

		$ExtraExportLibrary =~ s/\{(\d|a|b|c|d|e|f){8}\}//i;

		$PrimaryExportLibrary = $ExtraExportLibrary;

	}

#	set up LinkAs

	$UidList[2]=~/^0x(.*)$/o;

	if ($1 ne '00000000') { # have to make sure than series of noughts in brackets doesn't appear in name for null uids

		$LinkAs=join '', &main::Path_Split('Base',$LinkAs),"[$1]",&main::Path_Split('Ext',$LinkAs);

	}

#	work out the flags for various platforms

	unless ($ABI eq 'ARMV5' or $ABI eq 'ARMV4') {

		&main::FatalError("Platform module - ABI \"$ABI\" unrecognised");

	}

	my $ComputeCompilerOpts=ComputeCompilerOpts();

	if (@mmpOption) 

	{

		my $pattern = '-{1,2}\S+\s*(?!-)\S*';	

		foreach my $options (@mmpOption) 

		{

			my @opts = $options =~ /$pattern/g;

			my $count = 0;

			while ($count <= $#opts) 

			{

				my $opt;

				my $rep;

				if ($opts[$count] =~ /^(\S+)\s+(\S+)$/) 

				{

					$opt = $1;

					$rep = $2;

					$ComputeCompilerOpts =~ s/$opt\s+\S+\s+/ $opt $rep /g;

					$count++;

				}

				else

				{

					$opt = $opts[$count];

					$rep = $opts[$count+1];

					$ComputeCompilerOpts =~ s/$opt/$rep/g;					

					$count+=2;

				}

			}		

		}

	}

	$PlatOpt{Arm} = $ComputeCompilerOpts;

	my $InterWorking = ($ABI eq 'ARMV4') ? "" : "--inter";

	$Archive=$ToolPrefix.'armar';

	$Objcopy=$ToolPrefix.'objcopy';

	&Generic_Header(0,$Makecmd);	# define standard things using absolute paths

	if ($Makecmd eq "nmake") {

		&main::Output(

			"\n",

  			"PATH=",&main::Path_Drive,$EPOCPath,"gcc\$(PBUILDPID)\\bin;\$(PATH)\n",

			"\n"

		);

	}

	else {

		&main::Output(

			"\n",

			"# must set both PATH and Path to make it work correctly\n",

  			"Path:=",&main::Path_Drive,$EPOCPath,"gcc\$(PBUILDPID)\\bin;\$(Path)\n",

			"PATH:=\$(Path)\n",

			"\n"

		);

	}

	&main::Output(

		"INCDIR  ="

	);

	PrintList("\" -J \$_\"", @ChopUserIncPaths);

	PrintList("\" -J \$_\"", @ChopSysIncPaths);

	if ($ArmIncDir) {

		&main::Output(

		    " -J \"$ArmIncDir\" ",

		);	

	}

	&main::Output(

		"\n",

		"\n"

	);

	#Function Call Logger

	if ($Function_Call_Logger)	{

		&main::Output(

			"INCDIR_FCLOGGER  ="

		);

		PrintList("\" -I \$_\"", @ChopUserIncPaths);

		PrintList("\" -I \$_\"", @ChopSysIncPaths);

		if ($ArmIncDir) {

			&main::Output(

				" -I \"$ArmIncDir\" "

			);	

		}

		&main::Output(

			"\n",

			"\n"

		);

	}

	&main::Output(

		"ARMCCFLAGS=$PlatOpt{Arm} -c\\\n",

		"\n"

	);

	&main::Output(

		"ARMCCDEFS = "

	);

	PrintList("\" -D\$_\"", @MacroList);

	if($VariantFile) {

		if ($Function_Call_Logger) {