Subversion Repositories DevTools

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

#

# Module name   : Sunworks

# Module type   : Makefile system

# Compiler(s)   : ANSI C

# Environment(s): CC

#   

# Description:

#   Sunworks C/C++ toolset

#

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

use strict;

use warnings;

use JatsError;

#

#   Table to provide the location of SUNWSPRO_SC

#   This is hardcoded ( not good ) based on build machine

#

#       Key: build machine type

#     Value: Per machine-type data

#

#   Per machine type data is a hash

#       compiler        - Path to the compiler

#       misalign        - Path (relative to compiler) to the misalign obj file

#                         If not present then misalign not supported

#

my %SunProLocation = (

    'solaris10_sparc32' => { 'compiler' => '/opt/SUNWspro/prod',

                             'misalign' => 'lib/misalign.o',

                             'archiver' => '/usr/ccs/bin',

                           },

    'solaris10_x86'     => { 'compiler' => '/opt/SUNWspro/prod',

                             'archiver' => '/usr/ccs/bin',

                           },

    'sparc'             => { 'compiler' => '/opt/SUNWspro/WS6U1',

                             'misalign' => 'lib/misalign.o',

                             'archiver' => '/usr/ccs/bin',

                           },

    );

#

#   Globals

#

our $GBE_MACHTYPE;

our $s;

our $o;

our $a;

our $so;

our $exe;

our @ScmToolsetArgs;

our @ScmPlatformArgs;

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

#   ToolsetInit()

#       Runtime initialisation

#

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

ToolsetInit();

my $toolsetccdepend      = 0;

sub ToolsetInit

{

#.. Standard.rul requirements

#   

    $s = 'asm';

    $o = 'o';

    $a = 'a';

    $so = 'so';

    $exe = '';

#.. Toolset configuration

#

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

    $::ScmToolsetGenerate = 0;                    # GEN generate optional

    my $ScmToolTarget = '';

    #

    #   Toolset args

    #

    foreach $_ ( @ScmToolsetArgs ) {

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

            $ScmToolTarget = $1;

        } else {

            Message( "sunworks toolset: unknown toolset option $_ -- ignored" );

        }

    }

    #

    #   Platform arguments

    #

    foreach $_ ( @ScmPlatformArgs ) {

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

        } else {

            Message( "sunworks toolset: unknown platform argument $_ -- ignored" );

        }

    } 

#.. Define environment

#    

    Init( "sunworks" );

    ToolsetDefines( "sunworks.def" );

    ToolsetRules( "sunworks.rul" );

    ToolsetRules( "standard.rul" );

#.. Cleanup rules

#

    ToolsetDirTree( "\$(LIBDIR)/SunWS_cache" );

    ToolsetDirTree( "\$(OBJDIR)/SunWS_cache" );

    ToolsetDirTree( "\$(BINDIR)/SunWS_cache" );

    ToolsetDirTree( "./SunWS_cache" );

    AddLibDir( '*', '/usr/lib', '--NoWarn', '--System' );

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

    (

        #

        #   Control the thread model to use

        #   This will affect the compiler options and the linker options

        #

        'multithread'        => { 'THREADMODE' , '1' },      # -mt (default)

        'multithread_none'   => { 'THREADMODE' , undef },    # (none)

        'no_multithread'     => { 'THREADMODE' , undef },    # (none)

        'no_misalign'        => { 'MISALIGN', undef },       # (default)

        'misalign'           => { 'MISALIGN', '1' },

    );

    #

    #   Set default options

    #

    $::ScmCompilerOpts{'THREADMODE'} = '1';

    #

    #   Ensure that we know where the compiler and archiver are

    #

    if ( exists $SunProLocation{$GBE_MACHTYPE} )

    {

        my $sunpro = $SunProLocation{$GBE_MACHTYPE}{compiler};

        ToolsetDefine ( "SUNWSPRO_SC  = $sunpro" );

        my $ar_path = $SunProLocation{$GBE_MACHTYPE}{archiver};

        ToolsetDefine ( "AR_PATH  = $ar_path" );

    }

    else

    {

        Error ("SunWorks compiler not configured for this type of machine",

               "GBE_MACHTYPE: $GBE_MACHTYPE" );

    }

    #

    #   Specify definitions to support 32 and 64 bit compilation

    #   Default operation is only intended for existing (solaris8) work

    #

    if ( $ScmToolTarget )

    {

        ToolsetDefine ( "COMPILE32  = 1" ) if ($ScmToolTarget =~ m/32$/);

        ToolsetDefine ( "COMPILE64  = 1" ) if ($ScmToolTarget =~ m/64$/);

    }

}

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

#   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

{

    #

    #   If the machine does not support misalignment and the user has requested

    #   it, then kill the option - it makes life easier later.

    #

    unless ( exists ($SunProLocation{$GBE_MACHTYPE}{misalign}) )

    {

        if ( $::ScmCompilerOpts{'MISALIGN'} )

        {

            Warning("Platform does not support MISALIGN option. Will be ignored");

            delete $::ScmCompilerOpts{'MISALIGN'};

        }

    }

}

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

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

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

    if ( $cflags )

    {                                           # object specific CFLAGS

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

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

    }

}

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

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

    $toolsetccdepend = 1;

}

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

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

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

    foreach ( @$pArgs ) {

        Debug( "option:    $_" );

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

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

            Debug( "CCX:    as shared object" );

        } else {

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

        }

    }

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

    if ( $cflags )

    {                                           # object specific CFLAGS

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

        MakePrint( "\tCXXFLAGS +=$cflags\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

{

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

        if ( $toolsetccdepend == 0 );

}

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

#   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

{

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

    foreach $_ ( @$pArgs ) {

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

    }

    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:

#

#   Options:

#       n/a

#

#   Output:

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

#           $(AR)

#

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

sub ToolsetAR

{

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

#.. Parse arguments

#

    foreach $_ ( @$pArgs ) {

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

    }

#.. Standard library builds

#

    MakeEntry( "\$(LIBDIR)/$name\$(GBE_TYPE).${a}:\t",

                  "", "\\\n\t\t", ".${o} ", @$pObjs );

    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:

#       --WithMisalign

#

#   Output:

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

#               ln -s $shared $name

#

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

#               $(SHLDDEPEND)

#

#       $(LIBDIR)/shared:       SHLIB=name

#       $(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, $merge_obj );

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

        if ( m~^--WithMisalign~ ) {

            if ( exists $SunProLocation{$GBE_MACHTYPE}{misalign} ) {

                $merge_obj = $SunProLocation{$GBE_MACHTYPE}{misalign};

            }

        } 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

#

#   dep     Dependency file

#   map     Map file

#   ln      Link from LIBDIR to BINDIR

#

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

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

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

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

    ToolsetDirTree( "\$(LIBDIR)/${name}/SunWS_cache" );

    ToolsetDirTree( "\$(OBJDIR)/${name}/SunWS_cache" );

#.. Build rules

#

#   name        Base name

#   shared      Library name, includes GBE_TYPE specification

#

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

    $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->SHLDDEPEND($name, $name, $shared);     # std SHLDDEPEND rules

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

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

    $io->Entry( "\$(LIBDIR)/${shared}:\t", "", "\\\n\t\t", ".$::o", @$pObjs );

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

    $io->Prt( "\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}_ld" );              # command tag

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

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

                                                # object list

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

    if ( $merge_obj )

    {

        $io->PrtLn( "ifdef MISALIGN" );

        $io->Cmd( "\$(SUNWSPRO_SC)/$merge_obj" );

        $io->PrtLn( "endif" );

    }

    ToolsetLibStd( $pLibs );                    # push standard libraries

                                                # library list

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

    $io->Newline();

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

    $io->SetTerm();

    $io->DepRules( $name, $pLibs,               # library depends rules

        \&ToolsetLibRecipe, "$shared" );

    $io->Newline();

}

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

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

#       This subroutine takes the user options and builds the rules

#       required to link the program 'name'.

#

#   Arguments:

#       n/a

#

#   Output:

#       $(BINDIR)/name:

#                       $(BINDIR)/name.dep

#           $(LD)

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

#               $(LDDEPEND)

#

#       ifeq "$(IFLAG)" "3"

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

#       endif

#

#       name_ld += ...

#           :

#

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

sub ToolsetLD

{

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

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

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

    }

#.. Cleanup rules

#

#       dep     Dependency file

#       map     Mape file

#

    ToolsetGenerate( "\$(BINDIR)/${name}.dep" );

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

#.. Build rules

#

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

    $io->Prt( "\\\n\t\t\$(BINDIR)/${name}.dep\n" .

              "\t\$(LD)\n\n" );

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

    $io->Newline();

#.. 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->ObjList( $name, $pObjs, \&ToolsetObjRecipe );  # object list

    ToolsetLibStd( $pLibs );                            # push standard libraries

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

    $io->Newline();

#.. 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,                       # library depends rules

        \&ToolsetLibRecipe, "\$(BINDIR)/${name}" );

    $io->Newline();

}

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

#

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

    }

}

#.. Successful termination

1;