build/src/tools/gcc.jam

# Copyright 2001 David Abrahams.
# Copyright 2002-2006 Rene Rivera.
# Copyright 2002-2003 Vladimir Prus.
#  Copyright (c) 2005 Reece H. Dunn.
# Copyright 2006 Ilya Sokolov.
# Copyright 2007 Roland Schwarz
# Copyright 2007 Boris Gubenko.
#
# Distributed under the Boost Software License, Version 1.0.
#    (See accompanying file LICENSE_1_0.txt or copy at
#          http://www.boost.org/LICENSE_1_0.txt)

import toolset : flags ;
import property ;
import generators ;
import os ;
import type ;
import feature ;
import "class" : new ;
import set ;
import common ;
import errors ;
import property-set ;
import pch ;
import regex ;

if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
{
    .debug-configuration = true ;
}


feature.extend toolset : gcc ;

import unix ;
toolset.inherit-generators gcc : unix : unix.link unix.link.dll ;
toolset.inherit-flags gcc : unix ;
toolset.inherit-rules gcc : unix ;

generators.override gcc.prebuilt : builtin.prebuilt ;
generators.override gcc.searched-lib-generator : searched-lib-generator ;

# Target naming is determined by types/lib.jam and the settings below this
# comment.
#
# On *nix:
#     libxxx.a     static library
#     libxxx.so    shared library
#
# On windows (mingw):
#     libxxx.lib   static library
#     xxx.dll      DLL
#     xxx.lib      import library
#
# On windows (cygwin) i.e. <target-os>cygwin
#     libxxx.a     static library
#     xxx.dll      DLL
#     libxxx.dll.a import library
# 
# Note: user can always override by using the <tag>@rule
#       This settings have been choosen, so that mingw
#       is in line with msvc naming conventions. For
#       cygwin the cygwin naming convention has been choosen.

# Make the "o" suffix used for gcc toolset on all
# platforms
type.set-generated-target-suffix OBJ : <toolset>gcc : o ;
type.set-generated-target-suffix STATIC_LIB : <toolset>gcc <target-os>cygwin : a ;

type.set-generated-target-suffix IMPORT_LIB : <toolset>gcc <target-os>cygwin : dll.a ;
type.set-generated-target-prefix IMPORT_LIB : <toolset>gcc <target-os>cygwin : lib ;

import rc ;

# Initializes the gcc toolset for the given version.
# If necessary, command may be used to specify where the compiler
# is located.
# The parameter 'options' is a space-delimited list of options, each
# one being specified as <option-name>option-value. Valid option names
# are: cxxflags, linkflags and linker-type. Accepted values for linker-type
# are gnu and sun, gnu being the default.
# Example:
#   using gcc : 3.4 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;
rule init ( version ? : command * : options * )
{
    # Information about the gcc command...
    #   The command.
    local command = [ common.get-invocation-command gcc : g++ : $(command) ] ;
    #   The root directory of the tool install.
    local root = [ feature.get-values <root> : $(options) ] ;
    #   The bin directory where to find the command to execute.
    local bin ;
    #   The flavor of compiler.
    local flavor = [ feature.get-values <flavor> : $(options) ] ;
    #   Autodetect the root and bin dir if not given.
    if $(command)
    {
        bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ;
        root ?= $(bin:D) ;
    }
    #   Autodetect the version and flavor if not given.
    if $(command)
    {
        # The 'command' variable can have multiple elements. When calling
        # the SHELL builtin we need a single string.
        local command-string = $(command:J=" ") ;
        local machine = [ MATCH "^([^ ]+)"
            : [ SHELL "$(command-string) -dumpmachine" ] ] ;
        version ?= [ MATCH "^([0-9.]+)"
            : [ SHELL "$(command-string) -dumpversion" ] ] ;
        switch $(machine:L)
        {
            case *mingw* : flavor ?= mingw ;
        }
    }

    local condition ;
    if $(flavor)
    {
        condition = [ common.check-init-parameters gcc
            : version $(version)
            : flavor $(flavor)
            ] ;
    }
    else
    {
        condition = [ common.check-init-parameters gcc
            : version $(version)
            ] ;
    }
    
    common.handle-options gcc : $(condition) : $(command) : $(options) ;
    
    local linker = [ feature.get-values <linker-type> : $(options) ] ;
    if ! $(linker) {
        
        if [ os.name ] = OSF
        {
            linker = osf ;
        }
        else if [ os.name ] = HPUX
        {
            linker = hpux ;
        }
        else
        {                            
            linker = gnu ;
        }        
    }
    init-link-flags gcc $(linker) $(condition) ;
    
    
    # If gcc is installed in non-standard location, we'd need to
    # add LD_LIBRARY_PATH when running programs created with it
    # (for unit-test/run rules).       
    if $(command)
    {
        # On multilib 64-bit boxes, there are both 32-bit and 64-bit
        # libraries and all must be added to LD_LIBRARY_PATH. The linker
        # will pick the right onces.
        # Note that we don't provide a clean way to build 32-bit binary
        # with 64-bit compiler, but user can always pass -m32 manually.
        local lib_path = $(root)/bin $(root)/lib $(root)/lib32 $(root)/lib64 ;
        if $(.debug-configuration)
        {
            ECHO notice: using gcc libraries :: $(condition) :: $(lib_path) ;
        }
        flags gcc.link RUN_PATH $(condition) : $(lib_path) ;
    }   

    #~ If it's not a system gcc install we should adjust the various
    #~ programs as needed to prefer using the install specific versions.
    #~ This is essential for correct use of MinGW and for cross-compiling.
    
    #~ - The archive builder.
    local archiver =
        [ common.get-invocation-command gcc
            : ar : [ feature.get-values <archiver> : $(options) ] : $(bin) : search-path ] ;
    flags gcc.archive .AR $(condition) : $(archiver[1]) ;
    if $(.debug-configuration)
    {
        ECHO notice: using gcc archiver :: $(condition) :: $(archiver[1]) ;
    }
    
    #~ - The resource compiler.
    local rc =
        [ common.get-invocation-command-nodefault gcc
            : windres : [ feature.get-values <rc> : $(options) ] : $(bin) : search-path ] ;
    local rc-type =
        [ feature.get-values <rc-type> : $(options) ] ;
    rc-type ?= windres ;
    if ! $(rc)
    {
        #~ If we can't find an RC compiler we fallback to a null RC compiler
        #~ that creates empty object files. This allows the same Jamfiles
        #~ to work across the board. The null RC uses the assembler to create
        #~ the empty objects, so configure that.
        rc =
            [ common.get-invocation-command gcc
                : as : : $(bin) : search-path ] ;
        rc-type = null ;
    }
    rc.configure $(rc) : $(condition) : <rc-type>$(rc-type) ;
}

if [ os.name ] = NT
{
    # This causes single-line command invocation to not go through
    # .bat files, thus avoiding command-line length limitations
    JAMSHELL = % ;  
}

generators.register-c-compiler gcc.compile.c++ : CPP : OBJ : <toolset>gcc ;
generators.register-c-compiler gcc.compile.c : C : OBJ : <toolset>gcc ;
generators.register-c-compiler gcc.compile.asm : ASM : OBJ : <toolset>gcc ;

# pch support

# The compiler looks for a precompiled header in each directory just 
# before it looks for the include file in that directory.
# The name searched for is the name specified in the #include directive 
# with ".gch" suffix appended.
# The logic in gcc-pch-generator will make sure that BASE_PCH suffix is
# appended to full name of the header.

type.set-generated-target-suffix PCH : <toolset>gcc : gch ;

# GCC-specific pch generator.
class gcc-pch-generator : pch-generator
{
    import project ;
    import property-set ;
    import type ;

    rule run-pch ( project name ? : property-set : sources + )
    {
        # Find the header in sources. Ignore any CPP sources.
        local header ;
        for local s in $(sources)
        {
            if [ type.is-derived [ $(s).type ] H ] 
            {
                header = $(s) ;
            }            
        }
                
        # error handling
        # base name of header file should be the same as the base name 
        # of precompiled header.
        local header-name = [ $(header).name ] ;
        local header-basename = $(header-name:B) ;
        if $(header-basename) != $(name)
        {
            local location = [ $(project).project-module ] ;
            errors.user-error "in" $(location)": pch target name `"$(name)"' should be the same as the base name of header file `"$(header-name)"'" ;
        }

        local pch-file =
            [ 
              generator.run $(project) $(name)
                : $(property-set)
                : $(header)
            ]
          ;

        # return result of base class and pch-file property as usage-requirements
        return
            [ property-set.create <pch-file>$(pch-file) <cflags>-Winvalid-pch ]
            $(pch-file)
          ;
    }
    
    # Calls the base version specifying source's name as the
    # name of the created target. As result, the PCH will be named
    # whatever.hpp.gch, and not whatever.gch.
    rule generated-targets ( sources + : property-set : project name ? )
    {
        name = [ $(sources[1]).name ] ;
        return [ generator.generated-targets $(sources) 
          : $(property-set) : $(project) $(name) ] ;
    }    
}

# Note: the 'H' source type will catch both '.h' header and '.hpp' header. The latter
# have HPP type, but HPP type is derived from H.  The type of compilation is determined
# entirely by the destination type.
generators.register [ new gcc-pch-generator gcc.compile.c.pch   : H :   C_PCH : <pch>on <toolset>gcc ] ;
generators.register [ new gcc-pch-generator gcc.compile.c++.pch : H : CPP_PCH : <pch>on <toolset>gcc ] ;

# Override default do-nothing generators.
generators.override gcc.compile.c.pch   : pch.default-c-pch-generator   ;
generators.override gcc.compile.c++.pch : pch.default-cpp-pch-generator ;

flags gcc.compile PCH_FILE <pch>on : <pch-file> ;

# Declare flags and action for compilation
flags gcc.compile OPTIONS <optimization>off : -O0 ;
flags gcc.compile OPTIONS <optimization>speed : -O3 ;
flags gcc.compile OPTIONS <optimization>space : -Os ;

flags gcc.compile OPTIONS <inlining>off : -fno-inline ;
flags gcc.compile OPTIONS <inlining>on : -Wno-inline ;
flags gcc.compile OPTIONS <inlining>full : -finline-functions -Wno-inline ;

flags gcc.compile OPTIONS <warnings>off : -w ;
flags gcc.compile OPTIONS <warnings>on : -Wall ;
flags gcc.compile OPTIONS <warnings>all : -Wall -pedantic ;
flags gcc.compile OPTIONS <warnings-as-errors>on : -Werror ;

flags gcc.compile OPTIONS <debug-symbols>on : -g ;
flags gcc.compile OPTIONS <profiling>on : -pg ;
# On cygwin and mingw, gcc generates position independent code by default,
# and warns if -fPIC is specified. This might not be the right way
# of checking if we're using cygwin. For example, it's possible 
# to run cygwin gcc from NT shell, or using crosscompiling.
# But we'll solve that problem when it's time. In that case
# we'll just add another parameter to 'init' and move this login
# inside 'init'.
if [ os.name ] != CYGWIN && [ os.name ] != NT
{        
    # This logic will add -fPIC for all compilations:
    #
    # lib a : a.cpp b ;
    # obj b : b.cpp ;
    # exe c : c.cpp a d ;
    # obj d : d.cpp ;
    # 
    # This all is fine, except that 'd' will be compiled with
    # -fPIC even though it's not needed, as 'd' is used only in
    # exe. However, it's hard to detect where a target is going to
    # be used. Alternative, we can set -fPIC only when main target type 
    # is LIB but than 'b' will be compiled without -fPIC. In x86-64 that
    # will lead to link errors. So, compile everything with -fPIC.
    #
    # Yet another alternative would be to create propagated <sharedable> 
    # feature, and set it when building shared libraries, but that's hard
    # to implement and will increase target path length even more.
    flags gcc.compile OPTIONS <link>shared : -fPIC ;
}    
if [ os.name ] != NT && [ os.name ] != OSF && [ os.name ] != HPUX
{
    # OSF does have an option called -soname but it doesn't seem to work as
    # expected, therefore it has been disabled.

    HAVE_SONAME   = "" ;
    SONAME_OPTION = -h ;
}



flags gcc.compile USER_OPTIONS <cflags> ;
flags gcc.compile.c++ USER_OPTIONS <cxxflags> ;
flags gcc.compile DEFINES <define> ;
flags gcc.compile INCLUDES <include> ;

actions compile.c++.pch
{
    "$(CONFIG_COMMAND)" -x c++-header $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)" 
}

actions compile.c.pch
{
    "$(CONFIG_COMMAND)" -x c-header $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)" 
}

rule compile.c++
{
    # Some extensions are compiled as C++ by default. For others, we need
    # to pass -x c++.
    # We could always pass -x c++ but distcc does not work with it.
    if ! $(>:S) in .cc .cp .cxx .cpp .c++ .C
    {
        LANG on $(<) = "-x c++" ;
    }    
    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
}

rule compile.c
{
    # If we use the name g++ then default file suffix -> language mapping
    # does not work. So have to pass -x option. Maybe, we can work around this
    # by allowing the user to specify both C and C++ compiler names.
    #if $(>:S) != .c
    #{
        LANG on $(<) = "-x c" ;
    #}    
    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
}

actions compile.c++ bind PCH_FILE
{
    "$(CONFIG_COMMAND)" $(LANG) -ftemplate-depth-128 $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<:W)" "$(>:W)"
}

actions compile.c bind PCH_FILE
{
    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<)" "$(>)" 
}

rule compile.asm
{
    LANG on $(<) = "-x assembler-with-cpp" ;
}

actions compile.asm
{
    "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)" 
}

# The class which check that we don't try to use
# the <runtime-link>static property while creating or using shared library,
# since it's not supported by gcc/libc.
class gcc-linking-generator : unix-linking-generator
{
    rule run ( project name ? : property-set : sources + )
    {
        #~ TODO: Replace this with the use of a target-os property.
        local no-static-link = ;
        if [ modules.peek : UNIX ]
        {
            switch [ modules.peek : JAMUNAME ]
            {
                case * : no-static-link = true ;
            }
        }

        local properties = [ $(property-set).raw ] ;
        local reason ;
        if $(no-static-link) && <runtime-link>static in $(properties)
        {
            if <link>shared in $(properties)
            {
                reason =
                    "On gcc, DLL can't be build with '<runtime-link>static'." ;
            }
            else if [ type.is-derived $(self.target-types[1]) EXE ]
            {
                for local s in $(sources)
                {
                    local type = [ $(s).type ] ;
                    if $(type) &&  [ type.is-derived $(type) SHARED_LIB ]
                    {
                        reason =
                            "On gcc, using DLLS together with the"
                            "<runtime-link>static options is not possible " ;
                    }
                }
            }
        }
        if $(reason)
        {
            ECHO warning:
                $(reason) ;
            ECHO warning:
                "It's suggested to use '<runtime-link>static' together"
                "with the '<link>static'." ;
            return ;
        }
        else
        {
            local generated-targets = [ unix-linking-generator.run $(project) $(name)
                : $(property-set) : $(sources) ] ;
            
            return $(generated-targets) ;
        }
    }
}

.IMPLIB-COMMAND = ;
if [ os.on-windows ]
{
    .IMPLIB-COMMAND = "-Wl,--out-implib," ;
    generators.register
        [ new gcc-linking-generator gcc.link
            : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
            : EXE
            : <toolset>gcc ] ;
    generators.register
        [ new gcc-linking-generator gcc.link.dll
            : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
            : IMPORT_LIB SHARED_LIB
            : <toolset>gcc ] ;
}
else
{
    generators.register
        [ new gcc-linking-generator gcc.link
            : LIB OBJ
            : EXE
            : <toolset>gcc ] ;
    generators.register
        [ new gcc-linking-generator gcc.link.dll
            : LIB OBJ
            : SHARED_LIB
            : <toolset>gcc ] ;
}

# Declare flags for linking
# First, the common flags
flags gcc.link OPTIONS <debug-symbols>on : -g ;
flags gcc.link OPTIONS <profiling>on : -pg ;
flags gcc.link USER_OPTIONS <linkflags> ;
flags gcc.link LINKPATH <library-path> ;
flags gcc.link FINDLIBS-ST <find-static-library> ;
flags gcc.link FINDLIBS-SA <find-shared-library> ;
flags gcc.link LIBRARIES <library-file> ;

# For <runtime-link>static we made sure there are no dynamic libraries
# in the link.
# On HP-UX not all system libraries exist as archived libraries (for example,
# there is no libunwind.a), so, on this platform, the -static option cannot
# be specified.

if [ os.name ] != HPUX
{
    flags gcc.link OPTIONS <runtime-link>static : -static ;
}

# Now, the vendor specific flags
# The parameter linker can be either gnu or sun
rule init-link-flags ( toolset linker condition )
{
    switch $(linker)
    {
    case gnu :
        {
        # Strip the binary when no debugging is needed.
        # We use --strip-all flag as opposed to -s since icc
        # (intel's compiler) is generally option-compatible with
        # and inherits from gcc toolset, but does not support -s
        flags $(toolset).link OPTIONS $(condition)/<debug-symbols>off : -Wl,--strip-all 
          : unchecked ;
        flags $(toolset).link RPATH $(condition) : <dll-path> : unchecked ;
        flags $(toolset).link RPATH_LINK $(condition) : <xdll-path> : unchecked ;
        flags $(toolset).link START-GROUP $(condition) : -Wl,--start-group : unchecked ;
        flags $(toolset).link END-GROUP $(condition) : -Wl,--end-group : unchecked ;
        
        # gnu ld has the ability to change the search behaviour for libraries referenced
        # by -l switch. These modifiers are -Bstatic and -Bdynamic and change search
        # for -l switches that follow them. The following list shows the tried variants.
        # The search stops at the first variant that has a match.
        # *nix: -Bstatic -lxxx
        #    libxxx.a
        #
        # *nix: -Bdynamic -lxxx
        #    libxxx.so
        #    libxxx.a
        #
        # windows (mingw,cygwin) -Bstatic -lxxx
        #    libxxx.a
        #    xxx.lib
        #
        # windows (mingw,cygwin) -Bdynamic -lxxx
        #    libxxx.dll.a
        #    xxx.dll.a
        #    libxxx.a
        #    xxx.lib
        #    cygxxx.dll (*)
        #    libxxx.dll
        #    xxx.dll
        #    libxxx.a
        #
        # (*) This is for cygwin
        # Please note that -Bstatic and -Bdynamic are not a guarantee that a static
        # or dynamic lib indeed gets linked in. The switches only change search
        # patterns!
        
        # On *nix mixing shared libs with static runtime is not a good idea.
        flags $(toolset).link FINDLIBS-ST-PFX $(condition)/<runtime-link>shared 
            : -Wl,-Bstatic : unchecked ;
        flags $(toolset).link FINDLIBS-SA-PFX $(condition)/<runtime-link>shared 
            : -Wl,-Bdynamic : unchecked ;
        
        # On windows allow mixing of static and dynamic libs with static runtime
        flags $(toolset).link FINDLIBS-ST-PFX $(condition)/<runtime-link>static/<target-os>windows
            : -Wl,-Bstatic : unchecked ;
        flags $(toolset).link FINDLIBS-SA-PFX $(condition)/<runtime-link>static/<target-os>windows 
            : -Wl,-Bdynamic : unchecked ;
        flags $(toolset).link OPTIONS $(condition)/<runtime-link>static/<target-os>windows 
            : -Wl,-Bstatic : unchecked ;
        }
    case darwin :
        {
        # On Darwin, the -s option to ld does not work unless we pass
        # -static, and passing -static unconditionally is a bad idea.
        # So, don't pass -s at all, darwin.jam will use separate 'strip'
        # invocation.
        flags $(toolset).link RPATH $(condition) : <dll-path> : unchecked ;
        flags $(toolset).link RPATH_LINK $(condition) : <xdll-path> : unchecked ;
        }
        
    case osf :
        {
            # No --strip-all, just -s
            flags $(toolset).link OPTIONS $(condition)/<debug-symbols>off : -Wl,-s 
              : unchecked ;

            flags $(toolset).link RPATH $(condition) : <dll-path> : unchecked ;
            # This does not supports -R
            flags $(toolset).link RPATH_OPTION $(condition) : -rpath : unchecked ;
            # -rpath-link is not supported at all.
        }
        

    case sun :
        {
        flags $(toolset).link OPTIONS $(condition)/<debug-symbols>off : -Wl,-s 
            : unchecked ;
        flags $(toolset).link RPATH $(condition) : <dll-path> : unchecked ;
        # Solaris linker does not have a separate -rpath-link, but
        # allows to use -L for the same purpose.
        flags $(toolset).link LINKPATH $(condition) : <xdll-path> : unchecked ;

        # This permits shared libraries with non-PIC code on Solaris
        # VP, 2004/09/07: Now that we have -fPIC hardcode in link.dll,
        # the following is not needed. Whether -fPIC should be hardcoded,
        # is a separate question.
        # AH, 2004/10/16: it is still necessary because some tests link
        # against static libraries that were compiled without PIC.
        flags $(toolset).link OPTIONS $(condition)/<link>shared : -mimpure-text 
          : unchecked ;
        }

    case hpux :
        {
            flags $(toolset).link OPTIONS $(condition)/<debug-symbols>off : -Wl,-s
              : unchecked ;
            flags $(toolset).link OPTIONS $(condition)/<link>shared : -fPIC
              : unchecked ;
        }

    case * :
        {
            errors.user-error
            "$(toolset) initialization: invalid linker '$(linker)'" :
            "The value '$(linker)' specified for <linker> is not recognized." :
            "Possible values are 'sun', 'gnu'" ;
        }
    }
}

# Declare actions for linking
rule link ( targets * : sources * : properties * )
{
    SPACE on $(targets) = " " ;    
    # Serialize execution of the 'link' action, since
    # running N links in parallel is just slower.
    # For now, serialize only gcc links, it might be a good
    # idea to serialize all links.
    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
}

actions link bind LIBRARIES
{
    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,"$(RPATH)" -Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" -o "$(<)" $(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) $(USER_OPTIONS)

}

# Default value. Mostly for the sake of intel-linux
# that inherits from gcc, but does not has the same
# logic to set the .AR variable. We can put the same
# logic in intel-linux, but that's hardly worth the trouble
# as on Linux, 'ar' is always available.
.AR = ar ; 

flags gcc.archive AROPTIONS <archiveflags> ;

rule archive ( targets * : sources * : properties * )
{
    # Always remove archive and start again. Here's rationale from
    #
    # Andre Hentz:
    #
    # I had a file, say a1.c, that was included into liba.a. 
    # I moved a1.c to a2.c, updated my Jamfiles and rebuilt. 
    # My program was crashing with absurd errors. 
    # After some debugging I traced it back to the fact that a1.o was *still* 
    # in liba.a 
    #
    # Rene Rivera:
    #
    # Originally removing the archive was done by splicing an RM
    # onto the archive action. That makes archives fail to build on NT
    # when they have many files because it will no longer execute the
    # action directly and blow the line length limit. Instead we
    # remove the file in a different action, just before the building
    # of the archive.
    #
    local clean.a = $(targets[1])(clean) ;
    TEMPORARY $(clean.a) ;
    NOCARE $(clean.a) ;
    LOCATE on $(clean.a) = [ on $(targets[1]) return $(LOCATE) ] ;
    DEPENDS $(clean.a) : $(sources) ;
    DEPENDS $(targets) : $(clean.a) ;
    common.RmTemps $(clean.a) : $(targets) ;
}

# Declare action for creating static libraries
# The 'r' letter means to add files to the archive with replacement
# Since we remove archive, we don't care about replacement, but
# there's no option "add without replacement".
# The 'c' letter means suppresses warning in case the archive
#   does not exists yet. That warning is produced only on
#   some platforms, for whatever reasons.
actions piecemeal archive 
{
    "$(.AR)" $(AROPTIONS) rc "$(<)" "$(>)"
}


rule link.dll ( targets * : sources * : properties * )
{
    SPACE on $(targets) = " " ;    
    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
}

# Differ from 'link' above only by -shared.
actions link.dll bind LIBRARIES
{
    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,"$(RPATH)" "$(.IMPLIB-COMMAND)$(<[1])" -o "$(<[-1])" $(HAVE_SONAME)-Wl,$(SONAME_OPTION)$(SPACE)-Wl,$(<[-1]:D=) -shared $(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) $(USER_OPTIONS)
}

# Set up threading support. It's somewhat contrived, so perform it at the end,
# to avoid cluttering other code.

if [ os.on-windows ] 
{
    flags gcc OPTIONS <threading>multi : -mthreads ;
}
else if [ modules.peek : UNIX ] 
{
    switch [ modules.peek : JAMUNAME ]
    {
    case SunOS* :
        {
        flags gcc OPTIONS <threading>multi : -pthreads ;
        flags gcc FINDLIBS-SA <threading>multi : rt ;
        }
    case BeOS :
        {
        # BeOS has no threading options, don't set anything here.
        }
    case *BSD :
        {
        flags gcc OPTIONS <threading>multi : -pthread ;
        # there is no -lrt on BSD
        }
    case DragonFly :
        {
        flags gcc OPTIONS <threading>multi : -pthread ;
        # there is no -lrt on BSD - DragonFly is a FreeBSD variant,
        # which anoyingly doesn't say it's a *BSD.
        }
    case IRIX :
        {
        # gcc on IRIX does not support multi-threading, don't set anything here.
        }
    case Darwin :
        {
        # Darwin has no threading options, don't set anything here.
        }
    case * :
        {
        flags gcc OPTIONS <threading>multi : -pthread ;
        flags gcc FINDLIBS-SA <threading>multi : rt ;
        }
    }
}

local rule cpu-flags ( toolset variable : architecture : instruction-set + : values + : default ? )
{
    if $(default)
    {
        flags $(toolset) $(variable)
            <architecture>$(architecture)/<instruction-set>
            : $(values) ;
    }
    flags $(toolset) $(variable)
        <architecture>/<instruction-set>$(instruction-set)
        <architecture>$(architecture)/<instruction-set>$(instruction-set)
        : $(values) ;
}

# Set architecture/instruction-set options.
#
# x86 and compatible
flags gcc OPTIONS <architecture>x86/<address-model>32 : -m32 ;
flags gcc OPTIONS <architecture>x86/<address-model>64 : -m64 ;
cpu-flags gcc OPTIONS : x86 : i386 : -march=i386 : default ;
cpu-flags gcc OPTIONS : x86 : i486 : -march=i486 ;
cpu-flags gcc OPTIONS : x86 : i586 : -march=i586 ;
cpu-flags gcc OPTIONS : x86 : i686 : -march=i686 ;
cpu-flags gcc OPTIONS : x86 : pentium : -march=pentium ;
cpu-flags gcc OPTIONS : x86 : pentium-mmx : -march=pentium-mmx ;
cpu-flags gcc OPTIONS : x86 : pentiumpro : -march=pentiumpro ;
cpu-flags gcc OPTIONS : x86 : pentium2 : -march=pentium2 ;
cpu-flags gcc OPTIONS : x86 : pentium3 : -march=pentium3 ;
cpu-flags gcc OPTIONS : x86 : pentium3m : -march=pentium3m ;
cpu-flags gcc OPTIONS : x86 : pentium-m : -march=pentium-m ;
cpu-flags gcc OPTIONS : x86 : pentium4 : -march=pentium4 ;
cpu-flags gcc OPTIONS : x86 : pentium4m : -march=pentium4m ;
cpu-flags gcc OPTIONS : x86 : prescott : -march=prescott ;
cpu-flags gcc OPTIONS : x86 : nocona : -march=nocona ;
cpu-flags gcc OPTIONS : x86 : k6 : -march=k6 ;
cpu-flags gcc OPTIONS : x86 : k6-2 : -march=k6-2 ;
cpu-flags gcc OPTIONS : x86 : k6-3 : -march=k6-3 ;
cpu-flags gcc OPTIONS : x86 : athlon : -march=athlon ;
cpu-flags gcc OPTIONS : x86 : athlon-tbird : -march=athlon-tbird ;
cpu-flags gcc OPTIONS : x86 : athlon-4 : -march=athlon-4 ;
cpu-flags gcc OPTIONS : x86 : athlon-xp : -march=athlon-xp ;
cpu-flags gcc OPTIONS : x86 : athlon-mp : -march=athlon-mp ;
##
cpu-flags gcc OPTIONS : x86 : k8 : -march=k8 ;
cpu-flags gcc OPTIONS : x86 : opteron : -march=opteron ;
cpu-flags gcc OPTIONS : x86 : athlon64 : -march=athlon64 ;
cpu-flags gcc OPTIONS : x86 : athlon-fx : -march=athlon-fx ;
cpu-flags gcc OPTIONS : x86 : winchip-c6 : -march=winchip-c6 ;
cpu-flags gcc OPTIONS : x86 : winchip2 : -march=winchip2 ;
cpu-flags gcc OPTIONS : x86 : c3 : -march=c3 ;
cpu-flags gcc OPTIONS : x86 : c3-2 : -march=c3-2 ;
# Sparc
flags gcc OPTIONS <architecture>sparc/<address-model>32 : -m32 ;
flags gcc OPTIONS <architecture>sparc/<address-model>64 : -m64 ;
cpu-flags gcc OPTIONS : sparc : c3 : -mcpu=c3 : default ;
cpu-flags gcc OPTIONS : sparc : v7 : -mcpu=v7 ;
cpu-flags gcc OPTIONS : sparc : cypress : -mcpu=cypress ;
cpu-flags gcc OPTIONS : sparc : v8 : -mcpu=v8 ;
cpu-flags gcc OPTIONS : sparc : supersparc : -mcpu=supersparc ;
cpu-flags gcc OPTIONS : sparc : sparclite : -mcpu=sparclite ;
cpu-flags gcc OPTIONS : sparc : hypersparc : -mcpu=hypersparc ;
cpu-flags gcc OPTIONS : sparc : sparclite86x : -mcpu=sparclite86x ;
cpu-flags gcc OPTIONS : sparc : f930 : -mcpu=f930 ;
cpu-flags gcc OPTIONS : sparc : f934 : -mcpu=f934 ;
cpu-flags gcc OPTIONS : sparc : sparclet : -mcpu=sparclet ;
cpu-flags gcc OPTIONS : sparc : tsc701 : -mcpu=tsc701 ;
cpu-flags gcc OPTIONS : sparc : v9 : -mcpu=v9 ;
cpu-flags gcc OPTIONS : sparc : ultrasparc : -mcpu=ultrasparc ;
cpu-flags gcc OPTIONS : sparc : ultrasparc3 : -mcpu=ultrasparc3 ;
# RS/6000 & PowerPC
flags gcc OPTIONS <architecture>power/<address-model>32 : -m32 ;
flags gcc OPTIONS <architecture>power/<address-model>64 : -m64 ;
flags gcc OPTIONS <architecture>power/<address-model>/<instruction-set> : -mcpu=common ;
cpu-flags gcc OPTIONS : power : 403 : -mcpu=403 ;
cpu-flags gcc OPTIONS : power : 505 : -mcpu=505 ;
cpu-flags gcc OPTIONS : power : 601 : -mcpu=601 ;
cpu-flags gcc OPTIONS : power : 602 : -mcpu=602 ;
cpu-flags gcc OPTIONS : power : 603 : -mcpu=603 ;
cpu-flags gcc OPTIONS : power : 603e : -mcpu=603e ;
cpu-flags gcc OPTIONS : power : 604 : -mcpu=604 ;
cpu-flags gcc OPTIONS : power : 604e : -mcpu=604e ;
cpu-flags gcc OPTIONS : power : 620 : -mcpu=620 ;
cpu-flags gcc OPTIONS : power : 630 : -mcpu=630 ;
cpu-flags gcc OPTIONS : power : 740 : -mcpu=740 ;
cpu-flags gcc OPTIONS : power : 7400 : -mcpu=7400 ;
cpu-flags gcc OPTIONS : power : 7450 : -mcpu=7450 ;
cpu-flags gcc OPTIONS : power : 750 : -mcpu=750 ;
cpu-flags gcc OPTIONS : power : 801 : -mcpu=801 ;
cpu-flags gcc OPTIONS : power : 821 : -mcpu=821 ;
cpu-flags gcc OPTIONS : power : 823 : -mcpu=823 ;
cpu-flags gcc OPTIONS : power : 860 : -mcpu=860 ;
cpu-flags gcc OPTIONS : power : 970 : -mcpu=970 ;
cpu-flags gcc OPTIONS : power : 8540 : -mcpu=8540 ;
cpu-flags gcc OPTIONS : power : power : -mcpu=power ;
cpu-flags gcc OPTIONS : power : power2 : -mcpu=power2 ;
cpu-flags gcc OPTIONS : power : power3 : -mcpu=power3 ;
cpu-flags gcc OPTIONS : power : power4 : -mcpu=power4 ;
cpu-flags gcc OPTIONS : power : power5 : -mcpu=power5 ;
cpu-flags gcc OPTIONS : power : powerpc : -mcpu=powerpc ;
cpu-flags gcc OPTIONS : power : powerpc64 : -mcpu=powerpc64 ;
cpu-flags gcc OPTIONS : power : rios : -mcpu=rios ;
cpu-flags gcc OPTIONS : power : rios1 : -mcpu=rios1 ;
cpu-flags gcc OPTIONS : power : rios2 : -mcpu=rios2 ;
cpu-flags gcc OPTIONS : power : rsc : -mcpu=rsc ;
cpu-flags gcc OPTIONS : power : rs64a : -mcpu=rs64 ;
# AIX variant of RS/6000 & PowerPC
flags gcc OPTIONS <architecture>power/<address-model>32/<target-os>aix : -maix32 ;
flags gcc OPTIONS <architecture>power/<address-model>64/<target-os>aix : -maix64 ;
flags gcc AROPTIONS <architecture>power/<address-model>64/<target-os>aix : "-X 64" ;