Subversion Repositories DevTools

##############################################################################

#

# Module name   : TOOLSET/KeilArmV3

# Module type   : Makefile system

# Environment(s):

#

# Description:

#   Keil MDK Arm V4.3 toolset

#   A very simple toolset to support

#       1) C compiliation

#       2) Generation of libaries

#       3) Merging of libraries

#       4) Executables

#       5) Assembler files

#

#   Does not support ( because its not needed yet )

#       a) Shared libraries

#

##############################################################################

our @ScmToolsetArgs;

##############################################################################

#   ToolsetInit()

#       Runtime initialisation

#

##############################################################################

ToolsetInit();

sub ToolsetInit

{

    my $KeilVersion = "MDK Arm V4.3";

    my $GenThumb;

    my $GenDevice;

#.. Parse arguments

#

    foreach $_ ( @ScmToolsetArgs ) {

        if ( m~^--Thumb~ ) {

            $GenThumb=1;

        } elsif ( m~^--Device=(.*)~ ) {

            $GenDevice = $1;

        } else {

            Message( "KeilArmV3: unknown option $_ -- ignored\n" );

        }

    }

    Error ("KeilArmV3: Toolset error. --Device must be specified")

        unless ( $GenDevice );

#.. Standard.rul requirements

#

    $s = 's';

    $o = 'o';

    $a = 'lib';

    $exe = '.bin';

    AddSourceType( ".$s", '.asm' );

#.. Define environment

#

    Init( "KeilArmV3" );

    ToolsetDefine( "#################################################" );

    ToolsetDefine( "# Compiler version" );

    ToolsetDefine( "#" );

    ToolsetDefine( "KeilC Version      = \"$KeilVersion\"" );

    ToolsetDefine( "USE_THUMB = 1" ) if $GenThumb;

    ToolsetDefine( "USE_DEVICE = $GenDevice" );

    ToolsetDefine( "" );

    ToolsetDefine( "#" );

    ToolsetDefines( "KeilArmV3.def" );

    ToolsetRules  ( "KeilArmV3.rul" );

    ToolsetRules  ( "standard.rul" );

    #

    #   Extend the cleanup rule

    #

    ToolsetGenerate( '*.lst' );

#.. Extend the CompilerOption directive

#   Create a standard data structure

#   This is a hash of hashes

#       The first hash is keyed by CompileOption keyword

#       The second hash contains pairs of values to set or remove

#

    %::ScmToolsetCompilerOptions =

    (

        'nowarn='             => { 'NOWARNLIST'   ,\&NoWarns }, # Suppress warnings

        'timeoptimization'    => { 'OPT_MODE' , 'time'  },      # Time optimize

        'spaceoptimization'   => { 'OPT_MODE' , 'space' },      # Space optimize

        'defaultoptimization' => { 'OPT_MODE' , undef },        # Default (?space)

    );

    #

    #   Set default options

    #       $::ScmCompilerOpts{'xxxx'} = 'yyy';

    #

    $::ScmCompilerOpts{'NOWARNLIST'}  = '';

    $::ScmCompilerOpts{'OPT_MODE'}    = 'space';

}

#-------------------------------------------------------------------------------

# Function        : NoWarns

#

# Description     : ScmToolsetCompilerOptions  extension function

#                   Accumulates the NoWarn options as a comma seperated list

#

# Inputs          : $key        - Name of the Option

#                   $value      - Option Value. Comma sep list of numbers

#                   $ukey       - User key (within $::ScmCompilerOpts)

#

# Returns         : New sting to save

#

sub NoWarns

{

    my ($key, $value, $ukey) = @_;

    my @NoWarnList =  split (',', $::ScmCompilerOpts{$ukey});

    UniquePush ( \@NoWarnList, split (',', $value) );

    return join ',', @NoWarnList;

}

###############################################################################

#   ToolsetAS( $source, $obj, \@args )

#       This subroutine takes the user options and builds the rule(s)

#       required to compile the source file 'source' to 'obj'

#

###############################################################################

sub ToolsetAS

{

    MakePrint( "\n\t\$(AS)\n" );

}

sub ToolsetASDepend

{

}

###############################################################################

#   ToolsetCC( $source, $obj, \@args )

#       This subroutine takes the user options and builds the rule(s)

#       required to compile the source file 'source' to 'obj'

#

###############################################################################

sub ToolsetCC

{

    my( $source, $obj, $pArgs ) = @_;

    Debug( "CC:  $source -> $obj" );

    foreach ( @$pArgs ) {

        Debug( "option:    $_" );

        if ( /--Shared$/ ) {                    # Building a 'shared' object

            $cflags = "$cflags \$(SHCFLAGS)";

            Debug( "CC:    as shared object" );

        } else {                                # unknown option

            Message( "CC: unknown option $_ -- ignored\n" );

        }

    }

    MakePrint( "\n\t\$(CC)\n" );

    MakePrint( "\$(OBJDIR)/$i.${o}:\tCFLAGS +=$cflags\n" )

        if ( $cflags );

}

###############################################################################

#   ToolsetCCDepend( $depend, \@sources )

#       This subroutine takes the user options and builds the

#       rule(s) required to build the dependencies for the source

#       files 'sources' to 'depend'.

#

###############################################################################

sub ToolsetCCDepend

{

    MakePrint( "\t\$(CCDEPEND)\n" );

}

###############################################################################

#   ToolsetAR( $name, \@args, \@objs )

#       This subroutine takes the user options and builds the rules

#       required to build the library 'name'.

#

#   Arguments:

#       n/a

#

#   Output:

#       [ $(BINDIR)/name$.${a}:   .... ]

#           $(AR)

#

###############################################################################

sub ToolsetAR

{

    my( $name, $pArgs, $pObjs ) = @_;

#.. Parse arguments

#

    foreach $_ ( @$pArgs ) 

    {

        Message( "AR: unknown option $_ -- ignored\n" );

    }

#

    MakeEntry( "\$(LIBDIR)/$name\$(GBE_TYPE).${a}:\t", "", " \\\n\t\t", ".${o}", @$pObjs );

#.. Build library rule (just append to standard rule)

#

    MakePrint( "\n\t\$(AR)\n\n" );

}

###############################################################################

#   ToolsetARMerge()

#       Generate the recipe to merge libraries.

#       The dependency list is created by the caller.

#

###############################################################################

sub ToolsetARMerge

{

    MakePrint( "\n\t\$(ARMERGE)\n\n" );

}

#-------------------------------------------------------------------------------

#   ToolsetLD( $name, \@pArgs, \@pObjs, \@pLibs )

#       This subroutine takes the user options and builds the rules

#       required to link the program 'name'.

#

#   Toolset is configured to suppress partial creation of the Package

#   Rules. This function must create the complete rule and recipe set.

#

#   Arguments:

#       $name           - Name of the output

#       $pArgs          - Ref to array of args

#       $pObjs          - Ref to array of objects

#       $pLibs          - Ref to array of libs

#

#  Options:

#       --Map           - Create a MAP file

#       --NoMap         - Don't create a MAP file

#       --Scatter=file  - Names a scatter file to be used

#       --ro-base=text  - Names the ReadOnly base

#       --rw-base=text  - Names the ReadWrite base

#       --Script=file   - Additional Linker commands

#

#   Output:

#       Generates makefile rules and recipes to create a program

#

sub ToolsetLD

{

    my( $name, $pArgs, $pObjs, $pLibs ) = @_;

    my $map_file;

    my $scatter_file;

    my $ro_base;

    my $rw_base;

    my @script_files;

#.. Parse arguments

#

    foreach ( @$pArgs )

    {

        if ( m~^--Map~i ) {

            $map_file = 1;

        } elsif ( m~^--NoMap~i ) {

            $map_file = 0;

        } elsif ( m~^--Scatter=(.+)~i ) {

            Src ('*', $1 );

            $scatter_file = MakeSrcResolve($1);

        } elsif ( m~^--Script=(.+)~i ) {

            Src ('*', $1 );

            push @script_files, MakeSrcResolve($1);

        } elsif ( /^--ro-base=(.+)/i ) {

            $ro_base = $1;

        } elsif ( m~^--rw-base=(.+)~i ) {

            $rw_base = $1;

        } else {

            Error( "LD: unknown option $_ -- ignored\n" );

        }

    }

    #

    #   Sanity test

    #

    Error ("Can't use --scatter in conjunction with -ro-base or -rw-base")

        if ( $scatter_file && ( $ro_base || $rw_base) );

    #

    #   Determine the target output name

    #

    my $root = "\$(BINDIR)/$name";

    my $full = $root . $::exe;

    my $axf  = $root . '.axf';

    my $dep  = $root . '.dep';

    my $map  = $root . '.map';

    my $call = $root . '.htm';

    #.. Packageing

    #   Have supressed default Prog building

    #   Need to specify the files to Package

    #

    PackageProgAddFiles ( $name, $full );

    PackageProgAddFiles ( $name, $map, 'Class=map' ) if $map_file;

    #.. Cleanup rules

    #

    ToolsetGenerate( $dep );

    ToolsetGenerate( $map );

    ToolsetGenerate( $axf );

    ToolsetGenerate( $call );

    #.. Build rules

    #

    my ($io) = ToolsetPrinter::New();

    #

    #   Standard Dependency rules

    #   Will generate rules to

    #       1) Determine at make-time the full paths to the libraries

    #       2) Include the above information

    #

    $io->LDDEPEND( $name );                         # standard LDDEPEND rules

    #.. Dependency link,

    #

    #       Now piece together a variable $(name_dp) which ends up in

    #       the command file building the application dependency list.

    #

    $io->SetTag( "${name}_dp" );                    # macro tag

    $io->SetTerm();

    $io->DepRules( $name, $pLibs, \&ToolsetLibRecipe ); # library depends rules

    $io->Newline();

    #

    #   List the object files

    #   Create a definition for the objects

    #

    $io->Label( "Object files", $name );            # label

    $io->StartDef ("${name}_obj");

    $io->ObjList( $name, $pObjs, \&ToolsetObjRecipe );

    $io->EndDef ();

    $io->Newline();

    #

    #   Define the program and its dependencies

    #   Place the .dep file first - this will ensure that failure

    #   to create this file will create an error before the object

    #   files are compiled. This makes it obvious what the error is.

    #

    $io->Label( "Program", $name );                     # label

    $io->Prt( "$axf : \t$dep" );                        # Dependencies

    $io->Prt( " \\\n\t$scatter_file" ) if ($scatter_file);

    $io->Prt( " \\\n\t$_" ) foreach (@script_files);

    $io->Prt( " \\\n\t\$(${name}_obj)" .

              " \\\n\t\$(${name}_lib)" );

    $io->Newline();

    #

    #   Recipe to build the program

    #

    $io->PrtLn( "\t\$(LD)" );

    #.. Linker command file

    #

    #       Create a variable $(name_ld) which will be the linker

    #       command line. Use previosly defined values

    #

    $io->Label( "Linker commands", $name );         # label

    $io->StartDef ("${name}_ld");

    $io->Def( "\$(${name}_obj)" );                  # Object file list variable

    $io->Def( "\$(${name}_lib)" );                  # Library list variable

    $io->Def( "--scatter=$scatter_file" ) if ($scatter_file);

    $io->Def( "--ro-base=$ro_base" ) if defined ($ro_base);

    $io->Def( "--rw-base=$rw_base" ) if defined ($rw_base);

    $io->Def( "--list=$map" ) if ( $map_file );

    $io->Def( "--via=$_" ) foreach (@script_files);

    $io->EndDef ();

    $io->Newline();

    #

    #   Create rules to convert the .axf file into a bin file

    #   Done as a seperate step

    #

    #

    $io->Label( "Elf Converion ", $name );             # label

    $io->Prt( "$full : \t$axf\n" );                    # Dependencies

    #

    #   Recipe to build the program

    #

    $io->PrtLn( "\t\$(FROMELF)" );

}

########################################################################

#

#   Generate a linker object recipe.  This is a helper function used 

#   within this toolset.

#

#   Arguments:

#       $io         I/O stream

#

#       $target     Name of the target

#

#       $obj        Library specification

#

########################################################################

sub ToolsetObjRecipe

{

    my ($io, $target, $obj) = @_;

    $io->Def( "$obj.$::o" );

}

###############################################################################

#

#   Parse a linker lib list

#   This is a helper function used within this toolset

#

#   Used to create a variable that will be fedd into 'cmdfile'

#   The output will then be included in the makefile

#   The output extends the definitions of the program being built

#   to contain the absolute pathnames to the libraries being consumed.

#

#   Arguments:

#       $io         io printer class

#

#       $target     Name of the target

#

#       $lib        Library specification

#

###############################################################################

sub ToolsetLibRecipe

{

    my ($io, $target, $lib) = @_;

    $io->Cmd( "${target}_lib += @(vglob2,$lib.$::a,LIB)" );

}

#.. Successful termination

1;