Subversion Repositories DevTools

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

# Copyright (C) 1998-2011 Vix Technology, All rights reserved

#

# Module name   : MSP430.PL

# Module type   : Makefile system

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : Toolset for the Texas Instruments CC Studio

#

#......................................................................#

use strict;

use JatsVersionUtils;

our $s;

our $o;

our $so;

our $exe;

our $tool_vxp430img;

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

#   ToolsetInit()

#       Runtime initialisation

#

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

ToolsetInit();

sub ToolsetInit

{

    my( $version, $product, @defines, @dirs, @flags, @asflags, @asdefines );

    #.. Parse Toolset Arguments

    #

    Debug( "msp430(@::ScmToolsetArgs)\n" );

    foreach $_ ( @::ScmToolsetArgs ) {

        if (/^--Version=(.*)/) {                # Compiler version

            $version = "$1";

        } else {

            Message( "msp430: unknown toolset argument $_ -- ignored\n" );

        }

    }

    #.. Parse Platform Arguments

    #

    foreach $_ ( @::ScmPlatformArgs ) {

        Message( "msp430: unknown platform argument $_ -- ignored\n" );

    }

    #.. Standard.rul requirements

    #

    $s = 'asm';             # Assembler source file

    $o = 'obj';             # Object file

    $a = 'lib';             # Library file

    $so = '';               # Shared library

    $exe = '.out';          # Linked binary images

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

    #.. Toolset configuration

    #

    $::ScmToolsetVersion = "1.0.0";               # our version

    $::ScmToolsetGenerate = 0;                    # generate optional

    $::ScmToolsetProgDependancies = 0;            # handle Prog dependancies myself

#.. Cleanup rules

#

#

#    ToolsetGenerate( "SomeFile" );

    #.. Define toolchain environment

    #

    #

    #   Define initialisation targets

    #   These will be used to ensure that correct versions of the toolset are present

    #

    Init( "msp430" );

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

    ToolsetDefine ( "# MSP430 compiler version" );

    ToolsetDefine ( "#" );

    ToolsetDefine ( "msp430_ver         = $version" );

    ToolsetDefine ( "" );

    ToolsetDefine ( "#" );

    ToolsetDefines( "msp430.def" );

    ToolsetRules  ( "msp430.rul" );

    ToolsetRules  ( "standard.rul" );

}

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

#   ToolsetPreprocess()

#       Process collected data before the makefile is generated

#       This, optional, routine is called from within MakefileGenerate()

#       It allows the toolset to massage any of the collected data before

#       the makefile is created

#

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

#sub ToolsetPreprocess

#{

#}

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

#   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

{

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

    #

    #   Mark generated assembler files to be deleted

    #

    ToolsetGenerate( "\$(OBJDIR)/$_[1].asm" );

}

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

#   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" );

}

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

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

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

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

#

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

sub ToolsetCXX

{

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

}

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

#   ToolsetCXXDepend( $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 ToolsetCXXDepend

{

    ToolsetCCDepend();

}

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

#   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\$(CC)\n" );

}

sub ToolsetASDepend

{

}

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

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

#       This subroutine takes the user options and builds the rules

#       required to build the library 'name'.

#

#   Arguments:

#       --xxx                   No arguments currently defined

#

#   Output:

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

#           $(AR)

#

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

sub ToolsetAR

{

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

    Debug("ToolsetAR");

#.. Parse arguments

#

    foreach $_ ( @$pArgs ) {

        if (/^--/) {

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

        }

    }

#.. Target

#

    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

#   Currently not supported

#   Add only if required

#

#{

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

#}

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

#   ToolsetLD( $name, \@args, \@objs, \@libraries )

#       This subroutine takes the user options and builds the rules

#       required to link the program 'name'.

#

#   Arguments:

#       --xxx                   No Arguments currently specified

#

#       Linker specific:

#       --Script=filename   Specify the name of a linker script file

#       --NoImg             Do not create IMG file, only COFF

#

#   Output:

#

#       name.map                - Map file

#       name.???

#       name.???

#       name.???

#

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

sub ToolsetLD

{

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

    my( $script );

    my $img_file = 1;

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

    #.. Target specific

    #

    #.. Toolset specific

    #

        if (/^--Script=(.*)/) {           # External file

            $script = $1;

            $script .= ".cmd" unless ( $script =~ m~\.cmd$~ );

        } elsif (/^--NoImg/i ) {

            $img_file = undef;

        } else {

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

        }

    }

#

#   Sanity check

#       - Ensure a linker script has been provided

#

unless ( $script )

{

    $script = "$name.opt";

    Warning( "Prog: Linker Script file not provided. Using $script" );

}

#

#   Locate the true path of the provided script file

#   If it is a generate file so it will be in the SRCS hash

#   Other wise the use will have to use Src to locate the file

#

    $script = MakeSrcResolve ( $script );

#

#   If creating an IMG file, then ensure that the tools are available

#

if ( $img_file )

{

    unless ( defined $tool_vxp430img )

    {

        $tool_vxp430img = ToolExtensionProgram( 'vxp430img', '.exe', '' );

        if ( $tool_vxp430img )

        {

            MakePrint ( "#################################################\n" );

            MakePrint ( "#  The path to tools required to build programs\n" );

            MakePrint ( "#\n" );

            MakePrint ( "TOOL_VXP430IMG := $tool_vxp430img\n" );

            MakePrint ( "\n" );

        }

        else

        {

            Error( 'Tool program required by toolset not found:',

                   'vxp430img',

                   'Check that the vxp430img package is present' );

        }

    }

}

#

#   Create a ToolsetPrinter

#

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

    my $dep = $io->SetLdTarget( $name );

#

#   Determine the target output name

#

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

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

    my $img = $img_file ? $root . '.img' : '';

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

#

#   Add runtime support libaries

#   These are transparent to the user

#

    push @$pLibs, 'libc.a';

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

#

#   Before this function was called, makelib.pl2 has generated a

#   partial rule consisting of:

#

#       $(BINDIR)/${name}${exe} :

#               All the specified object files

#

#   Add the names of all the other files required in the process

#   This will then serve as a target fo all things that need to be

#   created when a "program" is required

#

#       These are:

#               User linker script file

#               Library dependency file

# 

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

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

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

    $io->Entry( "", "", "\\\n\t", ".$::o ", @$pObjs );  # Object Files

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

    $io->Prt( "\n\t\$(call COFF2IMG,$full,$img,\$(BUILDVER))\n" ) if ($img);

    $io->Newline();

    #

    #   Specify files created by the linker

    #   These will be added to the clean list

    #

    ToolsetGenerate( $map );

    ToolsetGenerate( $root . '.ld' );

    if ( $img )

    {

        ToolsetGenerate( $img );

        ToolsetGenerate( $root . '.hex' );

    }

    #

    #   Create a linker command file

    #   Piecing together a variable $(name_ld) which ends up in the command file.

    #   This bit of magic will be performed by the LD recipe

    #

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

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

    $io->Cmd("--stack_size=160");

    $io->Cmd("--heap_size=160");

    $io->Cmd("--use_hw_mpy=F5");

    $io->Cmd("-o $full" );                                  # Output file

    $io->Cmd("-m $map" );                                   # Map file

    $io->Cmd("--warn_sections" );                           # Warn if creating unused sections

    $io->Cmd("--entry_point=main" );                        # Fixed entry point

    $io->Cmd("--reread_libs" );                             # Multipass on lib files

    $io->Cmd("-l $script" );                                # User script file

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

    #

    #   Specify the library files

    #

    $io->LibList( $name, $pLibs, \&ToolsetLibRecipe );      # Specify the libraries too

    $io->Newline();

    #.. Dependency link,

    #   Create a library dependency file

    #       Create command file to build applicaton dependency list

    #       from the list of dependent libraries

    #

    #       Create makefile directives to include the dependency

    #       list into the makefile.

    #

    $io->DepRules( $pLibs, \&ToolsetLibRecipe, $full );

    $io->LDDEPEND(); 

    #

    #   Add the MAP file to the program package

    #

    PackageProgAddFiles ( $name, $full );

    PackageProgAddFiles ( $name, $img ) if ($img);

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

}

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

#

#   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->Cmd("$obj.$::o" );

}

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

#

#   Generate a linker/depend library recipe.  This is a helper function

#   used within this toolset.

#

#   Arguments:

#       $io         I/O stream

#

#       $target     Name of the target

#

#       $lib        Library specification

#

#       $dp         If building a depend list, the full target name.

#

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

sub ToolsetLibRecipe

{

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

    #

    #   Run time libraries will have a .a suffix

    #   Do not append .lib if this is the case

    #

    $lib .= '.' . $::a unless ( $lib =~ m~\.a$~ );

    if ( !defined($dp) ) {                      # linker

        $io->Cmd("\"@(vpath2,\"$lib\",LIB,\\)\"" );

    } else {                                    # depend

        $io->Cmd( "$dp:\t@(vlib2,\"$lib\",LIB)" );

    }

}

#.. Successful termination

1;