Subversion Repositories DevTools

# -*- mode: perl; tabs: 8; indent-width: 4; show-tabs: yes; -*-

#

# Module name   : GCC

# Module type   : Makefile system

# Compiler(s)   : ANSI C

# Environment(s): GCC

#

# Description:

#       GCC C/C++ toolset

#

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

use strict;

use warnings;

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

#   Configuration information

#   Cross reference from CrossCompiler Alias to actual paths

#   Structure:

#   Hash reference: Array of toolchain information

#           Root of compiler

#           Path to gcc

#           Path to ar

#

#

my %ToolsetConfig = (

    #

    #   Preferred version of the embedded toolchain

    #

    'i386-unknown-linux-gnu'    => ['/opt/crosstool/gcc-4.1.1-glibc-2.5/i586-unknown-linux-gnu',

                                    'bin/i586-unknown-linux-gnu-gcc' ],

    'arm-9tdmi-linux-gnu'       => ['/opt/crosstool/gcc-4.1.1-glibc-2.5/arm-9tdmi-linux-gnu',

                                    'bin/arm-9tdmi-linux-gnu-gcc' ],

    'powerpc-603e-linux-gnu'    => ['/opt/crosstool/gcc-4.1.1-glibc-2.5/powerpc-603e-linux-gnu',

                                    'bin/powerpc-603e-linux-gnu-gcc'],

    'arm-926ejs-linux-gnueabi'  => ['/opt/crosstool/gcc-4.4.3-glibc-2.9/arm-926ejs-linux-gnueabi',

                                    'bin/arm-926ejs-linux-gnueabi-gcc' ],

    #

    #   Old (not to be used) version of the embedded toolchain

    #   This was depricated in favor of gcc-4.1.1-glibc-2.5

    #   It is not possible to reproduce old packages using the old compiler

    #   This is a known issue

    #

    'i386-unknown-linux-gnu.glibc-2.3.2' => ['/opt/crosstool/gcc-4.1.0-glibc-2.3.2/i386-unknown-linux-gnu',

                                 'bin/i386-unknown-linux-gnu-gcc' ],

    'arm-9tdmi-linux-gnu.glibc-2.3.2'    => ['/opt/crosstool/gcc-4.1.0-glibc-2.3.2/arm-9tdmi-linux-gnu',

                                 'bin/arm-9tdmi-linux-gnu-gcc' ],

    #

    #   Not too sure where this is used

    #

    'armv4l-unknown-linux-gcc' => [ '/opt/host/armv4l',

                                    'bin/armv4l-unknown-linux-gcc' ],

    #

    #   The compiler for the current local machine

    #

    'i386-unknown-linux-gcc' => [ '/opt/host/i386',

                                  'bin/i386-unknown-linux-gcc' ],

    );

#

#   Cross reference from GCCTarget to GBE_MACHTYPE for which it can

#   build using the 'native gcc'. This is NOT the preferred mode of operation

#   as the compiler is not as controlled as the cross compilers.

#

my %NativeCompilers = (

    'Linux i386'       => 'linux_i386',

    );

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

#   ToolsetInit()

#       Runtime initialisation

#

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

ToolsetInit();

sub ToolsetInit

{

    my( $GCCTarget, @GCCToolchain, $GCCRoot, $GCCBin, $GCCAr );

    my( $arg_alias, $tools_found );

#.. Toolset configuration

#

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

    $::ScmToolsetGenerate = 0;                  # GEN generate optional

    $::ScmToolsetCompilerPath = 1;              # Exports Compiler path to makefile via SCM_COMPILERPATH

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

#.. Standard.rul requirements

#

    $::s = "asm";

    $::o = "o";

    $::so = "so";

    $::a = "a";

    $::exe = "";

#.. Parse arguments

#

    foreach $_ ( @::ScmToolsetArgs ) {

        if (/^--Target=(.*)/) {                 # OS Version

            $GCCTarget = "$1";

        } elsif (/^--CrossAlias=(.*)/) {        # CrossCompiler target-alias

            $arg_alias = $1;

        } else {

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

        }

    }

    foreach $_ ( @::ScmPlatformArgs ) {

        if (/^--product=(.*)/) {                # GBE product

        } else {

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

        }

    }

    Error ("TOOLSET/gcc - Target undefined" )

        unless ($GCCTarget);

#.. Cross compile support

#

#   Toolchain=root,[bin]

#

    if ( $arg_alias )

    {

        if ( exists $ToolsetConfig{ $arg_alias } )

        {

            @GCCToolchain = @{$ToolsetConfig{ $arg_alias }};

            $tools_found = (-d $GCCToolchain[0]);

            Warning ("gcc toolset: CrossPlatform toolchain not found for: $arg_alias",

                     "Path: $GCCToolchain[0]" ) unless $tools_found;

        }

        else

        {

            Error("gcc toolset: CrossPlatform Alias not configured: $arg_alias");

        }

    }

    #

    #   If no Cross compiler toolchain is found (preferred method), then attempt

    #   to match a native compiler. Only known targets allow a native build

    #

    unless ( $tools_found )

    {

        if ( exists ( $NativeCompilers{$GCCTarget} ))

        {

            if ( $NativeCompilers{$GCCTarget} eq $::GBE_MACHTYPE )

            {

                $tools_found = 1;

                @GCCToolchain = ();

            }

        }

    }

    #

    #   Must have a toolset by now, either a cross compiler or Native

    #

    Error ("gcc toolset: Toolchain not found for: $GCCTarget" )

        unless ( $tools_found );

    if ( @GCCToolchain )

    {

        #

        #   Parse GCCToolchain. Potentially three parts

        #   [0] - GCCRoot - Location to find the effective /usr/include directory

        #   [1] - GCCBin  - Path to the gcc executable

        #                   If relative, then its relative to GCCRoot

        #   [2] - GCCAr   - Path to the ar executable

        #                   If relative, then its relative to GCCRoot

        #                   If not defined then its the same as GCCBin with gcc replaced with ar

        #

        $GCCRoot = $GCCToolchain[0];

        #   GCC_CC definition

        #

        if ( $GCCToolchain[1] )

        {                                           # user specification

            if ( substr($GCCToolchain[1],0,1) ne "/") {

                $GCCBin = $GCCToolchain[0].'/'.$GCCToolchain[1];

            } else {

                $GCCBin = $GCCToolchain[1];         # abs path

            }

        }

        else

        {                                           # default

            $GCCBin = $GCCToolchain[0] . '/bin/gcc';

        }

        #   GCC_AR definition

        #

        if ( defined($GCCToolchain[2]) && $GCCToolchain[2] )

        {                                           # user specification

            if ( substr($GCCToolchain[2],0,1) ne "/") {

                $GCCAr = $GCCToolchain[0].'/'.$GCCToolchain[2];

            } else {

                $GCCAr = $GCCToolchain[2];          # abs path

            }

        } 

        else 

        {                                           # default, base on GCCBin

            $GCCAr = substr($GCCBin,0,length($GCCBin)-3)."ar";

        }

    }

    else

    {

        $GCCRoot = "/usr";

        $GCCBin = "gcc";

        $GCCAr = "ar";

    }

#.. Define GCC environment

#

    PlatformDefine( "

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

# GCC toolchain definitions 

#

#..");

    PlatformDefine( "GCC_TARGET\t".     ":=$GCCTarget" );

    PlatformDefine( "GCC_ROOT\t".       ":=$GCCRoot" );

    PlatformDefine( "GCC_CC\t\t".       ":=$GCCBin" );

    PlatformDefine( "GCC_AR\t\t".       ":=$GCCAr" );

    PlatformDefine( "" );

    #

    #   Required since this toolset advertises: ScmToolsetCompilerPath

    #

    PlatformDefine( "SCM_COMPILERPATH\t\t".       ":=$GCCBin" );

#.. Piece the world together

#

    Init( "gcc" );

    ToolsetDefines( "gcc.def" );

    ToolsetRules( "gcc.rul" );

    ToolsetRules( "standard.rul" );

#   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 =

    (

        #

        #   Control the thread model to use

        #   This will affect the compiler options and the linker options

        #

        'staticprogs'        => { 'STATIC_PROGS' , '1' },      # Progams link staticlly

        'no_staticprogs'     => { 'STATIC_PROGS' , undef },    # Default

    );

    #

    #   Set default options

    #

    $::ScmCompilerOpts{'STATIC_PROGS'} = undef;

}

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

#   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 ) = @_;

    my( $cflags, $file ) = "";

    foreach $_ ( @$pArgs ) {

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

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

        } else {

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

        }

    }

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

    if ( $cflags )

    {                                           # object specific CFLAGS

        MakePadded( 4, "\$(OBJDIR)/$obj.$::o:" );

        MakePrint( "\tCFLAGS +=$cflags\n" );

    }

    $file = StripExt( $obj );                   # Metric working file

    ToolsetGenerate( "\$(OBJDIR)/$file.met" );

}

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

#   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

{

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

    my( $cflags, $file ) = "";

    foreach $_ ( @$pArgs ) {

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

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

        } else {

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

        }

    }

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

    if ( $cflags )

    {                                           # object specific CFLAGS

        MakePadded( 4, "\$(OBJDIR)/$obj.$::o:" );

        MakePrint( "\tCXXFLAGS +=$cflags\n" );

    }

    $file = StripExt( $obj );                   # Metric working file

    ToolsetGenerate( "\$(OBJDIR)/$file.met" );

}

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

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

}

sub ToolsetASDepend

{

}

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

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

#

#       name_ld += ...  Linker command file

#           :

#

#       name_dp += ...  Dependency list

#           :

#

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

sub ToolsetAR

{

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

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

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

    }

#.. Target

#

    MakePrint( "#.. Library ($name)\n\n" );     # label

    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( $name, \@args, \@libs )

#       This subroutine takes the user options and builds the rules

#       required to build the library 'name' by merging the specified

#       libaries

#

#   Arguments:

#       --xxx                   No arguments currently defined

#

#   Output:

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

#           ...

#

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

sub ToolsetARMerge

{

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

}

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

#   ToolsetSHLD( $name, \@args, \@objs, \@libraries, $ver )

#       This subroutine takes the user options and builds the rules

#       required to link the program 'name'.

#

#   Arguments:

#   n/a

#

#   Output:

#       $(LIBDIR)/name:     $(LIBDIR)/shared

#           ln -s $shared $name

#

#       $(LIBDIR)/name.dep: $(GBE_OBJDIR)

#       $(LIBDIR)/name.dep: $(GBE_LIBDIR)

#       $(LIBDIR)/name.dep: $(GBE_PLATFORM).mk

#           $(SHLDDEPEND)

#

#       $(LIBDIR)/shared:   SHNAME=name

#       $(LIBDIR)/shared:   SHBASE=base

#       $(LIBDIR)/shared:   $(LIBDIR)/name.dep  \

#           $(OBJECTS)

#                           

#       ifneq "$(findstring $(IFLAG),23)" ""

#       -include            "$(LIBDIR)/name.dep"

#       endif

#

#       name_ld += ...

#           :

#

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

sub ToolsetSHLD

{

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

    my( $shared, $def, $def_pref, $multi_scan );

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

        if (/^--Def=(.*?)(\,(.*))?$/) {         # Library definition

            #

            #   Locate the Def file.

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

            #   Otherwise the user will have to use Src to locate the file

            #

            $def = MakeSrcResolve($1);

            $def_pref = '';

            if ( $1 =~ m~\.def$~ ) {

                $def_pref = '--version-script='; # Old def file

            }

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

            $multi_scan = 1;

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

            $multi_scan = 0;

        } else {

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

        }

    }

#.. Full name of shared library

#

    $shared = "$name\$(GBE_TYPE).$::so.$ver";

#.. Install and package the shared libraries that are generated

#

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE).$::so" );

    PackageShlibAddFiles( $name, "\$(LIBDIR)/$shared" );

#.. Cleanup rules

#

#   map     Map file

#   ln      Link from LIBDIR to BINDIR

#

    ToolsetGenerate( "\$(LIBDIR)/${name}.map" );

    ToolsetGenerate( "\$(LIBDIR)/${shared}" );

    ToolsetGenerate( "\$(BINDIR)/${shared}" );

#.. Build rules

#

#   name        Base name

#   shared      Library name, includes GBE_TYPE specification

#

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

    my $dep = $io->SetShldTarget($shared);

    $io->Label( "Shared library", $name );

    $io->Prt( "\$(LIBDIR)/${name}\$(GBE_TYPE).$::so:\t\\\n" .

              "\t\t\$(GBE_BINDIR)\\\n" .

              "\t\t\$(LIBDIR)/${shared}\n" .

              "\t\@(rm -f \$@; ln -s ./$shared \$@)\n" .

              "\t\@(rm -f \$(BINDIR)/$shared; ln -s ../\$(LIBDIR)/$shared \$(BINDIR)/$shared)\n\n" );

    $io->Prt( "\$(LIBDIR)/${shared}:\tSHBASE=${name}\n" );

    $io->Prt( "\$(LIBDIR)/${shared}:\tSHNAME=${shared}\n" );

    $io->Prt( "\$(LIBDIR)/${shared}: \\\n\t\t$dep" );

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

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

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

#.. Linker command file

#

#       Now the fun part... piecing together a variable $(name_shld)

#       which ends up in the command file.

#

    $io->SetTag( "${name}_shld" );              # command tag

    $io->SetTerm( "\n" );

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

                                                # object list

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

    ToolsetLibStd( $pLibs );                    # push standard libraries

    $io->Cmd( "-Wl,$def_pref$def" ) if ($def);

    $io->Cmd( "-Wl,--start-group" ) if ($multi_scan);

    $io->LibList( $name, $pLibs, \&ToolsetLibRecipe );

    $io->Cmd( "-Wl,--end-group" ) if ($multi_scan);

    $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, "\$(LIBDIR)/${shared}" );

    $io->SHLDDEPEND($name, $shared);

}

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

# Function        : ToolsetLD

#

# Description     : Takes the user options and builds the rules required to

#                   link the program 'name'.

#

# Inputs          : $name           - base name of the program

#                   $pArgs          - Ref to program arguments

#                   $pObjs          - Ref to program objects

#                   $pLibs          - Ref to program library list

#

# Returns         : Nothing

#

# Output:         : Rules and recipes to create a program

#                       Create program rules and recipes

#                       Create linker input script

#                       Create library dependency list

#                       Include library dependency information

#

sub ToolsetLD

{

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

    my $static = $::ScmCompilerOpts{'STATIC_PROGS'};

    my $multi_scan;

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

        if ( m/^--Static$/ ) {

            $static = 1;

        } elsif ( m/^--Shared/ ) {

            $static = 0;

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

            $multi_scan = 1;

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

            $multi_scan = 0;

        } else {

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

        }

    }

#.. Names of programs and components

#

    my $base = "\$(BINDIR)/${name}";

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

    my $map  = $base . '.map';

    my $ld  =  $base . '.ld';

#.. Cleanup rules

#

    ToolsetGenerate( $ld );

    ToolsetGenerate( $map );

#.. Build rules

#

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

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

    $io->Prt( "$full : $dep " );

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

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

#.. Linker command file

#

#       Now the fun part... piecing together a variable $(name_ld)

#       which ends up in the command file.

#

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

    $io->SetTerm( "\n" );

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

    $io->Cmd( "-static" ) if ($static);         # Link as a static program

                                                # object list

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

    ToolsetLibStd( $pLibs );                    # push standard libraries

                                                # library list

    $io->Cmd( "-Wl,--start-group" ) if ($multi_scan);

    $io->LibList( $name, $pLibs, \&ToolsetLibRecipe );

    $io->Cmd( "-Wl,--end-group" ) if ($multi_scan);

    $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, $base );

    $io->LDDEPEND();

#.. Package up the program and other artifacts

#

    PackageProgAddFiles ( $name, $full );

}

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

#

#   Push standard "system" libraries. This is a helper function

#   used within this toolset.

#

#   Arguments:

#       $plib       Reference to library array.

#

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

sub ToolsetLibStd

{

}

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

#

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

}

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

#

#   Parse a linker lib list

#   This is a helper function used within this toolset

#

#   Arguments:

#       $target     Name of the target

#

#       $lib        Library specification

#

#       $tag        Tag (user specified)

#

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

#

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

sub ToolsetLibRecipe

{

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

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

        $lib =~ s/^lib//;                       # .. remove leading 'lib'

        $io->Cmd( "-l$lib" );

    } else {                                    # depend

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

    }

}

#.. Successful termination

1;