Subversion Repositories DevTools

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

# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

#

# Module name   : mos_mri

# Module type   : Makefile system

# Compiler(s)   : ANSI C

# Environment(s): MOS

#

# Description:

#       MRI 68k/CF toolset for MOS

#       This file provides Toolset initialisation and plugin functions

#       to makelib.pl2

#

# Contents:     MRI 68k/CF rules as used for the MOS

#

# Revision History:

#       12-Feb-04   DDP     Started Work

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

use strict;

use warnings;

#

#   Toolset Global variables

#

my $Toolset_DebugCode;

my $Toolset_DebugData;

my $Toolset_Product = '';

my $Toolset_Production_Only;

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

#   ToolsetInit()

#       Runtime initialisation

#

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

ToolsetInit();

sub ToolsetInit

{

    my( $version, $flavour );

    my $no_defines;

    my( @defines );

    my $board = '';

#.. Parse Toolset arguments

#

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

    $version = 0;                               # Default (not great)

    $flavour = '68k';

    foreach $_ ( @::ScmToolsetArgs ) {

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

            $version = "$1";

        } elsif (/^--68k/) {                    # Compiler flavour

            $flavour = '68k';

        } elsif (/^--coldfire/) {               # Compiler flavour

            $flavour = 'cf';

        } elsif (/^--NoDefines/) {               # Vanila defines

            $no_defines = 1;

        } else {

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

        }

    }

#.. Parse Platform Arguments

#

    foreach $_ ( @::ScmPlatformArgs ) {

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

            $Toolset_Product = $1;

        } elsif (/^--board=(.*)/) {             # Board subtypes

            $board = $1;

        } else {

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

        }

    }

#

#   Is this a ProductionOnly build, then we don't need the debug code and data

#   when building a THX. Determine, if this is a ProductionOnly build.

#

foreach  ( @{$::BUILDINFO{$::ScmPlatform}{ARGS}} )

{

    if ( m~^--OnlyProd~ )

    {

        $Toolset_Production_Only = 1;

        last;

    }

}

#

#   Definitions common to all platforms

#   These will be picked up when no platform has been defined: ie when

#   simply building for MOS68K or MOSCF

#

#   Note: _MICROTEC     is predefined by the compiler

#

    unless ( $no_defines )

    {

        push @defines, 'MOS';

        push @defines, '_MOS';

        push @defines, '_MOS_=1';

        push @defines, '_MOS_PERTH_=1';

        push @defines, 'MICROTEC=1';

        push @defines, 'MRI=1';

        push @defines, 'BIG_ENDIAN=1';

        push @defines, 'CcCpuBigEndian=1';

        push @defines, 'CcSupervisor=$(MODE_CCSUPERVISOR)';

        push @defines, 'CcCpu=$(mri_cpu_code)';

    }

#

#   Platform specific definitions

#   Set default code and data for development purposes only

#   This can be overridden

#

    if ( $Toolset_Product eq "GAK" || $Toolset_Product eq "TPT" )

    {

        # Example only

        #push @defines, '	SSM_DV';

        #push @defines, '	DES_ALIGN_CHECK';

        #push @defines, '	AMCCIF=15';

        #push @defines, '	PACKED=packed';

        if ( $flavour eq  '68k' )

        {

            $Toolset_DebugCode = "08100000H";

            $Toolset_DebugData = "0800800CH";

        }

        else

        {

            $Toolset_DebugCode = "08200000H";

            $Toolset_DebugData = "0800800CH";

        }

    }

    elsif ( $Toolset_Product eq "PCP" )

    {

        $board = "08200000H,0800800CH" if ( $board =~ m/development/i );

        $Toolset_DebugCode = "08100000H";

        $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product eq "VCP" )

    {

        $Toolset_DebugCode = "08100000H";

        $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product eq "TP5" or $Toolset_Product eq "PICP" )

    {

        $board = "08000000H,0400800CH" if ( $board =~ m/green/i );

        $Toolset_DebugCode = "05C00000H";

        $Toolset_DebugData = "0400800CH";

    }

    elsif ( $Toolset_Product eq "SSU" )

    {

    #    $Toolset_DebugCode = "08100000H";

    #    $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product eq "DDU" )

    {

    #    $Toolset_DebugCode = "08100000H";

    #    $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product eq "HCP" )

    {

    #    $Toolset_DebugCode = "08100000H";

    #    $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product eq "OBFTP" )

    {

        $Toolset_DebugCode = "08200000H";

        $Toolset_DebugData = "0800800CH";

    }

    elsif ( $Toolset_Product )

    {

        Message( "mos_mri: Unknown product: $Toolset_Product -- ignored" )

            unless ( $board );

    }

    #

    #   Decode any --board option

    #   This will override any defaults

    #

    if ($board )

    {

        if ( $board =~ m~(0[0-9A-F]+H),(0[0-9A-F]+H)~i )

        {

            $Toolset_DebugCode = $1;

            $Toolset_DebugData = $2;

            Message("Building for a $Toolset_Product DEVELOPMENT board: Code:$Toolset_DebugCode, Data:$Toolset_DebugData");

        }

        else

        {

            Error( "Bad board definition: $board",

                   "Expecting two hex numbers of the form 012345H" );

        }

    }

if ( $Toolset_Product && (! $Toolset_DebugCode || ! $Toolset_DebugData ))

{

    Message( "mos_mri: $Toolset_Product: Debug Code and Data not specified" );

}

#.. Standard.rul requirements

#

    $::s = 'asm';             # Assembler source file

    $::o = 'obj';             # Object file

    $::a = 'lib';             # Library file

    $::so = 'thx';            # Shared library

    $::exe = '.abs';          # Dummy, Cannot generate executables

#.. Toolset configuration

#

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

    $::ScmToolsetGenerate = 0;                    # generate optional

    $::ScmToolsetProgDependancies = 0;            # handle Prog dependancies myself		7 "I:\jats_cbuilder\JATS\MASS_Dev_Infra\core_devl\CFG\TOOLSET\ACEX.PL"

#.. Define MRI environment

#

    #

    #   Define initialisation targets

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

    #

    Init( "mri", "mri2" );

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

    ToolsetDefine ( "# MOS MRI compiler version" );

    ToolsetDefine ( "#" );

    ToolsetDefine ( "mri_ver         = $version" );

    ToolsetDefine ( "mri_type        = $flavour" );

    ToolsetDefine ( "" );

    ToolsetDefine ( "#" );

    ToolsetDefines( "mos_mri_${flavour}.def" );

    ToolsetRules  ( "mos_mri.rul" );

    ToolsetRules  ( "standard.rul" );

    PlatformEntry( "MRI_DEFINES\t=",    "\n", "\\\n\t", "", @defines )

        if ( scalar @defines );

    #

    #   Other toolsets used

    #

    PlatformDefine ("LINT_COFILE\t= MOS_MRI.LNT");

    PlatformDefine ("LINT_PRJ_FILE\t=lint.mri");

    ToolsetRequire( "pclint" );                 # using pclint

#

#   The debug files need to be compiled up with absolute paths to the source files

#   The easiest way to do this is with the makefile rules created with absolute

#   paths. Set a global flag to enable this option

#

    $::UseAbsObjects = 1;

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

    (

        'ccsupervisor'          => { 'MODE_CCSUPERVISOR' , '1' },

        #

        #   When using MOS fast intermodule calls the optimizer will preload commonly

        #   used memory addresses into a register BEFORE the GDP has been correctly set

        #   up. Use the following option to supress this optimisation

        #

        'noglobaloptimization'  => { 'NO_OPT_GLOBAL' , '1' },

        #

        #   To enable 32-bit relative PC addressing on platforms that

        #   don't have this as a default

        #

        'longrelative'    => { 'USE_32BIT_RELATIVE' , '1' },

        'nolongrelative'  => { 'USE_32BIT_RELATIVE' , undef },

    );

    #

    #   Set default options

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

    $::ScmCompilerOpts{'MODE_CCSUPERVISOR'} = '0';

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

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

}

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

#   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 user has specified a Prog or Shared library, then the

    #   tools within this file will need to be able to access

    #   a few external resouces. These will be provided by packages

    #   that should exist

    #

    #

    if ( $#::TESTPROGS >= 0 || $#::PROGS >= 0 || $#::SHLIBS >= 0)

    {

        my %need = ( "brt.exe"          => "TOOL_BRT",

                     "modcrc.exe"       => "TOOL_MODCRC",

                     "rel.exe"          => "TOOL_REL",

                     "vclickpaths.exe"  => "TOOL_VPATHS"

                   );

        my %found = ();

        #

        #   Locate the required files

        #

        for my $program ( keys( %need ))

        {

            if ( my $path = ToolExtensionProgram( $program ) )

            {

                $found{ $need{$program} } = $path;

                delete( $need{$program} );

            }

        }

        ::Error( "Tool program(s) required by toolset not found:",

                  sort( keys %need),

                  "Check that the daf_tools and mos_tools packages are present" )

            if ( scalar keys %need );

        #

        #   Generate the definitions

        #

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

        ToolsetDefine ( "#  The path to tools required to build MOS Programs" );

        ToolsetDefine ( "#" );

        for my $defn ( keys %found )

        {

            ToolsetDefine ( "$defn := $found{$defn}" );

        }

        ToolsetDefine ( "" );

        ToolsetDefine ( "#  The drive path to prefix to the vision click paths" );

        EnvImport( "GBE_DRV" );

        ToolsetDefine ( "GBE_VCLICKDRV = $::GBE_DRV" );

    }

}

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

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

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

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

#

#   Implementation Note:

#   The MRI compilers that are being used have a problem.

#   If the source filename is relative and longer that ~80 characters and the

#   -Gf switch is being used, then the compiler warns that the pathname is

#   too long to be stored in the ABS file. It then stores the relative name to

#   the file in thr ABS file. This confuses visionclick and vclickpaths

#

#   If the source file is an absolute path, then none of these problems

#   occur, BUT the displayed error messages get chopped so that the user

#   cannot determine the file being compiled.

#

#   Solution:

#       * Give the compiler an absolute path name

#       * Display a shortened filename on the JATS output

#

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

sub ToolsetCC

{

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

}

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

#   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\$(CXX)\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\$(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:

#       --xxx                   No arguments currently defined

#

#   Output:

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

#           $(AR)

#

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

sub ToolsetAR

{

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

    my $lib_file = "${name}\$(GBE_TYPE)";

    my $lib_base = "\$(LIBDIR)/$lib_file";

    my $lib_name = "$lib_base.${a}";

    Debug("ToolsetAR");

#.. Parse arguments

#

    foreach $_ ( @$pArgs ) {

        if (/^--/) {

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

        }

    }

#.. Target

#

    MakeEntry( "$lib_name:\t", "", "\\\n\t\t", ".$::o", @$pObjs );

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

}

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

#   ToolsetARLINT( $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:

#       [ $(LIBDIR)/name$_lint:   .... ]

#           $(ARLINT)

#

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

sub ToolsetARLINT

{

    PCLintAR( @_ );

}

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

#   ToolsetARMerge()

#       Generate the recipe to merge libraries.

#       The dependency list is created by the caller.

#

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

sub ToolsetARMerge

{

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

}

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

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

#       This subroutine takes the user options and builds the rules

#       required to link a shared library with any associated stub files

#

#   Arguments:

#       --xxx                   No Arguments currently specified

#

#       Linker specific:

#       --Data                  Generate a Data Module

#       --Debug                 Generate a debug module

#       --DebugCode=nnnnnH      Generate a debug module with code at address

#       --DebugData=nnnnnH      Generate a debug module with data at address

#       --Rel=file              Specify the Release file

#       --Implib=objfile        Specify an import library object

#       --StubOnly              Only generate the stub library

#       --BinaryImage           Generate binary image instead of a THX file

#

#   Output:

#

#       name.thx                - Loadable module

#       name.lib                - Module interface stub library

#       name.abs                - Precursor to .thx

#       name_o.abs              - Used to generate relocation information

#       name_0.abs              - Used to generate relocation information

#

#       name_debug.bdx          - File for debugger

#       name_debug.ab           - File for debugger

#       name_debug.abs          - Precursor to .bdx and .ab files

#

#       This is a very complicated process:

#           Generate stub library

#           Create module header object file

#           Link all at one address

#           Link all at another address

#           Determine relocation information

#           Compile up relocation information

#           Link all with relocation information

#           Create VisionClick debug files

#           Generate CRC over module

#

#   $(LIBDIR)/name.thx $(BINDIR)/name.bdx $(BINDIR)/name.ab :

#                       $(BINDIR)/name.abs

#

#   $(LIBDIR)/name.abs :

#                       objs ....

#                       libs ....

#                       $(OBJDIR)/linker_cmd_file

#

#   $(LIBDIR)/linker_cmd_file :

#                       $(GBE_PLATFORM).mk

#                       ...

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

sub ToolsetSHLD

{

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

    my $module_type = '';

    my $debug_code = $Toolset_DebugCode || 0;

    my $debug_data = $Toolset_DebugData || 0;

    my( $u_rel_file, $rel_file, $head_file, $implib, $stub_only, $bin_image);

    my $pSlibs;

#.. Parse arguments

#

    foreach $_ ( @$pArgs )

    {

    #.. Target specific

    #

    #.. Toolset specific

    #

        if (/^--Data$/) {                       # Generate a data module

            $module_type  = "data";

        } elsif (/^--Acon$/) {                  # Generate an ACON  module

            $module_type  = "acon";

        } elsif (/^--Rel=(.*)/) {               # The base REL file

            $u_rel_file = $1;

        } elsif (/^--Implib=(.*)/) {            # The import library object file

            $implib = $1;

        } elsif (/^--Stubonly/) {               # Only generate the stub library

            $stub_only = 1;

        } elsif (/^--BinaryImage/) {            # Generate binary image instead of a THX file

            $bin_image = 1;

        } elsif (/^--DebugData=(.*)/) {         # Generate a debug module

            $debug_data = $1;

            $module_type  = "debug";

        } elsif (/^--DebugCode=(.*)/) {         # Generate a debug module

            $debug_code = $1;

            $module_type  = "debug";

        } else {

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

        }

    }

#

#   Cannot create binaries unless we know where to place them

#   This error could be detected earlier, but by detecting it only when

#   we need the values so that we can add new product groups without

#   knowning all the details.

#

unless ( $Toolset_Production_Only )

{

    Error( "mos_mri: $Toolset_Product: Debug Code and Data not specified" )

        if ( ! $debug_data || ! $debug_code );

}

#

#   Sanity check

#       - Ensure the use has provided a REL file

#

unless ( $u_rel_file )

{

    $u_rel_file = "$name.rel";

    Warning( "Prog: Rel file not provided. Using $u_rel_file" );

}

#

#   Locate the true path of the provided REL 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

#

    $rel_file = MakeSrcResolve ( $u_rel_file );

#

#   Locate the true path of the head.asm file

#   This WILL be located within an external package as it is provided

#   by the MOS hardware package.

#

    $head_file = MakeSrcResolveExtended ( 1, "head.asm" );

#

#   If we are also creating an import (stub) library then remove

#   the stub library object file from the list of user provided objects

#   Done to allow the use of @OBJS in a library object list

#

if ( $implib )

{

    my @newobjs;

    for ( @$pObjs )

    {

        push @newobjs, $_

            unless ( m~/$implib$~ );

    }

    $pObjs = \@newobjs;

}

#

#   Extend the list of libraries with MOS specific libraries

#   This list may need multiple passes and will be replicated. Do not include

#   the compiler RTL library in this list as it will cause problems. It must be

#   linked last and linked only once.

#

    push( @$pLibs, 'glob' );

#   Create a list of system (RTL) libraries

#   We only want to use the compiler RTL library as a last resort and will only

#   make one pass over it.

#

    push( @$pSlibs, '$(mri_linker_lib)' );

#

#   Create a ABSRuleGenerator

#   This inherits from a a ToolsetPrinter and extends it to

#   allow addition data to be held

#

    my ($io) = ABSRuleGenerator::New( $name, $pObjs, $pLibs, $pSlibs );

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

#

#   Create a stub library to allow inter-module calls

#

if ( $implib )

{

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

    my $stub_lib = "\$(LIBDIR)/${name}\$(GBE_TYPE).${a}";

    #

    #   Rules and recipe to generate the stub library

    #

    #   If the implib was not named in the object list to this SharedLib

    #   then it will not be in OBJSOURCE and will not have a rule

    #

    #

    $::OBJSOURCE{"$name/$implib"} = $::OBJSOURCE{"$implib"}

        unless( $::OBJSOURCE{"$name/$implib"} );

    $io->Prt( "$stub_lib:\t\$(OBJDIR)/$name/$implib.$::o\n" );

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

    $io->Newline();

    #

    #   Files to be cleanup up

    #

    ToolsetGenerate( $stub_lib );

    #

    #   If the THX is being packaged/installed then add the static

    #   stub library to the packaging lists as a static library.

    #   This will allow the stub library to be installed with the

    #   static libraries and thus allow DLL's with mutual imports

    #

    PackageShlibAddLibFiles ($name, $stub_lib );

    #

    #   Add the stub library to the list of libraries being created

    #

    push @::LIBS, $name;

}

#

#   If we are only creating a sub library, then out work is done

#

if ( $stub_only )

{

    Error ("Request for stub library without specifying the Import file")

        unless ($implib);

    return;

}

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

#

#   Create the module header

#   This is a two step process

#       1) Create the head.inc file from the modules REL file

#       2) Compile the head.asm file

#

#   Note: "head.inc" is a fixed filename. It is created on demand

#         and left around

#

    $io->Label( "Module Header", $name );

    $io->Prt( "\$(OBJDIR)/${name}/head.$::o: $head_file $rel_file");

    $io->Prt( "\n\t\$(call AS_HEAD,$rel_file,$head_file,\$(OBJDIR)/${name}/head.$::o,\$(OBJDIR)/${name}/head.inc)\n" );

    $io->Newline();

    ToolsetObj     ( "\$(OBJDIR)/${name}/head" );

    ToolsetGenerate( "\$(OBJDIR)/${name}/head.inc" );

    ToolsetGenerate( "\$(OBJDIR)/head.inc" );

#

#   Create rules and recipes to generate two .abs files that are

#   used to generate relocation information

#

    $io->GenAbsFile( "OBJDIR", "_o", "S[3]", $module_type, "800000H", "100000H" );

    $io->GenAbsFile( "OBJDIR", "_0", "S[3]", $module_type, "400000H", "000000H" );

    #

    #   Create the relocation information from the two .abs files

    #   This file will be used to add to other abs files

    #

    $io->Prt( "\$(OBJDIR)/${name}_rtab_d.asm \$(OBJDIR)/${name}_rtab_cd.asm: BRTROOT=${name}\n" );

    $io->Entry( "\$(OBJDIR)/${name}_rtab_d.asm \$(OBJDIR)/${name}_rtab_cd.asm:\t", "", "\\\n\t\t\$(OBJDIR)/", ".abs ", ( "${name}_o", "${name}_0" ) );

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

    $io->Newline();

    ToolsetGenerate( "\$(OBJDIR)/${name}_rtab_d.asm" );

    ToolsetGenerate( "\$(OBJDIR)/${name}_rtab_cd.asm" );

    #

    #   Rules to allow the two assembler files to be created

    #   Override user assembler flags to control the assembler environment

    #

    $io->Prt( "\$(OBJDIR)/${name}_rtab_d.$::o: ASFLAGS=-fNOPCR -frel32\n");

    $io->Prt( "\$(OBJDIR)/${name}_rtab_d.$::o: \$(OBJDIR)/${name}_rtab_d.asm");

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

    $io->Newline();

    $io->Prt( "\$(OBJDIR)/head.$::o: ASFLAGS=-fNOPCR -frel32\n");

    $io->Prt( "\$(OBJDIR)/${name}_rtab_cd.$::o: ASFLAGS=-fNOPCR -frel32\n");

    $io->Prt( "\$(OBJDIR)/${name}_rtab_cd.$::o: \$(OBJDIR)/${name}_rtab_cd.asm");

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

    $io->Newline();

    ToolsetObj( "\$(OBJDIR)/${name}_rtab_d" );

    ToolsetObj( "\$(OBJDIR)/${name}_rtab_cd" );

#

#   Create rules and recipes to generate the final .abs file which will feed into

#   the required .thx file. this file will now have embedded relocation information

#

    $io->GenAbsFile( "LIBDIR", "\$(GBE_TYPE)", "S[3]", $module_type, "400000H", "000000H", "\$(OBJDIR)/${name}_rtab_cd"  );

#

#   Create rules and recipes to generate a debug-able .abs file

#   This is a totally different beast and is then used to

#   create some debugger friendly files

#

    $io->GenAbsFile( "LIBDIR", "\$(GBE_TYPE)_debug", "IEEE", "debug", $debug_data, $debug_code, "\$(OBJDIR)/${name}_rtab_d" );

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

#

#   VisionClick support

#   Physivcal files will not be generated if the tool it not available

#   Either generate the files or provide phony targets

#

    $io->Label( "VisionClick support", $name );

    $io->Prt( "ifdef VISIONCLICK\n".

              "\$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt ".

              "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.bdx ".

              "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abx ".

              "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.ab: ".

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abs".

              "\n\t\t\$(call VCLICK, \$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abs,\\".

              "\n\t\t               \$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt,\\".

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

              "\nelse".

              "\n.PHONY:\t\$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt".

              "\n.PHONY:\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.bdx".

              "\n.PHONY:\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abx".

              "\n.PHONY:\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.ab".

              "\nendif\n\n" );

    #

    #   Vision Click files for cleanup

    #

    ToolsetGenerate( "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.bdx" );

    ToolsetGenerate( "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.ab" );

    ToolsetGenerate( "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abx" );

    ToolsetGenerate( "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abg" );

    ToolsetGenerate( "\$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt" );

    #

    #   Add the Visionclick files to the package lists

    #   These will only be packaged if VISIONCLICK is defined

    #

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.bdx" , 'defined=VISIONCLICK', 'Class=debug' );

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.ab"  , 'defined=VISIONCLICK', 'Class=debug' );

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abx" , 'defined=VISIONCLICK', 'Class=debug' );

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt", 'defined=VISIONCLICK', 'Class=debug' );

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

#

#   Rules and recipes to create the .THX (.BIN) file

#   This ties together all the previous components

#

#

    my $sh_ext = $bin_image ? 'bin' : $::so;

    $io->Label( "MOS Module", $name );

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

              "\\\n\t\t\$(OBJDIR)/${name}_o.abs " .

              "\\\n\t\t\$(OBJDIR)/${name}_0.abs " .

              "\\\n\t\t\$(OBJDIR)/${name}_rtab_cd.asm " .

              "\\\n\t\t\$(OBJDIR)/${name}_rtab_d.asm " .

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE).abs " .

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abs " .

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_vpaths.txt ".

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.bdx ".

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abx ".

              "\\\n\t\t\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.ab "

            );

    if ( $bin_image)

    {

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

    }

    else

    {

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

    }

    #

    #   Register generated file for cleanup

    #   The MODCRC process generates a .bak file. Ensure that it gets removed

    #

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

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

    #

    #   Specify the files to be packaged as part of the shared library

    #

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

    PackageShlibAddFiles( $name, "\$(LIBDIR)/${name}\$(GBE_TYPE)_debug.abs", 'Class=debug' );

}

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

# package       : ABSRuleGenerator

#

# Description   : Package to contain data to generate rules to create

#                 ABS files.

#

#                 This is implemented as a class to allow blocks of

#                 data to be simply maintained

#

#                 This class ISA ToolsetPrinter too

#

# Parameters    : name      - Basic name of the library

#                 pObjs     - Ref to an array of object files to be linked

#                 pLibs     - Ref to an array of librarus to be linked

#                 pSlibs    - Ref to an array of system libraries to be linked

#                             These libraries will only be linked ONCE

#

package ABSRuleGenerator;

    use vars qw(@ISA);

    @ISA = ("ToolsetPrinter");

sub New

{

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

    my $self = ToolsetPrinter::New();

    $self->{name}  = $name;

    $self->{pObjs} = $pObjs;

    $self->{pLibs} = $pLibs;

    $self->{sLibs} = $pSlibs;

    return bless $self, __PACKAGE__;

}

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

# Function        : GenAbsFile

#

# Description     : Internal helper function to generate an ABS file

#                   with desirable characteristics

#

#                   Note: This function is not within the ToolsetSHLD to

#                         make closure problems obvious

#

# Inputs          : $1      - Name of the output directory (LIBDIR or OBJDIR)

#                   $2      - basename of the output file

#                   $3      - basename sufix

#                   $4      - Type of output IEEE /S[3]

#                   $5      - Kind of module - "acon", "data", "debug" or ""

#                   $6      - Base of the data segment

#                   $7      - Base of the code segment

#                   $8      - Extra (internal) object file to be linked in

#

# Returns         :

#

sub GenAbsFile

{

    my ( $io, $dir, $suf, $otype, $kind, $data_base, $code_base, $eObjs ) = @_;

    my $name  = $io->{'name'};

    my $pLibs = $io->{'pLibs'};

    my $pSlibs = $io->{'sLibs'};

    my $lib = $name . $suf;

    #

    #   Generate a full list of object files

    #

    my @allObjs = @{$io->{'pObjs'}};

    push @allObjs, $eObjs

        if ( $eObjs);

#

#.. 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 LDABS recipe

#

    $io->Reset();                                   # Reset internal state

    $io->SetTag( "${lib}_shld" );                   # macro tag

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

    $io->Cmd("FORMAT      $otype" );

    $io->Cmd("CHIP	    \$(mri_cpu_type)" );

    $io->Cmd("LISTMAP     CROSSREF,INTERNALS,PUBLICS" );

    $io->Cmd("DEBUG_SYMBOLS" )        if ( $kind eq "debug" );

    unless ( $kind eq "acon" || $kind eq "data" )

    {

        $io->Cmd("MERGE vars  StartPixInit,pixinit,EndPixInit" );

        $io->Cmd("MERGE vars  StartInitFini,initfini,EndInitFini" );

        $io->Cmd("MERGE vars  cxx_rtti,cxx_edt" );

        $io->Cmd("INITDATA    vars" );

        $io->Cmd("INDEX       ?A5,zerovars" );

        $io->Cmd("EXTERN      __mosSoftTrap" );

    }

    if ( $kind eq "data" )

    {

        $io->Cmd("SECT        header = 0H" );

        $io->Cmd("ORDER       header,ascode,code,const" );

        $io->Cmd("ORDER       modtitle,lastsync" );