--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1_os/e32toolp/platform/cl_bpabi.pm Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,2885 @@
+# 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:
+#
+
+# This package contains routines to handle Base Platform ABI (BPABI) Platforms.
+package Cl_bpabi;
+
+my @commonOptions;
+my @thumbOptions;
+my @armOptions;
+my @kernelOptions;
+my @invariantOptions;
+my @linkerOptions;
+my @archiverOptions;
+my @debugFormat;
+my $ArmIncDir;
+my @ArmLibList;
+
+my %configVariables;
+
+#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();
+my $IsProxyWrapperOption=&main::ProxyWrapperOption();
+
+# 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);
+ }
+}
+
+sub DepLinkList
+{
+ my $expr = shift @_;
+ my @arr;
+ foreach (@_) {
+ my $str = eval($expr);
+ push @arr, $str;
+ }
+ return @arr;
+}
+
+require Exporter;
+@ISA=qw(Exporter);
+@EXPORT=qw(
+ PMHelp_Mmp
+ PMPlatProcessMmp
+ PMStartBldList
+ PMBld
+ PMStartSrcList
+ PMBitMapBld
+ PMResrcBld
+ PMStartSrc
+ PMAifBld
+ PMSrcDepend
+ PMSrcBldDepend
+ PMEndSrcBld
+ PMEndSrc
+ PMEndSrcList
+ PMPrefixFile
+ PMToolChainIncDir
+ PMSupportsFeatureVariants
+);
+
+use Cwd;
+
+# Armutl package does various ancillary things for armedg modules
+use Armutl;
+use BPABIutl;
+use E32Plat;
+use RVCT_plat2set;
+use gcce_plat2set;
+
+# This is the RVCT Version information required by Armutl package
+my $RVCTMajorVersion;
+my $RVCTMinorVersion;
+my $RVCTVersion;
+
+my $GCCEMajorVersion;
+my $GCCEMinorVersion;
+my $GCCEVersion;
+
+# The name of the build platform, e.g. ARMV6.
+my $PlatName = main::Plat();
+
+# The name of the root platform. This is useful if the plaform is derived using a
+# BSF file. If the current platform is not derived, $RootName will be the same as
+# $PlatName.
+my $RootName = E32Plat::Plat_Root($PlatName);
+
+
+# cl_generic package contains generic routines to handle bits of makefiles which are
+# common to all of the platforms. Currently it deals with AIF, MBM amd RSC files.
+use cl_generic;
+
+# E32env package contains information for makmake and associated e32tools perl programs
+# within the Epoc32 Environment
+use E32env;
+
+# Genutl package contains utility subroutines for MAKMAKE and associated scripts
+use Genutl;
+
+# Modload package is the runtime module-loading routine for loading e32tools modules into
+# 'main' module
+use Modload;
+
+use constant NOCOMPRESSIONMETHOD => 0;
+use constant INFLATECOMPRESSIONMETHOD => 1;
+use constant BYTEPAIRCOMPRESSIONMETHOD => 2;
+
+use constant NOTPAGED => 0;
+use constant UNPAGED => 1;
+use constant PAGED => 2;
+
+use constant NON_DEBUGGABLE => 0;
+use constant DEBUGGABLE => 1;
+use constant DEBUGGABLE_UDEBONLY => 2;
+
+my %plat = &main::PlatRec();
+my $CustomizedARMV5Plat = 0;
+
+if (($plat{'CUSTOMIZES'}) && (($plat{'ROOTPLATNAME'} eq "ARMV5") || ($plat{'ROOTPLATNAME'} eq "ARMV5_ABIV2"))) {
+# The following flag is set to handle the exceptions related to ARMV5 toolchain.
+ $CustomizedARMV5Plat = 1;
+}
+
+#this fucntion will be used for cw_ide platform to update the PlatName and reinitialize the hashtable
+sub getVariableForNewPlat
+{
+ $PlatName = main::Plat();
+ undef(%configVariables);
+}
+sub PMHelp_Mmp {
+
+# Help Text for ARM Platform, lists out the MMP keywords used incase of ARM Compiler
+ if($PlatName eq "ARMV5" || $PlatName eq "ARMV5_ABIV2" || $CustomizedARMV5Plat)
+ {
+ return &Armutl_Help_Mmp;
+ }
+ else
+ {
+ return "";
+ }
+}
+
+my $ToolChainIncDir;
+my @ToolChainLibList;
+my $ArmRT = 0;
+my %AsmFiles = ();
+my %AsmDirs = ();
+my $NamedSymLkup = 0;
+my $InterWorking = '';
+
+sub PMPlatProcessMmp (@) {
+ &InitToolChain(@_);
+ $ToolChainIncDir = &GetToolChainIncDir;
+ &main::SetStdIncPaths($ToolChainIncDir);
+ @ToolChainLibList = &GetLibList;
+# Variable to check if the target forms part of the run time libraries, if it is so
+# shouldn't be linked against itself or other runtime libs
+ $ArmRT = &IsTargetRT;
+ my @AsmFileList = &GetToolChainAsmFileList;
+ foreach (@AsmFileList) { $AsmFiles{ucfirst lc $_} = 1; }
+}
+
+my $preinclude;
+
+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__";
+ push @MacroList, "__SYMBIAN_STDCPP_SUPPORT__" if ( StdCppTarget() );
+
+ my $Plat=&main::Plat;
+ my $Trg=&main::Trg;
+ my $TrgType=&main::TrgType;
+
+ # This horrible change (presumably to allow GCCE to work with edll.lib etc.
+ # produced by RVCT breaks SMP (and also breaks any optimized platform
+ # builds such as ARMV6, and also Thumb2 builds).
+ # Work round for now by conditioning the horrible change on the absence of
+ # SMP in the platform definition.
+ my %PlatHash = &main::PlatRec();
+ unless ($PlatHash{SMP}) {
+ my $myStatLinkPath;
+ $myStatLinkPath = "$E32env::Data{LinkPath}";
+ $myStatLinkPath .= "ARMV5";
+ &main::SetStatLinkPath($myStatLinkPath);
+ }
+
+ my $VariantFile=&ChangeSlash(&main::VariantFile);
+
+ 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);
+ }
+
+ # Required for .lib generation
+ $InterWorking = ($ABI eq 'ARMV4') ? "" : "--inter";
+
+ # need to add config file for makmake invocation
+ my $config_file = BPABIutl_Config_Path($PlatName);
+
+ &main::Output("\n", "include $config_file\n", "\n");
+ &Generic_Header(0,$Makecmd, 1); # define standard things using absolute paths and request that a make function
+ # is provided to provide optional conversion of absolute paths to Unix slashes
+
+# modified start: makefile improvement
+ &main::Output(
+ "CHECKVMAP : CHECKVMAPUDEB CHECKVMAPUREL",
+ "\n"
+ );
+# modified end: makefile improvement
+ 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"
+ );
+ }
+
+ if ($BasicTrgType=~/^(DLL|EXE)/o)
+ {
+
+ my $OtherLinkerOpts;
+ my $toolchain = getConfigVariable('COMPILER_PLAT');
+
+ # In case of GCCE releases, '--map' option was supported only from build 3.4.3 Q1C release
+ # Hence this is a special case, where GCCE platform is checked to ensure that the --map option
+ # is accepted in the correct relase. Even if the option is provided in the config file, it will be
+ # ignored for versions before 3.4.3 Q1C 2005 release.
+
+ # Check to be included in the Makefile, so that the map filename is provided as input only
+ # when the MAP option is supplied
+
+ &main::Output("ifdef LINKER_SYMBOLS_MAP_OPTION\n");
+ foreach (@BldList)
+ {
+ &main::Output("\t$_"."_MAP_FILE=\"\$(EPOCTRG$_)\\".&main::Trg($_).".map\"\n");
+ }
+ &main::Output("else\n");
+ foreach (@BldList)
+ {
+ &main::Output("\t$_"."_MAP_FILE=\n");
+ }
+ &main::Output("endif\n");
+
+ # In some compiler toolchains, the start address may be required to be provided using the appropriate option.
+ # Incase if the option is provided by the toolchain, then pass we need to pass in the start address.
+ &main::Output(
+ "\nifdef CODE_SEGMENT_START\n",
+ "\tCODE_SEGMENT_START += 0x8000 \n",
+ "endif\n",
+ );
+
+
+ # In some compiler toolchain, the symboled archives may have to be listed
+ &main::Output(
+ "ifdef START_GROUP_SYMBOL\n",
+ "\tEEXE_OBJECT=\$(START_GROUP_SYMBOL)UC_EXE_.o\$(END_GROUP_SYMBOL)\n",
+ "\tEDLL_OBJECT=\$(START_GROUP_SYMBOL)UC_DLL_.o\$(END_GROUP_SYMBOL)\n",
+ "\tDENTRY_OBJECT=\$(START_GROUP_SYMBOL)D_ENTRY_.o\$(END_GROUP_SYMBOL)\n",
+ "\tLENTRY_OBJECT=\$(START_GROUP_SYMBOL)L_ENTRY_.o\$(END_GROUP_SYMBOL)\n",
+ "\tXENTRY_OBJECT=\$(START_GROUP_SYMBOL)X_ENTRY_.o\$(END_GROUP_SYMBOL)\n",
+ "\tVENTRY_OBJECT=\$(START_GROUP_SYMBOL)V_ENTRY_.o\$(END_GROUP_SYMBOL)\n",
+ "\tKENTRY_OBJECT=\$(START_GROUP_SYMBOL)K_ENTRY_.o\$(END_GROUP_SYMBOL)\n",
+ "endif\n\n"
+ );
+
+ # put the extra linker options from MMP file into the linker flags
+ $OtherLinkerOpts=&main::LinkerOption($toolchain);
+
+ if($OtherLinkerOpts) {
+ &main::Output(
+ "\n# ADDITIONAL LINKER OPTIONS\n",
+ "ifdef SYMBIAN_UREL_LINK_FLAGS\n",
+ "\tSYMBIAN_UREL_LINK_FLAGS += $OtherLinkerOpts \n",
+ "else\n",
+ "\tSYMBIAN_UREL_LINK_FLAGS = $OtherLinkerOpts \n",
+ "endif\n",
+ "ifdef SYMBIAN_UDEB_LINK_FLAGS\n",
+ "\tSYMBIAN_UDEB_LINK_FLAGS += $OtherLinkerOpts \n",
+ "else\n",
+ "\tSYMBIAN_UDEB_LINK_FLAGS = $OtherLinkerOpts \n",
+ "endif\n\n"
+ );
+ }
+ }
+
+ &main::Output(
+ "INCDIR ="
+ );
+
+ PrintList("\" \\\$(INCLUDE_OPTION) \$_\"", @ChopUserIncPaths);
+ PrintList("\" \\\$(INCLUDE_OPTION) \$_\"", @ChopSysIncPaths);
+
+ $ToolchainIncDir = &GetToolChainIncDir;
+
+ if($ToolchainIncDir ne '')
+ {
+ &main::Output(
+ " \$(INCLUDE_OPTION) ","\"$ToolchainIncDir\"");
+ }
+
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ #Function call logger takes -I as include option
+ my $FCLogger_inc_option = getConfigVariable('FC_LOGGER_INCLUDE_OPTION');
+ if ($Function_Call_Logger) {
+ &main::Output(
+ "INCDIR_FCLOGGER ="
+ );
+ PrintList("\" $FCLogger_inc_option \$_\"", @ChopUserIncPaths);
+ PrintList("\" $FCLogger_inc_option \$_\"", @ChopSysIncPaths);
+ $ToolchainIncDir = &GetToolChainIncDir;
+ if($ToolchainIncDir ne '') {
+ &main::Output(
+ " $FCLogger_inc_option \"$ToolchainIncDir\""
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ }
+
+ # Set control warnings and errors options for building Standard C++ application
+ if( StdCppTarget() ) {
+ &main::Output("CC_WARNINGS_CONTROL_OPTION=\$(CC_STDCPP_WARNINGS_CONTROL_OPTION)","\n");
+ &main::Output("CC_ERRORS_CONTROL_OPTION=\$(CC_STDCPP_ERRORS_CONTROL_OPTION)","\n");
+ &main::Output("\n", "\n");
+ }
+
+ Read_BSF_Options() if ($plat{'CUSTOMIZES'});
+
+ my $kernelOption=0;
+ my $buildAsArmOption=0;
+ my $thumbOption=0;
+
+ if (SysTrg())
+ {
+ $kernelOption=1;
+ }
+ elsif (main::BuildAsARM() or ($ABI eq 'ARMV4'))
+ {
+ $buildAsArmOption=1;
+ }
+ else
+ {
+ $thumbOption=1;
+ }
+
+ my $OtherOpts = undef;
+
+ my $toolchain = getConfigVariable('COMPILER_PLAT');
+
+ $OtherOpts = &main::CompilerOption($toolchain);
+
+
+ if($kernelOption==1)
+ {
+ if(@kernelOptions) {
+# Kernel options as read from BSF file (KERNEL_OPTIONS keyword)
+ Set_BSF_Options('KERNEL_OPTIONS',\@kernelOptions);
+ }
+ $OtherOpts .= " \$(KERNEL_OPTIONS) ";
+ }
+ elsif($buildAsArmOption==1)
+ {
+ if(@armOptions) {
+# Arm options as read from BSF file (ARM_OPTIONS keyword)
+ Set_BSF_Options('ARM_OPTIONS',\@armOptions);
+ }
+ $OtherOpts .= " \$(ARM_OPTIONS) ";
+ }
+ elsif($thumbOption==1)
+ {
+ if(@thumbOptions) {
+# Thumb options as read from BSF file (THUMB_OPTIONS keyword)
+ Set_BSF_Options('THUMB_OPTIONS',\@thumbOptions);
+ }
+ $OtherOpts .= " \$(THUMB_OPTIONS) ";
+ }
+
+ if($thumbOption==1 || $buildAsArmOption==1 || $kernelOption ==1 )
+ {
+ if (&main::ARMFPU && (&main::ARMFPU =~ /^VFPV2$/i))
+ {
+ $OtherOpts .= " \$(VFP2MODE_OPTION) ";
+ }
+ else
+ {
+ $OtherOpts .= " \$(SOFTVFPMODE_OPTION) ";
+ }
+ }
+
+ if ($thumbOption==1)
+ {
+ $OtherOpts .= " \$(COMPILER_THUMB_DEFINES) ";
+ }
+
+ $OtherOpts .= " \$(COMPILER_INTERWORK_DEFINES) ";
+
+ # Options to export symbols by default, for OE
+ if($TrgType=~/^STDDLL$/o || $TrgType=~/^STDEXE$/o || $TrgType=~/^STDLIB$/o) {
+ $OtherOpts .= " \$(OE_OPTIONS) ";
+ }
+
+ if($OtherOpts)
+ {
+ &main::Output(
+ "OTHEROPTIONS=$OtherOpts",
+ "\n",
+ "CCFLAGS += \$(OTHEROPTIONS)",
+ "\n"
+ );
+ }
+
+ if(@invariantOptions) {
+# Invariant options as read from BSF file (INVARIANT_OPTIONS keyword)
+ Set_BSF_Options('INVARIANT_OPTIONS',\@invariantOptions);
+ }
+
+ if(@commonOptions) {
+# Common options as read from BSF file (COMMON_OPTIONS keyword)
+ Set_BSF_Options('COMMON_OPTIONS',\@commonOptions);
+ }
+
+ if(@linkerOptions) {
+# Linker options as read from BSF file (LD_OPTIONS keyword)
+ Set_BSF_Options('LD_OPTIONS',\@linkerOptions);
+ }
+
+ if ($BasicTrgType=~/^LIB$/o) {
+ if(@archiverOptions) {
+# Archiver options as read from BSF file (AR_OPTIONS keyword)
+ Set_BSF_Options('AR_OPTIONS',\@archiverOptions);
+ }
+ }
+
+ if(@debugFormat) {
+ Set_BSF_Options('DEBUG_FORMAT',\@debugFormat);
+ }
+
+ &main::Output(
+ "CCDEFS = \$(COMPILER_DEFINES) "
+ );
+
+ PrintList("\" -D\$_\"", @MacroList);
+
+ &main::Output(
+ " \$(PLATFORM_DEFINES) "
+ );
+
+ &main::Output(
+
+ );
+
+ if($kernelOption==1)
+ {
+ &main::Output(
+ "-D__KERNEL_MODE__ "
+ );
+ }
+
+ if($VariantFile){
+ #Function Call Logger
+ if ($Function_Call_Logger) {
+ #FC Logger accepts product include file without path
+ my $file=&main::Path_Split('File', &main::VariantFile);
+ &main::Output(
+ " -D\"__PRODUCT_INCLUDE__=\\\"${file}\\\"\""
+ );
+ }
+ else {
+ &main::Output(
+ " -D__PRODUCT_INCLUDE__=\\\"${VariantFile}\\\""
+ );
+ }
+ }
+
+ &main::Output(
+ " \$(USERDEFS)\n",
+ "\n"
+ );
+
+ if ( $RootName =~ /^ARMV5$/ ) {
+ # Now we know that the platform is either ARMV5 or a platform derived from
+ # ARMV5 (BSF).
+
+ # See if an environment variable overrides the default DWARF version for
+ # this platform.
+
+ my $env_dwarf_key = "ABLD_${PlatName}_DWARF";
+ my $env_dwarf_val = $ENV{$env_dwarf_key};
+
+ if ($env_dwarf_val) {
+ main::FatalError("The value of $env_dwarf_key is invalid.") unless ($env_dwarf_val =~ /^[23]$/);
+ main::FatalError("We don't support DWARF-2 on ARMV7.") if ($PlatName =~ /^ARMV7/ && $env_dwarf_val == 2);
+
+ &main::Output( "DEBUG_FORMAT=\$(DEBUG_FORMAT_DWARF$env_dwarf_val)\n\n");
+ }
+ }
+
+
+ foreach (@BldList) {
+ &main::Output(
+ "CC$_ = ", $IsProxyWrapperOption ? "$ENV{ABLD_COMPWRAP} ":"", "\$(CC) "
+ );
+
+ # SYMBIAN_UDEB/UREL_CCFLAGS don't have the optimisation levels.
+ if(&main::DebugSwitchUsed() ){
+ if(&main::SymbolicDebugEnabled() ) {
+ &main::Output(
+ " \$(SYMBIAN_UDEB_CCFLAGS) "
+ );
+ }
+ else {
+ &main::Output(
+ " \$(SYMBIAN_UREL_CCFLAGS) "
+ );
+ }
+ }
+ elsif (/DEB$/o) {
+ &main::Output(
+ " \$(SYMBIAN_UDEB_CCFLAGS) "
+ );
+ }
+ else {
+ &main::Output(
+ " \$(SYMBIAN_UREL_CCFLAGS) "
+ );
+
+ }
+ #Set the optimisation levels depending on whether it is a UREL or a UDEB build
+ if (/DEB$/o) {
+ &main::Output(
+ " \$(DEBUG_OPTIMISATION) "
+ );
+ }
+ else {
+ &main::Output(
+ " \$(REL_OPTIMISATION) "
+ );
+ }
+
+ &main::Output(
+ "\$(RUNTIME_SYMBOL_VISIBILITY_OPTION) "
+ );
+
+ if($kernelOption == 0)
+ {
+ &main::Output(
+ "\$(EXCEPTIONS) "
+ );
+ }
+ &main::Output(
+ '$(CCFLAGS) '
+ );
+
+ my @ml = &main::MacroList($_);
+ PrintList("\" -D\$_\"", @ml);
+
+ &main::Output(
+ " \$(CCDEFS)\n"
+ );
+ my @mmpReplaceOptions = &main::ReplaceOptions($toolchain);
+
+ if (@mmpReplaceOptions)
+ {
+ my $OptionPrefix = getConfigVariable('OPTION_PREFIX');
+ my $Pattern;
+
+ # Set the value of '$Pattern' which is required to segregate one option from another based on the option prefix.
+ if($OptionPrefix)
+ {
+ $Pattern = $OptionPrefix.'\S+\s*(?!'.$OptionPrefix.')\S*';
+ }
+ else
+ {
+ # If option prefix is not set in the configuration make file, then set default
+ # option prefix as '-' or '--'.
+ $Pattern = '-{1,2}\S+\s*(?!-)\S*';
+ }
+
+ foreach my $options (@mmpReplaceOptions)
+ {
+ 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;
+ &main::Output(
+ "CC$_ := \$(subst $opt ,@@,\$(CC$_))\n",
+ "CC$_ := \$(CC$_:@@%=$opt $rep)",
+ "\n"
+ );
+ $count++;
+ }
+ else
+ {
+ $opt = $opts[$count];
+ $rep = $opts[$count+1];
+
+ # Substitute '=' with '%' which is a wild card character in makefile.
+ $opt =~ s/=/%/;
+
+ &main::Output(
+ "CC$_ := \$(CC$_:$opt=$rep)",
+ "\n"
+ );
+ $count+=2;
+ }
+ }
+ }
+ }
+ &main::Output(
+ "\n"
+ );
+ }
+
+ &main::Output(
+ "\n"
+ );
+
+ #Function call logger
+ if ($Function_Call_Logger) {
+ #Send all the debug macros to logger
+ foreach (@BldList) {
+ &main::Output
+ (
+ "FCLOGGER$_ = ",
+ $EPOCPath,
+ "tools\\fc_logger\\edgcpfe"
+ );
+
+ my @ml = &main::MacroList($_);
+ PrintList("\" -D\$_\"", @ml);
+ if ($thumbOption==1) {
+ &main::Output(
+ " \$(COMPILER_THUMB_DEFINES)"
+ );
+ }
+ &main::Output(" \$(COMPILER_INTERWORK_DEFINES)",
+ " \$(CCDEFS)",
+ " \$(FC_LOGGER_DEFINES)",
+ " \$(FC_LOGGER_OPTION)");
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ }
+ }
+
+ foreach (@BldList) {
+ &main::Output(
+ "$_ :"
+ );
+
+ if ($BasicTrgType !~ /IMPLIB/io) {
+ &main::Output (
+ " \\\n\t",
+ &Generic_Quote("\$(EPOCTRG$_)\\".&main::Trg($_))
+ );
+ }
+
+# lib has to come after the main target so that a .DEF file will be generated if the project is not frozen
+ if ($DefFile and not &main::ExportUnfrozen) {
+ &main::Output(
+ " \\\n",
+ "\tLIBRARY\n"
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ }
+
+ # Resource building is done entirely via cl_generic.pm
+ PrintList("\"\nRESOURCE\$_ : MAKEWORK\$_\"", @BldList);
+ &main::Output(
+ "\n",
+ "\n",
+ );
+
+ &main::Output(
+ "LIBRARY : MAKEWORKLIBRARY"
+ );
+ if ($BasicTrgType=~/^LIB$/o) {
+# code to ensure that the static libraries for all builds are built at the library stage
+ PrintList("\" \$_\"", @BldList);
+ }
+ elsif ($DefFile and !$NoExportLibrary) {
+ unless (&main::ExportUnfrozen) {
+ if (-e $DefFile) { # effectively "if project frozen ..."
+ if ($PlatName =~ /^ARMV5$/) {
+ &main::Output(
+ " ", &Generic_Quote("\$(EPOCLIB)\\LIB\\$PrimaryExportLibrary.dso"),
+ " ", &Generic_Quote("\$(EPOCLIB)\\LIB\\$PrimaryExportLibrary.lib"), "\n"
+ );
+ }
+ else {
+ &main::Output(
+ " ", &Generic_Quote("\$(EPOCLIB)\\LIB\\$PrimaryExportLibrary.dso"), "\n"
+ );
+ }
+ }
+ else {
+ &main::Output(
+ "\n",
+ "\t\@echo WARNING: Not attempting to create any import libraries.\n",
+ "\t\@echo When exports are frozen in \"$DefFile\", regenerate Makefile.\n"
+ );
+ }
+ } else {
+ &main::Output(
+ "\n",
+ "\t\@echo Not attempting to create \"\$(EPOCLIB)\\LIB\\$PrimaryExportLibrary.dso\"\n",
+ "\t\@echo from frozen .DEF file, since EXPORTUNFROZEN specified.\n"
+ );
+ }
+
+ my $theDefFile = $DefFile;
+ $theDefFile = "\$(EPOCBLD)\\$BaseTrg.def" unless (-e $DefFile);
+ &main::Output(
+ "\n",
+ "\n",
+ "# REAL TARGET - LIBRARY (.dso) \n",
+ "\n",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExportLibrary.dso"), " : ",
+ &Generic_Quote($DefFile), "\n",
+ "\tperl -S prepdef.pl ", &Generic_Quote($DefFile), " \"\$(EPOCBLD)\\$ExportLibrary.prep.def\"\n",
+ "\telf2e32 --definput=\"\$(EPOCBLD)\\$ExportLibrary.prep.def\" --dso=",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExportLibrary.dso"),
+ " --linkas=$LinkAs\n",
+ "\n"
+ );
+ if ($ExtraExportLibrary) {
+ &main::Output(
+ "\n",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.dso"), " : ",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExportLibrary.dso"), "\n",
+ "\tcopy \"\$<\" \"\$@\"\n"
+ );
+ }
+
+ # Generate .lib files which will be used for ARMV5_ABIV1 platform (ABIV1 mode toolchain)
+ # Only for ARMV5 platform
+ if ($PlatName =~ /^ARMV5$/)
+ {
+ &main::Output(
+ "\n",
+ "\n",
+ "# REAL TARGET - LIBRARY (.lib) \n",
+ "\n",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExportLibrary.lib"), " : ",
+ &Generic_Quote($DefFile), "\n",
+ "\tperl -S prepdef.pl ", &Generic_Quote($DefFile), " \"\$(EPOCBLD)\\$ExportLibrary.prep.def\"\n",
+ "\tdef2dll.bat --path=\$(EPOCLIB)\\LIB \\\n\t\t--bldpath=\$(EPOCBLD) \\\n\t\t--import=$ExportLibrary \\\n",
+ "\t\t--deffile=\"\$(EPOCBLD)\\$ExportLibrary.prep.def\" \\\n\t\t--linkAs=$LinkAs \\\n\t\t$InterWorking\n",
+ "\n",
+ );
+ if ($ExtraExportLibrary) {
+ &main::Output(
+ "\n",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.lib"), " : ",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$ExportLibrary.lib"), "\n",
+ "\tcopy \"\$<\" \"\$@\"\n"
+ );
+ }
+ }
+ }
+
+ my $freezeDir = &main::Path_Split('Path', $DefFile);
+ chop($freezeDir);
+
+ # dummy rule for def files to cope with filename case differences
+ unless (&main::ExportUnfrozen) {
+ if (-e $DefFile) { # effectively "if project frozen ..."
+ &main::Output(
+ "\n",
+ "\n",
+ &Generic_Quote($DefFile), " : ", "\n",
+ "\t\@rem Do nothing\n",
+ );
+ }
+ }
+
+ &main::Output(
+ "\n",
+ "\n",
+ &Generic_Quote($freezeDir), " : ", "\n",
+ "\tperl -S emkdir.pl \$\@\n",
+ );
+
+ &main::Output(
+ "\n",
+ "\n",
+ "FREEZE : ",
+ &Generic_Quote($freezeDir), "\n",
+ );
+ if ($DefFile and $BasicTrgType!~/^IMPLIB$/io) {
+# call perl on the script here so make will die if there are errors
+# - this doesn't happen if calling perl in a batch file
+ &main::Output( "\tperl -S efreeze.pl \$(EFREEZE_ALLOW_REMOVE) \"$DefFile\" \"\$(EPOCBLD)\\$ExportLibrary.def\" \n" );
+ }
+ else {
+ &main::Output( "\tperl -e \"print \\\"warning: freeze could not be supported or \\
+ you need to declare an explicitly specified def file using the keyword \\
+ DEFFILE in the MMP file!\\n\\\"\"");
+ }
+ &main::Output(
+ "\n",
+ "CLEANLIBRARY :\n"
+ );
+ if ($DefFile and !$NoExportLibrary) {
+ &main::Output(
+ "\t-\$(ERASE) \"\$(EPOCLIB)\\LIB\\$ExportLibrary.dso\"\n"
+ );
+ if ($ExtraExportLibrary) {
+ &main::Output(
+ "\t-\$(ERASE) \"\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.dso\"\n"
+ );
+ }
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ &Generic_MakeWorkDir('MAKEWORKLIBRARY',"${LibPath}");
+
+ &Generic_Releaseables;
+}
+
+
+sub PMBld {
+
+ my $ABI=&main::ABI;
+ my @ASSPLibList=&main::ASSPLibList;
+ my @SrcList=&main::SrcList;
+ my $FeatureVariantBaseTrg=&main::FeatureVariantBaseTrg;
+ my $Bld=&main::Bld;
+ my $ChopBldPath=&main::Path_Chop(&main::BldPath);
+ my $DefFile=&main::DefFile;
+ my $EPOCIncPath=&main::EPOCIncPath;
+ my $FirstLib=&main::FirstLib;
+ my $BasicTrgType=&main::BasicTrgType;
+ my @LibList;
+ my @RTLibList = &GetRTLibList();
+ my $SystemTrg = &main::SystemTrg;
+ my $LibPath= &main::LibPath;
+ my $LinkAs=&main::LinkAs;
+ my $ExportLibrary=&main::ExportLibrary;
+ my $NoExportLibrary=&main::NoExportLibrary;
+ # N.B. should get better way to detect kernel probably!!
+ $SystemTrg = 1 if ($ExportLibrary =~ /EKERN/i);
+ my $ChopRelPath=&main::Path_Chop(&main::RelPath);
+ my $RelPath=&main::RelPath;
+ my @StatLibList=&main::StatLibList;
+ my $StatLinkPath=&main::StatLinkPath;
+ my $Trg=&main::Trg;
+ my $TrgType=&main::TrgType;
+ my @UidList=&main::UidList;
+ my %Version = &main::Version();
+ my $ExtraExportLibrary;
+ unless ($Version{explicit}) {
+ $ExtraExportLibrary = $ExportLibrary;
+ $ExtraExportLibrary =~ s/\{(\d|a|b|c|d|e|f){8}\}//i;
+ }
+ my $objectFiles;
+
+ if ($Bld =~ /DEB/) {
+ @LibList = &main::DebugLibList;
+ } else {
+ @LibList = &main::LibList;
+ }
+
+# 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);
+ }
+
+
+ # REAL TARGETS
+ #-------------
+ &main::Output(
+ "# REAL TARGET - BUILD VARIANT $Bld\n",
+ "\n"
+ );
+
+# releasables
+ my @releaseables;
+
+ push @releaseables, "$RelPath$Trg" if ($BasicTrgType!~/^IMPLIB$/io);
+ if ($BasicTrgType=~/^(DLL|EXE)$/o) {
+ push @releaseables, "$RelPath$Trg.map";
+ }
+ if (-e $DefFile and !$NoExportLibrary) { # effectively "if project frozen ..."
+ push @releaseables, "$LibPath$ExportLibrary.dso";
+ push @releaseables, "$LibPath$ExtraExportLibrary.dso" if ($ExtraExportLibrary);
+ if ($PlatName =~ /^ARMV5$/) {
+ push @releaseables, "$LibPath$ExportLibrary.lib";
+ push @releaseables, "$LibPath$ExtraExportLibrary.lib" if ($ExtraExportLibrary);
+ }
+ }
+
+ push @releaseables, &main::FeatureVariantVMapFile() if &main::FeatureVariantVMapFile();
+
+ &main::Output(
+ "WHAT$Bld : WHATGENERIC\n",
+ "\n",
+ "CLEAN$Bld : CLEANBUILD$Bld CLEANRELEASE$Bld\n",
+ "\n",
+ "CLEANBUILD$Bld : \n",
+ "\t\@perl -S ermdir.pl \"\$(EPOCBLD$Bld)\"\n",
+ "\n",
+ "CLEANRELEASE$Bld : CLEANGENERIC\n",
+ "\n"
+ );
+
+ &Generic_WhatTargets($Bld, "WHAT$Bld", @releaseables);
+ my @cleantargets = (@releaseables, "$RelPath$ExtraExportLibrary.sym");
+
+ if (-e $DefFile and !$NoExportLibrary) { # effectively "if project frozen ..."
+ &Generic_CleanTargets($Bld, "CLEANRELEASE$Bld", @cleantargets);
+ }
+ else {
+ push @cleantargets, "$LibPath$ExportLibrary.dso";
+ push @cleantargets, "$LibPath$ExtraExportLibrary.dso" if ($ExtraExportLibrary);
+ if ($PlatName =~ /^ARMV5$/) {
+ push @cleantargets, "$LibPath$ExportLibrary.lib";
+ push @cleantargets, "$LibPath$ExtraExportLibrary.lib" if ($ExtraExportLibrary);
+ }
+ &Generic_CleanTargets($Bld, "CLEANRELEASE$Bld", @cleantargets);
+ }
+
+ &Generic_MakeWorkDir("MAKEWORK$Bld",$ChopBldPath);
+ &Generic_MakeWorkDir("MAKEWORK$Bld",$ChopRelPath);
+
+ return if ($BasicTrgType=~/^IMPLIB$/io);
+
+ &main::Output(
+ "LISTING$Bld : MAKEWORK$Bld"
+ );
+ foreach (@SrcList) {
+ my $BaseSrc = &main::Path_Split('Base', $_);
+ my $Ext = &main::Path_Split('Ext', $_);
+ if ($Ext =~ /cia/i && ($PlatName ne "GCCE")) {
+ $BaseSrc = "$BaseSrc\_";
+ }
+ &main::Output(
+ " \\\n\tLISTING$Bld$BaseSrc"
+ );
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ #Compiler wrapper support starts
+ if($IsCompilerWrapperOption)
+ {
+ my $Platcmpwrap=&main::Plat;
+
+ &main::Output(
+ "COMPWRAP$Bld : OUTPUT_NAME = ",
+ "$Platcmpwrap\_$Bld",
+ "\n"
+ );
+
+ &main::Output(
+ "COMPWRAP$Bld : MAKEWORK$Bld"
+ );
+
+ foreach (@SrcList) {
+ my $BaseSrc = &main::Path_Split('Base', $_);
+ &main::Output(
+ " \\\n\tCOMPWRAP$Bld$BaseSrc"
+ );
+ }
+
+ &main::Output(
+ "\n",
+ "\n"
+ );
+ }
+ #--Compiler wrapper support ends
+
+ # Flag that tells us wheter to run checklib.exe on user-added static libraries.
+ my $run_checklib = 0;
+
+ if (@StatLibList && $BasicTrgType =~ /^(EXE|DLL)$/o && !$SystemTrg && main::StdCppSupport()) {
+ # There are user-added static libraries. They should be checked for
+ # consistent use of operator new.
+ $run_checklib = 1;
+
+ #Create a make variable for the libraries.
+ main::Output("\nUSER_ADDED_ARCHIVES_$Bld=");
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\\\$\(EPOCSTATLINK$Bld\)\\\\\$_\"\)", @StatLibList);
+ main::Output("\n\n");
+ }
+
+ &main::Output(
+ "LIBS$Bld="
+ );
+
+ my @depLibs;
+ if ($BasicTrgType=~/^DLL$/o) { # Add the DLL stub library
+ &main::Output(
+ " \\\n\t",
+ &Generic_Quote("\$(EPOCSTATLINK$Bld)\\EDLLSTUB.lib")
+ );
+ push @depLibs, &Generic_Quote("\$(EPOCSTATLINK$Bld)\\EDLLSTUB.lib");
+ }
+
+ my $StaticRTLib = "";
+
+
+ if ($SystemTrg) {
+ $StaticRTLib = "ksrt";
+ }
+ else {
+ $StaticRTLib = "usrt";
+ }
+
+ if ($RVCTVersion) {
+ $StaticRTLib .= $RVCTVersion;
+ }
+ elsif ($GCCEVersion) {
+ if ($GCCEMajorVersion < 4) {
+ $StaticRTLib .= "2_2";
+ }
+ else {
+ $StaticRTLib .= "3_1";
+ }
+ }
+ else {
+ $StaticRTLib .= "2_2";
+ }
+
+ &main::Output(" \\\n\$(EPOCSTATLINK$Bld)\\$StaticRTLib\.lib");
+
+ &main::Output(" \\\n\t",getConfigVariable('VIA_FILE_PREFIX'));
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\\\$\(EPOCBSFSTATLINK$Bld\)\\\\\$_\"\)", @StatLibList);
+ &main::Output(" \\\n\t",getConfigVariable('VIA_FILE_SUFFIX'));
+
+ @depLibs = (@depLibs, DepLinkList("\&Generic_Quote\(\"\\\$\(EPOCBSFSTATLINK$Bld\)\\\\\$_\"\)", @StatLibList));
+
+
+ my @ImportLibList = ImportLibraryList(@LibList);
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\\\$\(EPOCLIB\)\\\\LIB\\\\\$_\"\)", @ImportLibList);
+ @depLibs = (@depLibs, DepLinkList("\&Generic_Quote\(\"\\\$\(EPOCLIB\)\\\\LIB\\\\\$_\"\)", @ImportLibList));
+
+ if ($TrgType=~/^STDEXE$/o || $TrgType=~/^STDDLL$/o) {
+ $NamedSymLkup = 1;
+ my @OEImportLibraryList = &GetOEImportLibList();
+ @OEImportLibraryList = ImportLibraryList(@OEImportLibraryList);
+ if(not (grep /^libc.dso$/i, @LibList)) {
+ push @OEImportLibraryList, "libc.dso";
+ }
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\\\$\(EPOCLIB\)\\\\LIB\\\\\$_\"\)", @OEImportLibraryList);
+ @depLibs = (@depLibs, DepLinkList("\&Generic_Quote\(\"\\\$\(EPOCLIB\)\\\\LIB\\\\\$_\"\)", @OEImportLibraryList));
+ }
+
+ unless ($ArmRT || ($BasicTrgType=~/^LIB$/o)) {
+ my $TargLib = "$ExportLibrary.dso";
+ $TargLib =~ s/\{(\d|a|b|c|d|e|f){8}\}//i;
+ unless ($SystemTrg) {
+ foreach (@RTLibList) {
+ # Ignore the empty file name Modified by Kun Xu for DEF126030 on 06/08/2008
+ if(!$_)
+ {
+ next;
+ }
+ &main::Output(
+ " \\\n\t",
+ &Generic_Quote("\$(EPOCLIB)\\LIB\\$_")
+ ) unless ($_ =~ /$TargLib/i);
+ push @depLibs, &Generic_Quote("\$(EPOCLIB)\\LIB\\$_") unless ($_ =~ /$TargLib/i);
+ }
+ }
+ }
+ #OE Glue Code
+ if ($TrgType=~/^STDEXE$/o) {
+ my @OELibList = &GetOELibList();
+ foreach (@OELibList) {
+ &main::Output(
+ " \\\n\t",
+ &Generic_Quote("\$(EPOCSTATLINK$Bld)\\$_"),
+ );
+ push @depLibs, &Generic_Quote("\$(EPOCSTATLINK$Bld)\\$_");
+ }
+ }
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\$_\"\)", @ToolChainLibList);
+
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ main::Output(
+ "LIBS$Bld" . "DEPS="
+ );
+
+ my @tmp;
+ for my $lib (@depLibs)
+ {
+ $lib =~ s/\(.*\.o\)//;
+ $lib =~ s/\\$//;
+ push @tmp, $lib unless ($lib =~ /-\(/ || $lib =~ /-\)/);
+ }
+
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\"\$_\"\)", @tmp);
+
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ &main::Output(
+ "VTBLEXPORTS$Bld="
+ );
+ my $vtobj = quotemeta("(VtblExports.o)");
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ &main::Output(
+ "OBJECTS$Bld="
+ );
+ foreach (@SrcList) {
+ my $BaseSrc = &main::Path_Split('Base', $_);
+ my $Ext = &main::Path_Split('Ext', $_);
+ if ($Ext =~ /cia/i && ($PlatName ne "GCCE")) {
+ $BaseSrc = "$BaseSrc\_";
+ }
+
+ &main::Output(
+ " \\\n\t",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.o")
+ );
+
+ $objectFiles .= &main::BldPath.$BaseSrc.".o ";
+ }
+ &main::Output(
+ "\n",
+ "\n"
+ );
+
+ # IsCustomDllUseCase() subroutine is called to check if the given executable
+ # is a custom dll or not.
+ my $IsCustomDll = IsCustomDllUseCase();
+
+ if ($IsCustomDll)
+ {
+ # Generate ".bin" file(assembly listing file) only if frozen deffile is present and EXPORTUNFROZEN is not specified
+ # in the Mmp file.
+ if((-e $DefFile) && (!&main::ExportUnfrozen))
+ {
+ &main::Output(
+ "EXPFILE$Bld = \$(EPOCBLD$Bld)\\$ExportLibrary.bin \n",
+ "\n"
+ );
+ }
+ else
+ {
+ &main::Output(
+ "EXPFILE$Bld = \n",
+ "\n"
+ );
+ }
+ }
+
+ # Create "via" file containing all object files in order to reduce
+ # command line lengths in pertinent calls
+ my $objectsViaFile = &main::CommandFile();
+ my $viaoption = getConfigVariable('COMMANDFILE_OPTION');
+
+ if ($BasicTrgType=~/^LIB$/o && StdCppTarget() ) {
+
+ # Add the magic object that identifies the library as a STDLIB.
+ $objectFiles .= "$ENV{EPOCROOT}epoc32/tools/tag/tag_elf";
+ }
+
+ $objectFiles =~ s/\\/\//g ;
+
+ &main::CreateExtraFile($objectsViaFile, $objectFiles);
+
+ &main::Output(
+ &Generic_Quote("\$(EPOCTRG$Bld)\\$Trg"),
+ " : \$(OBJECTS$Bld) \$(LIBS". $Bld . "DEPS)"
+ );
+
+ if (-e $DefFile) { # effectively "if project frozen ..."
+ &main::Output(
+ " ", &Generic_Quote($DefFile)
+ );
+ }
+
+ if($IsCustomDll eq 1)
+ {
+ &main::Output( " \$(EXPFILE$Bld) " );
+ }
+
+ &main::Output("\n");
+
+
+# get rid of any -symbols produced .map file
+ if ($BasicTrgType=~/^(DLL|EXE)/o) {
+ &main::Output(
+ "\t-\$(ERASE) \"\$(EPOCTRG$Bld)\\$Trg.map\" \n"
+ );
+ }
+
+ my $AbsentSubst = '';
+ if ($BasicTrgType=~/^(DLL|EXE)/o) {
+
+ if ($run_checklib) {
+ my $checklib = "checklib";
+
+ if ( StdCppTarget() ) {
+ $checklib .= " stdc++ --elf";
+ }
+ else {
+ $checklib .= " symc++ --elf";
+ }
+
+ &main::Output( "\t$checklib ","\$(USER_ADDED_ARCHIVES_$Bld)\n" );
+ }
+
+ my $WrapLD = $IsProxyWrapperOption ? "$ENV{ABLD_COMPWRAP} " : "";
+ if ($Bld =~ /DEB/)
+ {
+ if($PlatName ne "GCCE"){
+ # if the compiler is RVCT then append SYMBIAN_UDEB_LINK_FLAGS to option string
+ # in order to override the default ones.
+ &main::Output(
+ "\t", $WrapLD, "\$(LD) ","\$(STATIC_LIBS) ", "\$(SHARED_OBJECT_OPTION) ",
+ "\$(CODE_SEGMENT_START) ", "\$(DATA_SEGMENT_START) 0x400000 ", "\$(SYMVER_OPTION) ", "\$(SYMBIAN_UDEB_LINK_FLAGS) ", "\$(SO_NAME_OPTION) ","$LinkAs"
+ );
+ } else {
+ &main::Output(
+ "\t", $WrapLD, "\$(LD) ","\$(STATIC_LIBS) ","\$(SYMBIAN_UDEB_LINK_FLAGS) ", "\$(SHARED_OBJECT_OPTION) ",
+ "\$(CODE_SEGMENT_START) ", "\$(DATA_SEGMENT_START) 0x400000 ", "\$(SYMVER_OPTION) ","\$(SO_NAME_OPTION) ","$LinkAs"
+ );
+ }
+ }
+ else
+ {
+ if($PlatName ne "GCCE"){
+ # if the compiler is RVCT then append SYMBIAN_UREL_LINK_FLAGS to option string
+ # in order to override the default ones.
+ &main::Output(
+ "\t", $WrapLD, "\$(LD) ","\$(STATIC_LIBS) ","\$(SHARED_OBJECT_OPTION) ",
+ "\$(CODE_SEGMENT_START) ", "\$(DATA_SEGMENT_START) 0x400000 ", "\$(SYMVER_OPTION) ", "\$(SYMBIAN_UREL_LINK_FLAGS) ", "\$(SO_NAME_OPTION) ", "$LinkAs"
+ );
+ } else {
+ &main::Output(
+ "\t", $WrapLD, "\$(LD) ","\$(STATIC_LIBS) ","\$(SYMBIAN_UREL_LINK_FLAGS) ","\$(SHARED_OBJECT_OPTION) ",
+ "\$(CODE_SEGMENT_START) ", "\$(DATA_SEGMENT_START) 0x400000 ", "\$(SYMVER_OPTION) ","\$(SO_NAME_OPTION) ","$LinkAs"
+ );
+ }
+ }
+
+ if(&main::DebugSwitchUsed()){
+ if(&main::SymbolicDebugEnabled() ) {
+ &main::Output(
+ " \$(LINKER_DEBUG_OPTION) "
+ );
+ }
+ else {
+ &main::Output(
+ " \$(LINKER_NODEBUG_OPTION) "
+ );
+ }
+ }
+ elsif($Bld =~/DEB/){
+ &main::Output(
+ " \$(LINKER_DEBUG_OPTION) "
+ );
+ }
+ else {
+ &main::Output(
+ " \$(LINKER_NODEBUG_OPTION) "
+ );
+ }
+
+ my $EntrySymbol;
+ if ($BasicTrgType=~/^DLL$/o) {
+ $EntrySymbol = '_E32Dll';
+ }
+ elsif ($BasicTrgType=~/^EXE$/o) {
+ $EntrySymbol = '_E32Startup';
+ }
+ if ($EntrySymbol) {
+ $AbsentSubst = " --absent $EntrySymbol";
+ }
+
+ if (($BasicTrgType=~/^DLL$/o) || ($BasicTrgType=~/^EXE$/o)) {
+ &main::Output(
+ " \$(LINKER_ENTRY_OPTION)",
+ " $EntrySymbol "
+ );
+ my $undefined_option = getConfigVariable('UNDEFINED_SYMBOL_REF_OPTION');
+ if ($undefined_option)
+ {
+ &main::Output(
+ " \$(UNDEFINED_SYMBOL_REF_OPTION)",
+ " $EntrySymbol "
+ );
+ }
+ }
+
+ if ($BasicTrgType=~/^DLL$/o) {
+ # get the right object file for the entry point
+ my $ObjFile="\$(EDLL_OBJECT)";
+ if ($FirstLib =~ /EDEV/i) {
+ $ObjFile="\$(DENTRY_OBJECT)";
+ }
+ if ($FirstLib =~ /EKLL/i) {
+ $ObjFile="\$(LENTRY_OBJECT)";
+ }
+ if ($FirstLib =~ /EEXT/i) {
+ $ObjFile="\$(XENTRY_OBJECT)";
+ }
+ if ($FirstLib =~ /EVAR/i) {
+ $ObjFile="\$(VENTRY_OBJECT)";
+ }
+
+ &main::Output(
+ " \$(EPOCSTATLINK$Bld)\\$FirstLib", "$ObjFile",
+ " \$(EPOCSTATLINK$Bld)\\$FirstLib", " \\", "\n"
+ );
+ } elsif ($BasicTrgType=~/^EXE$/o || $TrgType=~/^EXEXP$/o) {
+ # get the right object file for the entry point
+ my $ObjFile="\$(EEXE_OBJECT)";
+ if ($FirstLib =~ /KC_EXE/i) {
+ $ObjFile="\$(KENTRY_OBJECT)";
+ }
+
+ &main::Output(
+ " \$(EPOCSTATLINK$Bld)\\$FirstLib", "$ObjFile",
+ " \$(EPOCSTATLINK$Bld)\\$FirstLib", " \\", "\n"
+ );
+ }
+
+ &main::Output(
+ "\t\t\$(LINKER_OUTPUT_OPTION) \"\$(EPOCBLD$Bld)\\$Trg\" \\\n",
+# "\t\t\$(OBJECTS$Bld) \\\n"
+ );
+
+ &main::Output(
+ "\t\t\$(LINKER_SYMBOLS_MAP_OPTION) ",
+ "\$(","$Bld","_MAP_FILE) \\\n"
+ );
+
+ # Pass in the command file if the command file option is passed in
+ if($viaoption) {
+ #'@' is for GCCE whos version is not 3.4.3
+ if($viaoption eq '@'){
+ main::Output(
+ "\t\t$viaoption$objectsViaFile \\\n"
+ );
+ }
+ #'-via' is for RVCT
+ else{
+ main::Output(
+ "\t\t$viaoption $objectsViaFile \\\n"
+ );
+ }
+ }
+ else {
+ &main::Output(
+ "\t\t\$(OBJECTS$Bld) \\\n"
+ );
+ }
+
+ if($IsCustomDll eq 1) {
+ &main::Output( "\t\t\$(EXPFILE$Bld) \\\n" );
+ }
+
+ &main::Output(
+ "\t\t\$(LIBS$Bld) \\\n",
+ "\t\t\$(VTBLEXPORTS$Bld) \$(USERLDFLAGS) \n"
+ );
+
+ if(&main::DebugSwitchUsed() ){
+ if(&main::SymbolicDebugEnabled() ) {
+ &main::Output(
+ "\tcopy \"\$(EPOCBLD$Bld)\\$Trg\" \"\$(EPOCTRG$Bld)\\$FeatureVariantBaseTrg.sym\"\n"
+ );
+ }
+ }
+ elsif ($Bld=~/^U?DEB$/o) {
+ &main::Output(
+ "\tcopy \"\$(EPOCBLD$Bld)\\$Trg\" \"\$(EPOCTRG$Bld)\\$FeatureVariantBaseTrg.sym\"\n"
+ );
+ }
+ if (-e $DefFile) {
+ &main::Output(
+ "\tcopy ", &Generic_Quote(("\"$DefFile\"")), " \"\$(EPOCBLD)\\$ExportLibrary.prep.def\"\n",
+ );
+ }
+
+ &main::Output(
+ "\telf2e32 --sid=", &main::SecureId(), " "
+ );
+
+ if (&main::IsDebuggable eq DEBUGGABLE) {
+ &main::Output(
+ ' --debuggable '
+ );
+ }
+
+ if (&main::IsDebuggable eq DEBUGGABLE_UDEBONLY) {
+ if ($Bld=~/^UDEB$/o) {
+ &main::Output(
+ ' --debuggable '
+ );
+ }
+ }
+
+ # Do not export Arm Static Library Symbols
+ if (&Armutl_ArmLibList) {
+ &main::Output(
+ ' --excludeunwantedexports'
+ );
+ }
+
+ if ($IsCustomDll eq 1) {
+ &main::Output(
+ ' --customdlltarget'
+ );
+ }
+ if (keys(%Version)) {
+ &main::Output(
+ ' --version=', &Genutl_VersionToUserString(%Version)
+ );
+ }
+ # exexps are allowed data, but they look like dlls to elftran....
+ if (&main::AllowDllData || $TrgType=~/^EXEXP$/o || $TrgType=~/^EXEDLL$/o) {
+ &main::Output(
+ ' --dlldata'
+ );
+ }
+ if (&main::DataLinkAddress) {
+ &main::Output(
+ ' --datalinkaddress=',&main::DataLinkAddress
+ );
+ }
+ if (&main::FixedProcess) {
+ &main::Output(
+ ' --fixedaddress'
+ );
+ }
+ if (&main::HeapSize) {
+ my %HeapSize=&main::HeapSize;
+ &main::Output(
+ ' --heap=',$HeapSize{Min},',',$HeapSize{Max}
+ );
+ }
+ if (&main::ProcessPriority) {
+ &main::Output(
+ ' --priority=',&main::ProcessPriority
+ );
+ }
+ if (&main::StackSize) {
+ &main::Output(
+ ' --stack=',&main::StackSize
+ );
+ }
+ &main::Output(
+ "\\\n\t\t"
+ );
+
+ my $i=1;
+ foreach (@UidList) {
+ &main::Output(
+ " --uid$i=$_"
+ );
+ $i++;
+ }
+ if(&main::VendorId) {
+ &main::Output(
+ ' --vid=',&main::VendorId
+ );
+ }
+ &main::Output(
+ "\\\n\t\t"
+ );
+
+ &main::Output(
+ ' --capability=',&main::Capability
+ );
+
+ my $vfpv2_support = getConfigVariable('VFP2MODE_OPTION');
+ if ($vfpv2_support && &main::ARMFPU && (&main::ARMFPU =~ /^VFPV2$/i))
+ {
+ &main::Output(
+ ' --fpu=vfpv2'
+ );
+ }
+ else
+ {
+ &main::Output(
+ ' --fpu=softvfp'
+ );
+ }
+
+ if (&main::SmpSafe)
+ {
+ &main::Output(
+ ' --smpsafe'
+ );
+ }
+
+
+ if(($BasicTrgType=~/^DLL/ && $TrgType!~/^DLL/ ) || $TrgType=~/^EXEXP/ || $TrgType=~/^STDEXE/){
+ &main::Output(
+ ' --targettype=',$TrgType
+ );
+ }
+ else{
+ &main::Output(
+ ' --targettype=',$BasicTrgType
+ );
+ }
+
+ &main::Output(
+ ' --output=',"\"\$\@\""
+ );
+ if ($BasicTrgType=~/^DLL$/o || $TrgType=~/^EXEXP$/o || $TrgType=~/^EXEDLL$/o) {
+ if (-e $DefFile) {
+ &main::Output(
+ ' --definput=',"\"\$(EPOCBLD)\\$ExportLibrary.prep.def\""
+ );
+ }
+ # Non-callable exports will be ignored if the MMP file does not contain the DEFFILE keyword or contains the NOEXPORTLIBRARY keyword
+ if (!($DefFile) || $NoExportLibrary) {
+ &main::Output( " --ignorenoncallable" );
+ }
+ &main::Output(
+ ' --dso=',
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$ExportLibrary.dso")
+ );
+ &main::Output(
+ ' --defoutput=',
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$ExportLibrary.def")
+ );
+ if(&main::ExportUnfrozen) {
+ &main::Output( ' --unfrozen ');
+ }
+ }
+ #the input elf file - as the last arg
+ &main::Output(
+ " --elfinput=","\"\$(EPOCBLD$Bld)\\$Trg\"",
+ " --linkas=$LinkAs"
+ );
+ if (&main::CompressTarget)
+ {
+ &main::Output(
+ " --uncompressed"
+ );
+ }
+ else
+ {
+ if(&main::CompressTargetMode == NOCOMPRESSIONMETHOD)
+ {
+ # Do nothing
+ }
+ elsif(&main::CompressTargetMode == INFLATECOMPRESSIONMETHOD)
+ {
+ &main::Output(
+ " --compressionmethod inflate"
+ );
+ }
+ elsif(&main::CompressTargetMode == BYTEPAIRCOMPRESSIONMETHOD)
+ {
+ &main::Output(
+ " --compressionmethod bytepair"
+ );
+ }
+
+ }
+
+ if($NamedSymLkup){
+ &main::Output(" --namedlookup"
+ );
+ }
+
+ &main::Output(
+ " --libpath=", "\"\$(EPOCLIB)\\LIB\""
+ );
+
+ if($BasicTrgType=~/^DLL/ && $TrgType!~/^DLL/){
+ my $Export;
+ my $Ordinal=1;
+ foreach $Export (&main::Exports) {
+ if($Ordinal == 1) {
+ &main::Output(" --sysdef=");
+ }
+ &main::Output(
+ "$Export,$Ordinal; "
+ );
+ $Ordinal++;
+ }
+ }
+
+ if (&main::CodePagingTargetMode == UNPAGED) {
+ &main::Output(
+ ' --codepaging=unpaged'
+ );
+ }
+ elsif (&main::CodePagingTargetMode == PAGED) {
+ &main::Output(
+ ' --codepaging=paged'
+ );
+ }
+
+ if (&main::DataPagingTargetMode == UNPAGED) {
+ &main::Output(
+ ' --datapaging=unpaged'
+ );
+ }
+ elsif (&main::DataPagingTargetMode == PAGED) {
+ &main::Output(
+ ' --datapaging=paged'
+ );
+ }
+
+ &main::Output(
+ "\n"
+ );
+
+ }
+ elsif ($BasicTrgType=~/^LIB$/o) {
+ &main::Output(
+ "\t\$(AR) ",
+ " \$(ARCHIVER_CREATE_OPTION) ",
+ " \$(EPOCBSFSTATLINK$Bld)\\$Trg \\\n"
+ );
+ # Pass in the command file if the command file option is passed in
+ if($viaoption) {
+ #'@' is for GCCE whos version is not 3.4.3
+ if($viaoption eq '@'){
+ &main::Output(
+ "\t\t$viaoption$objectsViaFile\n"
+ );
+ }
+ #'-via' is for RVCT
+ else{
+ &main::Output(
+ "\t\t$viaoption $objectsViaFile\n"
+ );
+ }
+ }
+ else {
+ &main::Output(
+ "\t\t\$(OBJECTS$Bld) \n"
+ );
+ }
+ # Pass the archiver options which can be customized form BSF file
+ &main::Output(
+ "\t\t\$(AR_OPTIONS) \n"
+ );
+ }
+
+ &main::Output(
+ "\n"
+ );
+
+ if ($BasicTrgType=~/^DLL$/o || $TrgType=~/^EXEXP$/o || $TrgType=~/^EXEDLL$/o) {
+ &main::Output(
+ "\tcopy ", " \"\$(EPOCBLD$Bld)\\$ExportLibrary.def\" ", "\"\$(EPOCBLD)\\$ExportLibrary.def\"\n"
+ );
+ if (&main::ExportUnfrozen) {
+ if ($PlatName =~ /^ARMV5$/)
+ {
+ &main::Output(
+ "\tdef2dll.bat --path=\$(EPOCBLD$Bld) \\\n\t\t--bldpath=\$(EPOCBLD$Bld) \\\n\t\t--export=$ExportLibrary \\\n\t\t--import=$ExportLibrary \\\n",
+ "\t\t--deffile=\$(EPOCBLD)\\$ExportLibrary.def \\\n\t\t--linkAs=$LinkAs \\\n\t\t$InterWorking \\\n\t\t--absent=undef \n"
+ );
+ &main::Output(
+ "\n",
+ "\tcopy ", " \"\$(EPOCBLD$Bld)\\$ExportLibrary.lib\" ",
+ "\"\$(EPOCLIB)\\LIB\\$ExportLibrary.lib\"",
+ "\n"
+ );
+ if ($ExtraExportLibrary) {
+ &main::Output(
+ "\n",
+ "\tcopy ", " \"\$(EPOCLIB)\\LIB\\$ExportLibrary.lib\" ",
+ "\"\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.lib\"",
+ "\n"
+ );
+ }
+ }
+
+ &main::Output(
+ "\n",
+ "\tcopy ", " \"\$(EPOCBLD$Bld)\\$ExportLibrary.dso\" ",
+ "\"\$(EPOCLIB)\\LIB\\$ExportLibrary.dso\"",
+ "\n"
+ );
+
+ &main::Output(
+ "\n",
+ "\tcopy ", " \"\$(EPOCBLD$Bld)\\$ExportLibrary.dso\" ",
+ "\"\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.dso\"",
+ "\n"
+ ) if ($ExtraExportLibrary);
+
+ }
+ }
+
+ if($IsCustomDll eq 1)
+ {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$ExportLibrary.bin"), ": $DefFile\n");
+
+ my $theDefFile = "\$(EPOCBLD)\\$ExportLibrary.def";
+ $theDefFile = $DefFile if (-e $DefFile && !&main::ExportUnfrozen);
+ my $theAssembler = " \$(ASM) ";
+ &main::Output(
+ "\telf2e32 \\\n\t\t--definput=$theDefFile \\\n\t\t--dump=a \\\n\t\t--output=\$(EPOCBLD$Bld)\\$ExportLibrary.s \n",
+ "\t$theAssembler \$(AAPCS_OPTION) \\\n\t\t \$(ASM_OUTPUT_OPTION) \$(EPOCBLD$Bld)\\$ExportLibrary.bin \$(EPOCBLD$Bld)\\$ExportLibrary.s\n\n"
+ );
+ &main::Output(
+ "\t-\$(ERASE) \"\$(EPOCBLD$Bld)\\$ExportLibrary.s\"\n\n"
+ );
+ }
+
+ &main::Output( "\n" );
+}
+
+# Set to 1 if multifile compilation wanted
+my $domultifile = 0;
+
+sub DoMultiFile () {
+ return $ENV{RVCTMultiFile} if (defined $ENV{RVCTMultiFile});
+ return $domultifile;
+}
+
+my %CompilationGroups = ();
+
+sub InitMultiFileCompilation() {
+# Do preparatory work for multifile compilation
+ my $SourceStructRef=&main::SourceStructRef;
+
+# We sort the source files by path and extension. These form natural groups to compile together.
+ my %PathToSourceMap = ();
+ foreach my $SourceRef (@$SourceStructRef) {
+ my $SrcFile = $$SourceRef{CurFile};
+ my $Ext = &main::Path_Split('Ext', $SrcFile);
+ push @{$PathToSourceMap{$$SourceRef{SrcPath}}{$Ext}}, $SrcFile;
+ }
+
+# Now we split each group into sets of 10.
+ foreach my $SrcPath (keys %PathToSourceMap) {
+ foreach my $Ext (keys %{$PathToSourceMap{$SrcPath}}) {
+ my @FileList;
+ my @ObjectList;
+ my @SourceList;
+ my $NumToGo = 10;
+ foreach my $File (@{$PathToSourceMap{$SrcPath}{$Ext}}) {
+ my $base = &main::Path_Split('Base', $File);
+ my $cia = ($Ext =~ /cia/i);
+ $base .= "_" if $cia && ($PlatName ne "GCCE");
+ push @FileList, $File;
+ push @ObjectList, "$base.o";
+# this gives us our source files xxx
+ push @SourceList, ($cia && ($PlatName ne "GCCE")) ? "$base.cpp" : "$SrcPath$base$Ext";
+ $NumToGo--;
+ unless ($NumToGo) {
+# Use the last file as the key. This means e.g that all the dependency
+# info will have been generated for the earlier files in the list
+ push @{$CompilationGroups{$FileList[$#FileList]}{Sources}}, @SourceList;
+ push @{$CompilationGroups{$FileList[$#FileList]}{Objects}}, @ObjectList;
+ $NumToGo = 10;
+ undef @FileList;
+ undef @ObjectList;
+ undef @SourceList;
+ }
+ }
+ push @{$CompilationGroups{$FileList[$#FileList]}{Sources}}, @SourceList;
+ push @{$CompilationGroups{$FileList[$#FileList]}{Objects}}, @ObjectList;
+ }
+ }
+
+# debug print out
+ if (0) {
+ foreach my $keyfile (keys %CompilationGroups) {
+ print "$keyfile :\n";
+ foreach my $class (keys %{$CompilationGroups{$keyfile}}) {
+ print "\t$class:\n\t\t";
+ print join " ", @{$CompilationGroups{$keyfile}{$class}}, "\n";
+ }
+ }
+ }
+
+}
+
+sub PMStartSrcList {
+
+ &main::Output(
+ "# SOURCES\n",
+ "\n"
+ );
+
+ InitMultiFileCompilation() if DoMultiFile();
+
+}
+
+sub PMBitMapBld {
+
+ &Generic_BitMapBld;
+
+}
+
+sub PMResrcBld {
+
+ &Generic_ResrcBld;
+
+}
+
+sub PMAifBld {
+ &Generic_AifBld;
+}
+
+
+sub PMStartSrc {
+ my $Src=&main::Src;
+
+ &main::Output(
+ "# Source $Src\n",
+ "\n"
+ );
+}
+
+sub PMSrcDepend {
+ my @DepList=&main::DepList;
+ return if (@DepList == 0);
+
+ my @BldList=&main::BldList;
+ my $BaseSrc=&main::BaseSrc;
+ my $ExtSrc=&main::ExtSrc;
+
+ my $BaseObj=$BaseSrc;
+ my $cia = 0;
+ if ($ExtSrc =~ /cia/i ) {
+ $cia = 1;
+ $BaseObj .= '_' if ($PlatName ne "GCCE");
+ }
+
+ foreach my $Bld (@BldList) {
+ my $tranasm = getConfigVariable('TRANASM');
+ if ($tranasm)
+ {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), " ",
+ ) if $cia && ($PlatName ne "GCCE");
+ }
+
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseObj.cpp"), " ",
+ ) if $cia && ($PlatName ne "GCCE");
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), " ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseObj.o"), " \\\n",
+ );
+ }
+ &main::Output(
+ ":"
+ );
+
+ my $prefix_file=getConfigVariable('PREFIXFILE');
+
+ my @tempdeplist = &main::DepList;
+
+ my $totalcount = $#tempdeplist;
+ my $count = 0;
+ while( $totalcount >= $count )
+ {
+ my $dependencyfile = shift(@tempdeplist);
+ if($dependencyfile eq $prefix_file )
+ {
+ $DepList[$count]="\$(PREFIXFILE)";
+ }
+ $count += 1;
+ }
+
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\$_\)", @DepList);
+ &main::Output(
+ "\n",
+ "\n"
+ );
+}
+
+sub PMSrcBldDepend {
+ my @DepList=&main::DepList;
+ return if (@DepList == 0);
+
+ my $Bld=&main::Bld;
+ my $BaseSrc=&main::BaseSrc;
+ my $ExtSrc=&main::ExtSrc;
+
+ my $BaseObj=$BaseSrc;
+ my $cia = 0;
+ if ($ExtSrc =~ /cia/i ) {
+ $cia = 1;
+ $BaseObj .= '_' if ($PlatName ne "GCCE");
+ }
+
+ my $tranasm = getConfigVariable('TRANASM');
+ if ($tranasm)
+ {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), " ",
+ ) if $cia && ($PlatName ne "GCCE");
+ }
+
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseObj.cpp"), " ",
+ ) if $cia && ($PlatName ne "GCCE");
+
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), " ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseObj.o"), " :",
+ );
+
+ my $prefix_file=getConfigVariable('PREFIXFILE');
+
+ my @tempdeplist = &main::DepList;
+
+ my $totalcount = $#tempdeplist;
+ my $count = 0;
+ while( $totalcount >= $count )
+ {
+ my $dependencyfile = shift(@tempdeplist);
+ if($dependencyfile eq $prefix_file )
+ {
+ $DepList[$count]="\$(PREFIXFILE)";
+ }
+ $count += 1;
+ }
+
+ PrintList("\' \\\n\t\'\.\&Generic_Quote\(\$_\)", @DepList);
+ &main::Output(
+ "\n",
+ "\n"
+ );
+}
+
+sub quoted_path
+{
+ my $curdrive="";
+ my ($arg) = @_;
+ return "\"$arg\"" if ($arg !~ /^\\[^\\]/); # not an absolute path
+
+ $curdrive=$1 if (cwd =~ /^(.:)/);
+ return "\"$curdrive$arg\"";
+}
+
+sub PMPrefixFile
+{
+# Prefix Header File passed to the preprocessor
+
+ my $prefix_file=getConfigVariable('PREFIXFILE');
+ return quoted_path($prefix_file) if defined $prefix_file;
+}
+
+sub PMToolChainIncDir
+ {
+ # Extra system include directories dictated by the toolchain
+ return $ToolChainIncDir;
+ }
+
+sub PMEndSrcBld {
+# Generate multifile compilation stuff if needed.
+ if (DoMultiFile()) {
+ MultiFileEndSrcBld();
+ return;
+ }
+
+ my $ABI=&main::ABI;
+ my $Plat=&main::Plat;
+ my $BaseSrc=&main::BaseSrc;
+ my $Bld=&main::Bld;
+ my $Src=lc &main::Src;
+ my $SrcPath=&main::SrcPath;
+ my $BaseTrg=&main::BaseTrg;
+ my $BldPath = &main::BldPath;
+ my $Ext = &main::Path_Split('Ext', $Src);
+ $Src = ucfirst $Src if ($Ext !~ /\.(cpp|c)$/);
+ my $LangOptions = &SelectLangOptions($Ext);
+ # support for auto 'translated' ASM
+ my $AsmFilep = $AsmFiles{$Src};
+
+ $preinclude = &GetToolChainPreInclude();
+
+ #Function call logger takes -I as include option
+ my $FCLogger_inc_option = getConfigVariable('FC_LOGGER_INCLUDE_OPTION');
+ my $logger_preinclude = getConfigVariable('PREINCLUDE_OPTION_FCLOGGER');
+ my $Dictionary_File_Name = getConfigVariable('FC_LOGGER_DICTIONARY_FILE_NAME');
+ my $Generated_C_File_Name = getConfigVariable('FC_LOGGER_GENERATED_C_FILE_NAME');
+
+ my $ChopSrcPath=&main::Path_Chop($SrcPath);
+ my $lfboption = LinkerFeedBackOption();
+ my $LstExt ;
+ if($Plat =~ /^(ARMV[6-9])/i){
+ $LstExt = $1 ;
+ }
+ else{
+ $LstExt = $ABI;
+ }
+ if ($AsmFilep || ($Ext =~ /cia/i && ($PlatName ne "GCCE"))) {
+ &main::Output(
+# compile the translated, preprocessed source
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.o"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), "\n",
+ "\t\@echo $Src\n",
+ "\t\$(CC$Bld) $lfboption $LangOptions ", "\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ \$(EPOCBLD$Bld)\\$BaseSrc\_.cpp)\n",
+ "\n"
+ );
+# rule to translate the preprocessed source
+ my $tranasm = getConfigVariable('TRANASM');
+ if ($tranasm)
+ {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), "\n",
+
+ "\t\$(TRANASM) \$(TRANASM_FLAGS) \$(TRANASM_OUTPUT_OPTION)\$\@ \$(TRANASM_INPUT_OPTION)\$(EPOCBLD$Bld)\\$BaseSrc.pre\n",
+ "\n"
+ );
+# rule to preprocess the source
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\$(CC$Bld) \$(PREPROCESSOR_OPTION) $preinclude $LangOptions ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) $ChopSrcPath\\$Src \$(OUTPUT_OPTION) \$\@) \n",
+# generate an assembly listing target too
+ "LISTING$Bld$BaseSrc\_ : ", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), "\n",
+ "\t", &Generic_CopyAction("$SrcPath$BaseSrc\_.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), "\n",
+ "\t\$(CC$Bld) $LangOptions ", "\$(ASSEMBLER_LISTING_OPTION) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ \$(EPOCBLD$Bld)\\$BaseSrc\_.cpp)\n",
+ "\n"
+ );
+ }
+ else
+ {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\$(CC$Bld) \$(PREPROCESSOR_OPTION) $preinclude $LangOptions ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) $ChopSrcPath\\$Src \$(OUTPUT_OPTION) \$\@) \n",
+# generate an assembly listing target too
+ "LISTING$Bld$BaseSrc\_ : ", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), "\n",
+ "\t", &Generic_CopyAction("$SrcPath$BaseSrc\_.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), "\n",
+ "\t\$(CC$Bld) $LangOptions ", "\$(ASSEMBLER_LISTING_OPTION) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ \$(EPOCBLD$Bld)\\$BaseSrc\_.cpp)\n",
+ "\n"
+ );
+ }
+ }
+ else {
+ #If Function call logging is enabled, add call to function call logger
+ if ($Function_Call_Logger) {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.o"),
+ " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.int.cpp"),
+ "\n",
+ "\t\@echo $BaseSrc.int.cpp\n",
+ "\t\$(CC$Bld) $lfboption$LangOptions ",
+ " \$(INCLUDE_OPTION) ",
+ "\$(call absolutePaths, $ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ \$(EPOCBLD$Bld)\\$BaseSrc.int.cpp)\n",
+ "\n",
+# generate an assembly listing target too
+ "LISTING$Bld$BaseSrc : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"),
+ "\n",
+ "\t",
+ &Generic_CopyAction("$SrcPath$BaseSrc.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"),
+ " : ",
+ &Generic_Quote("$SrcPath$Src"),
+ "\n",
+ "\t\$(CC$Bld) $LangOptions ",
+ "\$(ASSEMBLER_LISTING_OPTION) ",
+ "\$(INCLUDE_OPTION)",
+ " \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ $ChopSrcPath\\$Src) \n",
+ "\n"
+ );
+
+ #Call to Function Call Logger
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.int.cpp"),
+ " : ",
+ &Generic_Quote("$SrcPath\\$Src"),
+ "\n",
+ "\t\@echo $BaseSrc.int.cpp\n",
+ "\t\$(FCLOGGER$Bld) $lfboption \\\n" ,
+ "\t$FCLogger_inc_option $ChopSrcPath \\\n",
+ "\t$logger_preinclude \\\n ",
+ "\t\$(INCDIR_FCLOGGER) \\\n" ,
+ "\t$Dictionary_File_Name $BldPath$BaseTrg.txt \\\n" ,
+ "\t$Generated_C_File_Name \$\@ $ChopSrcPath\\$Src \n",
+ "\n\n"
+ );
+ }
+ else {
+ &main::Output(
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.o"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\@echo $Src\n",
+ "\t\$(CC$Bld) $lfboption $LangOptions ", "\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ $ChopSrcPath\\$Src)\n",
+ "\n",
+# generate an assembly listing target too
+ "LISTING$Bld$BaseSrc : ", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), "\n",
+ "\t", &Generic_CopyAction("$SrcPath$BaseSrc.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\$(CC$Bld) $LangOptions ","\$(ASSEMBLER_LISTING_OPTION) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ $ChopSrcPath\\$Src) \n",
+ "\n"
+ );
+ # Compiler wrapper support starts...
+ if($IsCompilerWrapperOption)
+ {
+ &main::Output(
+ "COMPWRAP$Bld$BaseSrc : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\@echo Analysing $Src\n",
+ "\t\$(COMPWRAP) \$(CC$Bld) $lfboption $LangOptions ", "\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR) \$(OUTPUT_OPTION) \$\@ $ChopSrcPath\\$Src)\n",
+ "\n"
+ );
+ }
+ # Compiler wrapper support ends...
+ }
+ }
+}
+
+my $MFVarN = 0;
+sub MultiFileEndSrcBld {
+ my $ABI=&main::ABI;
+ my $BaseSrc=&main::BaseSrc;
+ my $Bld=&main::Bld;
+ my $KeyFile = &main::Src;
+ my $Src=ucfirst lc $KeyFile;
+ my $SrcPath=&main::SrcPath;
+ my $Ext = &main::Path_Split('Ext', $Src);
+ my $LangOptions = &SelectLangOptions($Ext);
+ # support for auto 'translated' ASM
+ my $AsmFilep = $AsmFiles{$Src};
+
+ my $ChopSrcPath=&main::Path_Chop($SrcPath);
+ my $lfboption = LinkerFeedBackOption();
+
+ if ($AsmFilep || ($Ext =~ /cia/i && ($PlatName ne "GCCE"))) {
+ if ($CompilationGroups{$KeyFile}) {
+# compile the translated, preprocessed source
+ &main::Output( "OBJECTS$MFVarN = ");
+ foreach my $obj (@{$CompilationGroups{$KeyFile}{Objects}}) {
+ &main::Output( &Generic_Quote("\\\n\t\$(EPOCBLD$Bld)\\$obj"), " ");
+ }
+ &main::Output( "\n\n");
+ &main::Output( "SOURCES$MFVarN = ");
+ foreach my $src (@{$CompilationGroups{$KeyFile}{Sources}}) {
+ &main::Output( &Generic_Quote("\\\n\t\$(EPOCBLD$Bld)\\$src", " "));
+ }
+ &main::Output( "\n\n");
+ &main::Output( "\$(OBJECTS$MFVarN) : \$(SOURCES$MFVarN) \n");
+
+ &main::Output(
+ "\t\@echo Compiling \$(SOURCES$MFVarN)\n",
+ "\t\$(CC$Bld) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR)) $lfboption\\\n",
+ "\t\t$LangOptions \$(OUTPUT_OPTION) \$\@ --multifile \$(SOURCES$MFVarN)"
+ );
+ &main::Output( "\n\n");
+ $MFVarN++;
+ }
+ &main::Output(
+# rule to translate the preprocessed source
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), "\n",
+ "\ttranasm -n -s -o=\$\@ \$(EPOCBLD$Bld)\\$BaseSrc.pre\n",
+ "\n",
+# rule to preprocess the source
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.pre"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\$(CC$Bld) \$(PREPROCESSOR_OPTION) $preinclude $LangOptions ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR)) $ChopSrcPath\\$Src \$(OUTPUT_OPTION) \$\@ \n",
+# generate an assembly listing target too
+ "LISTING$Bld$BaseSrc\_ : ", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), "\n",
+ "\t", &Generic_CopyAction("$SrcPath$BaseSrc\_.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.lis"), " : ",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.cpp"), "\n",
+ "\t\$(CC$Bld) $LangOptions ", "\$(ASSEMBLER_LISTING_OPTION) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR)) \$(OUTPUT_OPTION) \$\@ \$(EPOCBLD$Bld)\\$BaseSrc\_.cpp\n",
+ "\n"
+ );
+ } else {
+
+ if ($CompilationGroups{$KeyFile}) {
+# compile the source
+ &main::Output( "OBJECTS$MFVarN = ");
+ foreach my $obj (@{$CompilationGroups{$KeyFile}{Objects}}) {
+ &main::Output( &Generic_Quote("\\\n\t\$(EPOCBLD$Bld)\\$obj"), " ");
+ }
+ &main::Output( "\n\n");
+ &main::Output( "SOURCES$MFVarN = ");
+ foreach my $src (@{$CompilationGroups{$KeyFile}{Sources}}) {
+ &main::Output( &Generic_Quote("\\\n\t$src"), " ");
+ }
+ &main::Output( "\n\n");
+ &main::Output( "\$(OBJECTS$MFVarN) : \$(SOURCES$MFVarN) \n");
+
+ &main::Output(
+ "\t\@echo Compiling \$(SOURCES$MFVarN)\n",
+ "\t\$(CC$Bld) ", "\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR)) $lfboption\\\n",
+ "\t\t$LangOptions \$(OUTPUT_OPTION) \$\@ --multifile \$(SOURCES$MFVarN)"
+ );
+ &main::Output( "\n\n");
+ $MFVarN++;
+ }
+# generate an assembly listing target too
+ &main::Output(
+ "LISTING$Bld$BaseSrc : ", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), "\n",
+ "\t", &Generic_CopyAction("$SrcPath$BaseSrc.$LstExt.lst"),
+ "\n",
+ &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.lis"), " : ",
+ &Generic_Quote("$SrcPath$Src"), "\n",
+ "\t\$(CC$Bld) $LangOptions ","\$(ASSEMBLER_LISTING_OPTION) ","\$(INCLUDE_OPTION)"," \$(call absolutePaths,$ChopSrcPath \$(INCDIR)) \$(OUTPUT_OPTION) \$\@ $ChopSrcPath\\$Src \n",
+ "\n"
+ );
+ }
+}
+
+
+sub PMEndSrc {
+
+ &main::Output(
+ "\n",
+ "\n"
+ );
+}
+
+sub PMEndSrcList {
+
+ # Deal with accumulated MAKEDIRS etc.
+
+ &Generic_End;
+# modified start: makefile improvement
+ &checkVMAPFiles;
+# modified end: makefile improvement
+}
+
+sub ImportLibraryList {
+ my $dso;
+ my $base;
+ my @ImportLibList;
+ foreach $dso (@_) {
+ $base = &main::Path_Split('Base', $dso);
+ $dso = $base.".dso";
+ push @ImportLibList, $dso;
+ }
+ return @ImportLibList;
+}
+
+sub ChangeSlash($) {
+ my $abspath = $_[0];
+ $abspath =~ s/\\/\//g ;
+ return $abspath;
+}
+
+# System libraries such as the standard C++ libraries or floating point libraries or any other
+# static libraries are made into DLLs by linking its export table against them. Such DLLs that are
+# created from a static library is known as a Custom DLL. The ARM libraries can be supplied using
+# the ARMLIBS mmp keyword A DLL is considered to be a customdll based on the presence of ARMLIBS
+# keyword and also the presence of DEFFILE keyword.
+
+sub IsCustomDllUseCase()
+{
+ # To check if ARMLIBS keyword is passed in the MMP file.
+ # Armutl_ArmLibList() gets the list of static arm libraries, if used by an executable.
+ my $armliblist = &Armutl_ArmLibList;
+
+ # To check if DEFFILE keyword is used in the MMP file to supply the def file.
+ my $deffile = &main::DefFile;
+
+ if ($armliblist && $deffile)
+ {
+ return 1;
+ }
+ return 0;
+
+}
+
+sub GetToolChainPreInclude {
+ my $preinclude_file = getConfigVariable('PREINCLUDE_OPTION');
+
+ $preinclude_file =~ s/\\/\//g;
+ return "$preinclude_file";
+}
+
+sub SelectLangOptions {
+ my ($Ext) = @_;
+ $preinclude = &GetToolChainPreInclude;
+ if ($Ext=~/^.cpp$/ || ($Ext=~/^.cia$/ && ($PlatName eq "GCCE"))) {
+ #Function Call Logger
+ return " \$(CPP_LANG_OPTION) " if ($Function_Call_Logger);
+ return " \$(CPP_LANG_OPTION) $preinclude ";
+ }
+ if ($Ext=~/^.cia$/) {
+ return " \$(CIA_LANG_OPTION) ";
+ }
+ if ($Ext=~/^.c$/) {
+ my $CompilerOption = &main::CompilerOption("ARMCC");
+ if($CompilerOption =~ /--cpp/){
+ #Function Call Logger
+ return " \$(CPP_LANG_OPTION) " if ($Function_Call_Logger);
+ return " \$(CPP_LANG_OPTION) $preinclude ";
+ }
+ else {
+ #Function Call Logger
+ return " \$(C_LANG_OPTION) " if ($Function_Call_Logger);
+ return " \$(C_LANG_OPTION) $preinclude ";
+ }
+ }
+ # To support .cc, .cxx, .c++ file extensions for Open Environment
+ elsif ($Ext=~/^(.cc|.cxx|.c\+\+)$/) {
+ #Function Call Logger
+ return " \$(CPP_LANG_OPTION) " if ($Function_Call_Logger);
+ return " \$(CPP_LANG_OPTION) $preinclude ";
+ }
+ return '';
+}
+
+sub IsMapOptAvail() {
+ open PIPE, "arm-none-symbianelf-g++ -v 2>&1 | ";
+ while(<PIPE>){
+
+ if($_ =~ /gcc version (.*) \(release\).*/i)
+ {
+ if($1 lt "3.4.3")
+ {
+ return 0;
+ }
+ elsif($_ =~ /gcc version (.*) \(release\) \(CodeSourcery ARM (.*) (\d*)\)/i)
+ {
+ if($1 eq "3.4.3" && uc $2 ne "Q1B" && $3 ge 2005)
+ {
+ return 1;
+ }
+ elsif($1 gt "3.4.3")
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+ }
+
+ }
+ close PIPE;
+}
+
+sub StdCppTarget() {
+
+ # STDCPP is supported
+ return 0 if (! main::StdCppSupport());
+
+ if ( main::NoStdCpp() ) { #MMP keyword NOSTDCPP set
+ return 0;
+ }
+
+ if ( main::StdCpp() ) { # MMP keyword STDCPP set.
+ return 1;
+ }
+ else {
+ return ( main::TrgType() =~ /^(STDEXE|STDDLL|STDLIB)$/io );
+ }
+}
+
+sub GetRTLibList() {
+
+ my $newlib = main::NewLib(); # Could have been set in the MMP file.
+
+ unless ($newlib) {
+ if ( StdCppTarget() ) {
+ $newlib = getConfigVariable('OE_NEW_LIB');
+ }
+ else {
+ $newlib = getConfigVariable('SYM_NEW_LIB');
+ }
+ }
+
+ my @RtLib;
+ my $list = "$newlib " . getConfigVariable('RUNTIME_LIBS_LIST') ;
+ if (length($list) >0)
+ {
+ @RtLib = split(/\s+/, $list);
+ }
+ return @RtLib;
+}
+
+sub GetOELibList() {
+ my @OELib;
+ my $list;
+ if (&main::IsWideCharMain()) {
+ $list = getConfigVariable('OE_EXE_LIBS_WCHAR');
+ }
+ else {
+ $list = getConfigVariable('OE_EXE_LIBS');
+ }
+
+ if (length($list) >0)
+ {
+ @OELib = split(/\s+/, $list);
+ }
+ return @OELib;
+}
+
+sub GetOEImportLibList() {
+ my @OEImportLib;
+ my $list;
+ $list = getConfigVariable('OE_IMPORT_LIBS');
+
+ if (length($list) >0)
+ {
+ @OEImportLib = split(/\s+/, $list);
+ }
+ return @OEImportLib;
+}
+
+sub InitToolChain(@) {
+
+ if($PlatName eq "ARMV5" || $PlatName eq "ARMV5_ABIV2" || $CustomizedARMV5Plat)
+ {
+ my $RVCTBuildNumber;
+
+ ($RVCTMajorVersion, $RVCTMinorVersion, $RVCTBuildNumber) = RVCT_plat2set::get_version_list($PlatName);
+
+ $RVCTVersion = "${RVCTMajorVersion}_${RVCTMinorVersion}";
+
+ my $aRVCTVersion = "${RVCTMajorVersion}.${RVCTMinorVersion}";
+ if (($aRVCTVersion == 2.2) && ($RVCTBuildNumber < 559))
+ {
+ warn "WARNING: When building using ABIV2 mode toolchain Compiler RVCT2.2 Build 559 or later is required.\n";
+ }
+ &Armutl_DoMmp(@_);
+ }
+ elsif ($RootName eq "GCCE")
+ {
+ ($GCCEMajorVersion, $GCCEMinorVersion) = gcce_plat2set::get_version_list($Platname);
+
+ $GCCEVersion = "${GCCEMajorVersion}_${GCCEMinorVersion}";
+ }
+
+}
+
+my %BSF_keywords = (
+ COMMON_OPTIONS => 1,
+ THUMB_OPTIONS => 1,
+ ARM_OPTIONS => 1,
+ KERNEL_OPTIONS => 1,
+ INVARIANT_OPTIONS => 1,
+ LD_OPTIONS => 1,
+ AR_OPTIONS => 1,
+ DEBUG_FORMAT => 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/) {
+ push @commonOptions, $val;
+ next;
+ }
+ if ($key =~ /THUMB_OPTIONS/) {
+ push @thumbOptions, $val;
+ next;
+ }
+ if ($key =~ /ARM_OPTIONS/) {
+ push @armOptions, $val;
+ next;
+ }
+ if ($key =~ /KERNEL_OPTIONS/) {
+ push @kernelOptions, $val;
+ next;
+ }
+ if ($key =~ /INVARIANT_OPTIONS/) {
+ push @invariantOptions, $val;
+ next;
+ }
+ if ($key =~ /LD_OPTIONS/) {
+ push @linkerOptions, $val;
+ next;
+ }
+ if ($key =~ /AR_OPTIONS/) {
+ push @archiverOptions, $val;
+ next;
+ }
+ if ($key =~ /DEBUG_FORMAT/) {
+ push @debugFormat, $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=();
+ foreach my $val (@{$Options})
+ {
+ # Check if the value of BSF option is to be set or added/removed.
+ if($val =~ /\+\[.*\]\+|\-\[.*\]\-/)
+ {
+ if (@Fragments = Split_BSF_Options($val,'RemoveOptions'))
+ {
+ foreach my $Opt (@Fragments)
+ {
+ # Remove trailing white spaces
+ $Opt =~ s/\s+$//;
+ # Substitute '=' with '%' which is a wild card character in makefile.
+ # This is required for cases where option to be removed contains '=' (e.g.'-march=armv5t').
+ # When such options are to be removed, "$(INVARIANT_OPTIONS:-march=armv5t=)" is written in the makefile.
+ # However, because of the occurence of '=', pattern match fails in the makefile and such options are not removed.
+ # To resolve this, '=' is replaced with '%' in the makefile so that the substitution pattern looks like
+ # "$(INVARIANT_OPTIONS:-march%armv5t=)" in makefile (e.g."$(INVARIANT_OPTIONS:-march%armv5t=)").
+ $Opt =~ s/=/%/;
+ &main::Output(
+ "$OptionName := \$($OptionName:$Opt=)",
+ "\n"
+ );
+ }
+ @Fragments=();
+ }
+ if (@Fragments = Split_BSF_Options($val,'AddOptions'))
+ {
+ &main::Output(
+ "$OptionName += @Fragments ",
+ "\n"
+ );
+ @Fragments=();
+ }
+
+ # Warn if options are not present in the form '+[...]+' or '-[...]-'
+ $val =~ s/\+\[.*?\]\+|\-\[.*?\]\-//g;
+ if($val !~ /^\s*$/)
+ {
+ print "Warning: Ignoring option(s) \"$val\" for $OptionName as option(s) should be in the form '+[...]+' or '-[...]-.\n";
+ }
+ }
+ else
+ {
+ &main::Output(
+ "$OptionName = $val ",
+ "\n"
+ );
+ }
+ }
+ &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 = '';
+ # Get the toolchain specific option prefix to segregate the options.
+ my $OptionPrefix = getConfigVariable('OPTION_PREFIX');
+
+ 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.
+ if($OptionPrefix)
+ {
+ $Pattern = $OptionPrefix.'\S+\s*(?!'.$OptionPrefix.')\S*';
+ }
+ else
+ {
+ # If option prefix is not set in the configuration make file, then set default
+ # option prefix as '-' or '--'.
+ $Pattern = '-{1,2}\S+\s*(?!-)\S*';
+ }
+
+ foreach my $Val (@Fragments)
+ {
+ my @Opt = $Val =~ /$Pattern/g;
+ push @Result,@Opt;
+ }
+ return @Result;
+}
+
+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;
+}
+
+sub GetLibList() {
+ my @LibList;
+ my @StaticLibList;
+ my $list = getConfigVariable('STATIC_LIBS_LIST') ;
+
+ if (length($list) >0)
+ {
+ @StaticLibList = split(/\s+/, $list);
+ }
+ if($PlatName eq "ARMV5" || $PlatName eq "ARMV5_ABIV2" || $CustomizedARMV5Plat) {
+ @LibList=&Armutl_ArmLibList;
+ if(@LibList==0) {
+ my $LibDir = Armutl_ArmLibDir();
+ # convert '/' to '\' if there are some '/'
+ $LibDir =~ s#/#\\#g;
+ if (@StaticLibList) {
+ foreach my $lib (@StaticLibList) {
+ push @LibList, ("$LibDir\\$lib");
+ }
+ }
+ }
+ }
+ else
+ {
+ @LibList = ('$(STATIC_LIBS_LIST)');
+ }
+ return @LibList;
+}
+
+sub GetToolChainAsmFileList() {
+ my @FileList;
+ @FileList=&Armutl_AsmFileList;
+ if(@FileList)
+ {
+ return @FileList;
+ }
+ return;
+}
+
+sub IsTargetRT() {
+ my $RTtarget=&Armutl_ArmRT;
+ if($RTtarget)
+ {
+ return $RTtarget;
+ }
+ return;
+}
+
+sub GetToolChainIncDir {
+ if($PlatName eq "ARMV5" || $PlatName eq "ARMV5_ABIV2" || $CustomizedARMV5Plat)
+ {
+ #the ToolChainIncDir's value depends on the key word ARMINC in mmp file
+ return &Armutl_ArmIncDir;
+ }
+ else
+ {
+ my $compiler_inc_path = getConfigVariable('COMPILER_INCLUDE_PATH');
+ $compiler_inc_path =~ s/^\s+//g;
+ return ($compiler_inc_path);
+ }
+}
+
+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_OPTION) $file ";
+
+}
+
+sub getConfigVariable
+{
+ my ($variable) = @_;
+ initialiseConfigVariables();
+ return $configVariables{$variable};
+}
+
+sub initialiseConfigVariables()
+{
+ if (!keys(%configVariables))
+ {
+ %configVariables = BPABIutl_Get_Config_Variables($PlatName);
+
+ if (!keys(%configVariables))
+ {
+ # no variables were extracted from configuration file.
+ &main::FatalError("Cannot extract configuration variables for $PlatName");
+ }
+ }
+}
+
+sub PMSupportsFeatureVariants
+{
+ return 1;
+}
+# modified start: makefile improvement
+sub checkVMAPFiles
+{
+ my %srcSet = %{&main::getSrcSet};
+ my %featureVariantInfo = &main::FeatureVariantInfo();
+ my $vmapfile = &main::Trg.".".$featureVariantInfo{NAME}.".vmap";
+ my $mmpFile = &main::MmpFile;
+ if ( $vmapfile ){
+ &main::Output(
+ "\n",
+ "\n",
+ "# Rules to check out the VMAP files",
+ "\n",
+ "\n",
+ );
+ &main::Output(
+ "CHECKVMAPUREL : ",
+ "\$(EPOCTRG)\\urel\\",
+ $vmapfile,
+ " \n",
+ "\$(EPOCTRG)\\urel\\",
+ $vmapfile,
+ " : \\\n",
+ "\t",
+ $mmpFile,
+ );
+ foreach my $srcfile (sort keys(%srcSet))
+ {
+ &main::Output(
+ " \\\n \t",
+ $srcfile,
+ );
+ }
+ &main::Output(
+ "\n",
+ "\t-\$(ERASE) \$(EPOCTRG)\\urel\\",
+ $vmapfile,
+ "\n",
+ "\n",
+ );
+ &main::Output(
+ "CHECKVMAPUDEB : ",
+ "\$(EPOCTRG)\\udeb\\",
+ $vmapfile,
+ " \n",
+ "\$(EPOCTRG)\\udeb\\",
+ $vmapfile,
+ " : \\\n",
+ "\t",
+ $mmpFile,
+ );
+ foreach my $srcfile (sort keys(%srcSet))
+ {
+ &main::Output(
+ " \\\n \t",
+ $srcfile,
+ );
+ }
+ &main::Output(
+ "\n",
+ "\t-\$(ERASE) \$(EPOCTRG)\\udeb\\",
+ $vmapfile,
+ "\n",
+ "\n",
+ );
+ }
+}
+# modified by SV end: makefile improvement
+# modified end: makefile improvement
+
+
+1;