[ceph.git] / ceph / src / boost / tools / build / src / tools / darwin.jam

# Copyright 2003 Christopher Currie
# Copyright 2006 Dave Abrahams 
# Copyright 2003, 2004, 2005, 2006 Vladimir Prus 
# Copyright 2005-2007 Mat Marcus
# Copyright 2005-2007 Adobe Systems Incorporated
# Copyright 2007-2010 Rene Rivera
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 

#  Please see http://article.gmane.org/gmane.comp.lib.boost.build/3389/
#  for explanation why it's a separate toolset.

import feature : feature ;
import toolset : flags ;
import type ;
import common ;
import generators ;
import path : basename ;
import version ;
import property-set ;
import regex ;
import errors ;

## Use a framework.
feature framework : : free ;

## The MacOSX version to compile for, which maps to the SDK to use (sysroot).
feature macosx-version : : propagated link-incompatible symmetric optional ;

## The minimal MacOSX version to target.
feature macosx-version-min : : propagated optional ;

## A dependency, that is forced to be included in the link.
feature force-load : : free dependency incidental ;

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

_ = " " ;

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

feature.extend toolset : darwin ;
import gcc ;
toolset.inherit-generators darwin : gcc : gcc.mingw.link gcc.mingw.link.dll ;

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

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

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

toolset.inherit-rules darwin : gcc : localize ;
toolset.inherit-flags darwin : gcc     
  :  <runtime-link>static
     <architecture>arm/<address-model>32
     <architecture>arm/<address-model>64
     <architecture>arm/<instruction-set>
     <architecture>x86/<address-model>32
     <architecture>x86/<address-model>64
     <architecture>x86/<instruction-set>
     <architecture>power/<address-model>32
     <architecture>power/<address-model>64
     <architecture>power/<instruction-set> 
     <inlining>full  ;

# Options:
#
#   <root>PATH
#       Platform root path. The common autodetection will set this to
#       "/Developer". And when a command is given it will be set to
#       the corresponding "*.platform/Developer" directory.
#
rule init ( version ? : command * : options * : requirement * )
{
    # First time around, figure what is host OSX version
    if ! $(.host-osx-version)  
    {
        .host-osx-version = [ MATCH "^([0-9.]+)"
          : [ SHELL "/usr/bin/sw_vers -productVersion" ] ] ;
        if $(.debug-configuration)
        {
            ECHO notice\: OSX version on this machine is $(.host-osx-version) ;
        }
    }
                      
    # - The root directory of the tool install.
    local root = [ feature.get-values <root> : $(options) ] ;
    
    # - The bin directory where to find the commands to execute.
    local bin ;
    
    # - The configured compile driver command.
    local command = [ common.get-invocation-command darwin : g++ : $(command) ] ;
    
    # The version as reported by the compiler
    local real-version ;
    
    # - Autodetect the root and bin dir if not given.
    if $(command)
    {
        bin ?= [ common.get-absolute-tool-path $(command[1]) ] ;
        if $(bin) = "/usr/bin"
        {
            root ?= /Developer ;
        }
        else
        {
            local r = $(bin:D) ;
            r = $(r:D) ;
            root ?= $(r) ;
        }
    }
    
    # - Autodetect the version 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=" ") ;
        real-version = [ MATCH "^([0-9.]+)"
            : [ SHELL "$(command-string) -dumpversion" ] ] ;
        version ?= $(real-version) ;
    }
    
    .real-version.$(version) = $(real-version) ;
    
    # - Define the condition for this toolset instance.
    local condition =
        [ common.check-init-parameters darwin $(requirement) : version $(version) ] ;
    
    # - Set the toolset generic common options.
    common.handle-options darwin : $(condition) : $(command) : $(options) ;
    
    real-version = [ regex.split $(real-version) \\. ] ;
    # - GCC 4.0 and higher in Darwin does not have -fcoalesce-templates.
    if [ version.version-less $(real-version) : 4 0 ]
    {
        flags darwin.compile.c++ OPTIONS $(condition) : -fcoalesce-templates ;
    }
    # - GCC 4.2 and higher in Darwin does not have -Wno-long-double.
    if [ version.version-less $(real-version) : 4 2 ]
    {
        flags darwin.compile OPTIONS $(condition) : -Wno-long-double ;
    }
    # - GCC on Darwin with -pedantic, suppress unsupported long long warning
    flags darwin.compile OPTIONS $(condition)/<warnings>pedantic : -Wno-long-long ;

    # - GCC on El Capitan (10.11) does not support -finline-functions
    if "10.11.0" <= $(.host-osx-version)
    {
        flags darwin.compile OPTIONS $(condition)/<inlining>full : -Wno-inline ;
    }

    # - The symbol strip program.
    local strip ;
    if <striper> in $(options)
    {
        # We can turn off strip by specifying it as empty. In which
        # case we switch to using the linker to do the strip.
        flags darwin.link.dll OPTIONS
            $(condition)/<main-target-type>LIB/<link>shared/<address-model>32/<strip>on : -Wl,-x ;
        flags darwin.link.dll OPTIONS
            $(condition)/<main-target-type>LIB/<link>shared/<address-model>/<strip>on : -Wl,-x ;
        flags darwin.link OPTIONS
            $(condition)/<main-target-type>EXE/<address-model>32/<strip>on : -s ;
        flags darwin.link OPTIONS
            $(condition)/<main-target-type>EXE/<address-model>/<strip>on : -s ;
    }
    else
    {
        # Otherwise we need to find a strip program to use. And hence
        # also tell the link action that we need to use a strip
        # post-process.
        flags darwin.link NEED_STRIP $(condition)/<strip>on : "" ;
        strip =
            [ common.get-invocation-command darwin
                : strip : [ feature.get-values <striper> : $(options) ] : $(bin) : search-path ] ;
        flags darwin.link .STRIP $(condition) : $(strip[1]) ;
        if $(.debug-configuration)
        {
            ECHO notice\: using strip for $(condition) at $(strip[1]) ;
        }
    }

    # - The archive builder (libtool is the default as creating
    #   archives in darwin is complicated.
    local archiver =
        [ common.get-invocation-command darwin
            : libtool : [ feature.get-values <archiver> : $(options) ] : $(bin) : search-path ] ;
    flags darwin.archive .LIBTOOL $(condition) : $(archiver[1]) ;
    if $(.debug-configuration)
    {
        ECHO notice\: using archiver for $(condition) at $(archiver[1]) ;
    }
    
    # - Initialize the SDKs available in the root for this tool.
    local sdks = [ init-available-sdk-versions $(condition) : $(root) ] ;
    
    #~ ECHO --- ;
    #~ ECHO --- bin :: $(bin) ;
    #~ ECHO --- root :: $(root) ;
    #~ ECHO --- version :: $(version) ;
    #~ ECHO --- condition :: $(condition) ;
    #~ ECHO --- strip :: $(strip) ;
    #~ ECHO --- archiver :: $(archiver) ;
    #~ ECHO --- sdks :: $(sdks) ;
    #~ ECHO --- ;
    #~ EXIT ;
}

# Add and set options for a discovered SDK version.
local rule init-sdk ( condition * : root ? : version + : version-feature ? )
{
    local rule version-to-feature ( version + )
    {
        switch $(version[1])
        {
            case appletv* :
            {
                return $(version[1])-$(version[2-]:J=.) ;
            }
            case iphone* :
            {
                return $(version[1])-$(version[2-]:J=.) ;
            }
            case mac* :
            {
                return $(version[2-]:J=.) ;
            }
            case * :
            {
                return $(version:J=.) ;
            }
        }
    }
    
    if $(version-feature)
    {
        if $(.debug-configuration)
        {
            ECHO notice\: available sdk for $(condition)/<macosx-version>$(version-feature) at $(root) ;
        }
        
        # Add the version to the features for specifying them.
        if ! $(version-feature) in [ feature.values macosx-version ]
        {
            feature.extend macosx-version : $(version-feature) ;
        }
        if ! $(version-feature) in [ feature.values macosx-version-min ]
        {
            feature.extend macosx-version-min : $(version-feature) ;
        }
        
        # Set the flags the version needs to compile with, first
        # generic options.
        flags darwin.compile OPTIONS $(condition)/<macosx-version>$(version-feature)
            : -isysroot $(root) ;
        flags darwin.link OPTIONS $(condition)/<macosx-version>$(version-feature)
            : -isysroot $(root) ;
        
        # Then device variation options.
        switch $(version[1])
        {
            case appletvsim* :
            {
                local N = $(version[2]) ;
                if ! $(version[3]) { N += 00 ; }
                else if [ regex.match (..) : $(version[3]) ] { N += $(version[3]) ; }
                else { N += 0$(version[3]) ; }
                if ! $(version[4]) { N += 00 ; }
                else if [ regex.match (..) : $(version[4]) ] { N += $(version[4]) ; }
                else { N += 0$(version[4]) ; }
                N = $(N:J=) ;
                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                    : -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
                    : -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
            }

            case appletv* :
            {
                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                    : -mtvos-version-min=$(version[2-]:J=.) ;
                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
                    : -mtvos-version-min=$(version[2-]:J=.) ;
            }

            case iphonesim* :
            {
                local N = $(version[2]) ;
                if ! $(version[3]) { N += 00 ; }
                else if [ regex.match (..) : $(version[3]) ] { N += $(version[3]) ; }
                else { N += 0$(version[3]) ; }
                if ! $(version[4]) { N += 00 ; }
                else if [ regex.match (..) : $(version[4]) ] { N += $(version[4]) ; }
                else { N += 0$(version[4]) ; }
                N = $(N:J=) ;
                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                    : -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
                    : -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
            }

            case iphone* :
            {
                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                    : -miphoneos-version-min=$(version[2-]:J=.) ;
                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
                    : -miphoneos-version-min=$(version[2-]:J=.) ;
            }
            
            case mac* :
            {
                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                    : -mmacosx-version-min=$(version[2-]:J=.) ;
                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
                    : -mmacosx-version-min=$(version[2-]:J=.) ;
            }
        }
        
        if $(version[3]) > 0
        {
            # We have a minor version of an SDK. We want to set up
            # previous minor versions, plus the current minor version.
            # So we recurse to set up the previous minor versions, up to
            # the current version.
            local minor-minus-1 = [ CALC $(version[3]) - 1 ] ;
            return
                [ init-sdk $(condition) : $(root)
                    : $(version[1-2]) $(minor-minus-1) : [ version-to-feature $(version[1-2]) $(minor-minus-1) ] ]
                $(version-feature) ;
        }
        else
        {
            return $(version-feature) ;
        }
    }
    else if $(version[4])
    {
        # We have a patch version of an SDK. We want to set up
        # both the specific patch version, and the minor version.
        # So we recurse to set up the patch version. Plus the minor version.
        return
            [ init-sdk $(condition) : $(root)
                : $(version[1-3]) : [ version-to-feature $(version[1-3]) ] ]
            [ init-sdk $(condition) : $(root)
                : $(version) : [ version-to-feature $(version) ] ] ;
    }
    else
    {
        # Yes, this is intentionally recursive.
        return
            [ init-sdk $(condition) : $(root)
                : $(version) : [ version-to-feature $(version) ] ] ;
    }
}

# Determine the MacOSX SDK versions installed and their locations.
local rule init-available-sdk-versions ( condition * : root ? )
{
    root ?= /Developer ;
    local sdks-root = $(root)/SDKs ;
    local sdks = [ GLOB $(sdks-root) : MacOSX*.sdk AppleTVOS*.sdk AppleTVSimulator*.sdk iPhoneOS*.sdk iPhoneSimulator*.sdk ] ;
    local result ;
    for local sdk in $(sdks)
    {
        local sdk-match = [ MATCH "([^0-9]+)([0-9]+)[.]([0-9x]+)[.]?([0-9x]+)?" : $(sdk:D=) ] ;
        local sdk-platform = $(sdk-match[1]:L) ;
        local sdk-version = $(sdk-match[2-]) ;
        if $(sdk-version)
        {
            switch $(sdk-platform)
            {
                case macosx :
                {
                    sdk-version = mac $(sdk-version) ;
                }
                case appletvos :
                {
                    sdk-version = appletv $(sdk-version) ;
                }
                case appletvsimulator :
                {
                    sdk-version = appletvsim $(sdk-version) ;
                }
                case iphoneos :
                {
                    sdk-version = iphone $(sdk-version) ;
                }
                case iphonesimulator :
                {
                    sdk-version = iphonesim $(sdk-version) ;
                }
                case * :
                {
                    sdk-version = $(sdk-version:J=-) ;
                }
            }
            result += [ init-sdk $(condition) : $(sdk) : $(sdk-version) ] ;
        }
    }
    return $(result) ;
}

# Generic options.
flags darwin.compile OPTIONS <flags> ;

# The following adds objective-c support to darwin.
# Thanks to http://thread.gmane.org/gmane.comp.lib.boost.build/13759

generators.register-c-compiler darwin.compile.m : OBJECTIVE_C : OBJ : <toolset>darwin ;
generators.register-c-compiler darwin.compile.mm : OBJECTIVE_CPP : OBJ : <toolset>darwin ;

rule setup-address-model ( targets * : sources * : properties * )
{
    local ps = [ property-set.create $(properties) ] ;
    local arch = [ $(ps).get <architecture> ] ;
    local instruction-set = [ $(ps).get <instruction-set> ] ;
    local address-model = [ $(ps).get <address-model> ] ;
    local osx-version = [ $(ps).get <macosx-version> ] ;
    local gcc-version = [ $(ps).get <toolset-darwin:version> ] ;
    gcc-version = $(.real-version.$(gcc-version)) ;
    local options ;
    
    local support-ppc64 = 1 ;
    
    osx-version ?= $(.host-osx-version) ;

    switch $(osx-version)
    {
        case iphone* :
        {
            support-ppc64 = ;
        }
        
        case * :
        if $(osx-version) && ! [ version.version-less [ regex.split $(osx-version) \\. ] : 10 6 ]
        {
            # When targeting 10.6:
            # - gcc 4.2 will give a compiler errir if ppc64 compilation is requested
            # - gcc 4.0 will compile fine, somehow, but then fail at link time
            support-ppc64 = ;
        }
    }
    switch $(arch)
    {
        case combined : 
        {
            if $(address-model) = 32_64 {
                if $(support-ppc64) {
                    options = -arch i386 -arch ppc -arch x86_64 -arch ppc64 ;                    
                } else {
                    # Build 3-way binary
                    options = -arch i386 -arch ppc -arch x86_64 ;
                }                                
            } else if $(address-model) = 64 {
                if $(support-ppc64) {
                    options = -arch x86_64 -arch ppc64 ;
                } else {
                    errors.user-error "64-bit PPC compilation is not supported when targeting OSX 10.6 or later" ;
                }                
            } else {
                options = -arch i386 -arch ppc ;
            }
        }
        
        case x86 : 
        {
            if $(address-model) = 32_64 {
                options = -arch i386 -arch x86_64 ;
            } else if $(address-model) = 64 {
                options = -arch x86_64 ;
            } else {
                options = -arch i386 ;
            }
        }        
        
        case power :
        {
            if ! $(support-ppc64) 
              && (  $(address-model) = 32_64 || $(address-model) = 64 )
            {
                errors.user-error "64-bit PPC compilation is not supported when targeting OSX 10.6 or later" ;
            }
            
            if $(address-model) = 32_64 {
                options = -arch ppc -arch ppc64 ;
            } else if $(address-model) = 64 {
                options = -arch ppc64 ;
            } else {
                options = -arch ppc ;
            }
        }
        
        case arm :
        {
            if $(instruction-set) {
                options = -arch$(_)$(instruction-set) ;
            } else {
                options = -arch arm ;
            }
        }
    }
    
    if $(options)
    {
        OPTIONS on $(targets) += $(options) ;
    }            
}

rule compile.m ( targets * : sources * : properties * )
{
    LANG on $(<) = "-x objective-c" ;
    gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;
    setup-address-model $(targets) : $(sources) : $(properties) ;
}

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

rule compile.mm  ( targets * : sources * : properties * )
{
    LANG on $(<) = "-x objective-c++" ;
    gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;
    setup-address-model $(targets) : $(sources) : $(properties) ;
}

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

# Set the max header padding to allow renaming of libs for installation.
flags darwin.link.dll OPTIONS : -headerpad_max_install_names ;

# To link the static runtime we need to link to all the core runtime libraries.
flags darwin.link OPTIONS <runtime-link>static
    : -nodefaultlibs -shared-libgcc -lstdc++-static -lgcc_eh -lgcc -lSystem ;

# Strip as much as possible when optimizing.
flags darwin.link OPTIONS <optimization>speed : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;
flags darwin.link OPTIONS <optimization>space : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;

# Dynamic/shared linking.
flags darwin.compile OPTIONS <link>shared : -dynamic ;

# Misc options.
flags darwin.compile OPTIONS : -gdwarf-2 -fexceptions ;
#~ flags darwin.link OPTIONS : -fexceptions ;

# Add the framework names to use.
flags darwin.link FRAMEWORK <framework> ;

#
flags darwin.link FORCE_LOAD <force-load> ;

# This is flag is useful for debugging the link step
# uncomment to see what libtool is doing under the hood
#~ flags darwin.link.dll OPTIONS : -Wl,-v ;

# set up the -F option to include the paths to any frameworks used.
local rule prepare-framework-path ( target + )
{
    # The -framework option only takes basename of the framework.
    # The -F option specifies the directories where a framework
    # is searched for.  So, if we find <framework> feature
    # with some path, we need to generate property -F option.
    local framework-paths = [ on $(target) return $(FRAMEWORK:D) ] ;

    # Be sure to generate no -F if there's no path.
    for local framework-path in $(framework-paths)
    {
        if $(framework-path) != ""
        {
            FRAMEWORK_PATH on $(target) += -F$(framework-path) ;
        }
    }
}

rule link ( targets * : sources * : properties * )
{
    DEPENDS $(targets) : [ on $(targets) return $(FORCE_LOAD) ] ;
    setup-address-model $(targets) : $(sources) : $(properties) ;
    prepare-framework-path $(<) ;
}

# Note that using strip without any options was reported to result in broken
# binaries, at least on OS X 10.5.5, see:
#    http://svn.boost.org/trac/boost/ticket/2347
# So we pass -S -x.
actions link bind LIBRARIES FORCE_LOAD
{
    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" "$(>)" -Wl,-force_load$(_)"$(FORCE_LOAD)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(FRAMEWORK_PATH) -framework$(_)$(FRAMEWORK:D=:S=) $(OPTIONS) $(USER_OPTIONS)
    $(NEED_STRIP)"$(.STRIP)" $(NEED_STRIP)-S $(NEED_STRIP)-x $(NEED_STRIP)"$(<)"
}

rule link.dll ( targets * : sources * : properties * )
{
    setup-address-model $(targets) : $(sources) : $(properties) ;
    prepare-framework-path $(<) ;
}

actions link.dll bind LIBRARIES
{
    "$(CONFIG_COMMAND)" -dynamiclib -Wl,-single_module -install_name "$(<:B)$(<:S)" -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(FRAMEWORK_PATH) -framework$(_)$(FRAMEWORK:D=:S=) $(OPTIONS) $(USER_OPTIONS)
}

# We use libtool instead of ar to support universal binary linking
# TODO: Find a way to use the underlying tools, i.e. lipo, to do this.
actions piecemeal archive
{
    "$(.LIBTOOL)" -static -o "$(<:T)"  $(ARFLAGS)  "$(>:T)"
}
Commit	Line	Data
7c673cae FG	1	# Copyright 2003 Christopher Currie
	2	# Copyright 2006 Dave Abrahams
	3	# Copyright 2003, 2004, 2005, 2006 Vladimir Prus
	4	# Copyright 2005-2007 Mat Marcus
	5	# Copyright 2005-2007 Adobe Systems Incorporated
	6	# Copyright 2007-2010 Rene Rivera
	7	# Distributed under the Boost Software License, Version 1.0.
	8	# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
	9
	10	# Please see http://article.gmane.org/gmane.comp.lib.boost.build/3389/
	11	# for explanation why it's a separate toolset.
	12
	13	import feature : feature ;
	14	import toolset : flags ;
	15	import type ;
	16	import common ;
	17	import generators ;
	18	import path : basename ;
	19	import version ;
	20	import property-set ;
	21	import regex ;
	22	import errors ;
	23
	24	## Use a framework.
	25	feature framework : : free ;
	26
	27	## The MacOSX version to compile for, which maps to the SDK to use (sysroot).
	28	feature macosx-version : : propagated link-incompatible symmetric optional ;
	29
	30	## The minimal MacOSX version to target.
	31	feature macosx-version-min : : propagated optional ;
	32
	33	## A dependency, that is forced to be included in the link.
	34	feature force-load : : free dependency incidental ;
	35
	36	#############################################################################
	37
	38	_ = " " ;
	39
	40	if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
	41	{
	42	.debug-configuration = true ;
	43	}
	44
	45	feature.extend toolset : darwin ;
	46	import gcc ;
	47	toolset.inherit-generators darwin : gcc : gcc.mingw.link gcc.mingw.link.dll ;
	48
	49	generators.override darwin.prebuilt : builtin.prebuilt ;
	50	generators.override darwin.searched-lib-generator : searched-lib-generator ;
	51
	52	# Override default do-nothing generators.
	53	generators.override darwin.compile.c.pch : pch.default-c-pch-generator ;
	54	generators.override darwin.compile.c++.pch : pch.default-cpp-pch-generator ;
	55
	56	type.set-generated-target-suffix PCH : <toolset>darwin : gch ;
	57
	58	toolset.inherit-rules darwin : gcc : localize ;
	59	toolset.inherit-flags darwin : gcc
	60	: <runtime-link>static
	61	<architecture>arm/<address-model>32
	62	<architecture>arm/<address-model>64
	63	<architecture>arm/<instruction-set>
	64	<architecture>x86/<address-model>32
65	<architecture>x86/<address-model>64
66	<architecture>x86/<instruction-set>
67	<architecture>power/<address-model>32
68	<architecture>power/<address-model>64
69	<architecture>power/<instruction-set>
70	<inlining>full ;
71
72	# Options:
73	#
74	# <root>PATH
75	# Platform root path. The common autodetection will set this to
76	# "/Developer". And when a command is given it will be set to
77	# the corresponding "*.platform/Developer" directory.
78	#
79	rule init ( version ? : command * : options * : requirement * )
80	{
81	# First time around, figure what is host OSX version
82	if ! $(.host-osx-version)
83	{
84	.host-osx-version = [ MATCH "^([0-9.]+)"
85	: [ SHELL "/usr/bin/sw_vers -productVersion" ] ] ;
86	if $(.debug-configuration)
87	{
11fdf7f2	88	ECHO notice\: OSX version on this machine is $(.host-osx-version) ;
7c673cae FG	89	}
	90	}
	91
	92	# - The root directory of the tool install.
	93	local root = [ feature.get-values <root> : $(options) ] ;
	94
	95	# - The bin directory where to find the commands to execute.
	96	local bin ;
	97
	98	# - The configured compile driver command.
	99	local command = [ common.get-invocation-command darwin : g++ : $(command) ] ;
	100
	101	# The version as reported by the compiler
	102	local real-version ;
	103
	104	# - Autodetect the root and bin dir if not given.
	105	if $(command)
	106	{
	107	bin ?= [ common.get-absolute-tool-path $(command[1]) ] ;
	108	if $(bin) = "/usr/bin"
	109	{
	110	root ?= /Developer ;
	111	}
	112	else
	113	{
	114	local r = $(bin:D) ;
	115	r = $(r:D) ;
	116	root ?= $(r) ;
	117	}
	118	}
	119
	120	# - Autodetect the version if not given.
	121	if $(command)
	122	{
	123	# - The 'command' variable can have multiple elements. When calling
	124	# the SHELL builtin we need a single string.
	125	local command-string = $(command:J=" ") ;
	126	real-version = [ MATCH "^([0-9.]+)"
	127	: [ SHELL "$(command-string) -dumpversion" ] ] ;
	128	version ?= $(real-version) ;
	129	}
	130
	131	.real-version.$(version) = $(real-version) ;
	132
	133	# - Define the condition for this toolset instance.
	134	local condition =
	135	[ common.check-init-parameters darwin $(requirement) : version $(version) ] ;
	136
	137	# - Set the toolset generic common options.
	138	common.handle-options darwin : $(condition) : $(command) : $(options) ;
	139
20effc67	140	real-version = [ regex.split $(real-version) \\. ] ;
7c673cae	141	# - GCC 4.0 and higher in Darwin does not have -fcoalesce-templates.
20effc67	142	if [ version.version-less $(real-version) : 4 0 ]
7c673cae FG	143	{
	144	flags darwin.compile.c++ OPTIONS $(condition) : -fcoalesce-templates ;
	145	}
	146	# - GCC 4.2 and higher in Darwin does not have -Wno-long-double.
20effc67	147	if [ version.version-less $(real-version) : 4 2 ]
7c673cae FG	148	{
	149	flags darwin.compile OPTIONS $(condition) : -Wno-long-double ;
	150	}
	151	# - GCC on Darwin with -pedantic, suppress unsupported long long warning
20effc67	152	flags darwin.compile OPTIONS $(condition)/<warnings>pedantic : -Wno-long-long ;
7c673cae	153
92f5a8d4	154	# - GCC on El Capitan (10.11) does not support -finline-functions
7c673cae FG	155	if "10.11.0" <= $(.host-osx-version)
	156	{
	157	flags darwin.compile OPTIONS $(condition)/<inlining>full : -Wno-inline ;
	158	}
	159
7c673cae FG	160	# - The symbol strip program.
	161	local strip ;
	162	if <striper> in $(options)
	163	{
	164	# We can turn off strip by specifying it as empty. In which
	165	# case we switch to using the linker to do the strip.
	166	flags darwin.link.dll OPTIONS
	167	$(condition)/<main-target-type>LIB/<link>shared/<address-model>32/<strip>on : -Wl,-x ;
	168	flags darwin.link.dll OPTIONS
	169	$(condition)/<main-target-type>LIB/<link>shared/<address-model>/<strip>on : -Wl,-x ;
	170	flags darwin.link OPTIONS
	171	$(condition)/<main-target-type>EXE/<address-model>32/<strip>on : -s ;
	172	flags darwin.link OPTIONS
	173	$(condition)/<main-target-type>EXE/<address-model>/<strip>on : -s ;
	174	}
	175	else
	176	{
	177	# Otherwise we need to find a strip program to use. And hence
	178	# also tell the link action that we need to use a strip
	179	# post-process.
	180	flags darwin.link NEED_STRIP $(condition)/<strip>on : "" ;
	181	strip =
	182	[ common.get-invocation-command darwin
	183	: strip : [ feature.get-values <striper> : $(options) ] : $(bin) : search-path ] ;
	184	flags darwin.link .STRIP $(condition) : $(strip[1]) ;
	185	if $(.debug-configuration)
	186	{
11fdf7f2	187	ECHO notice\: using strip for $(condition) at $(strip[1]) ;
7c673cae FG	188	}
	189	}
	190
	191	# - The archive builder (libtool is the default as creating
	192	# archives in darwin is complicated.
	193	local archiver =
	194	[ common.get-invocation-command darwin
	195	: libtool : [ feature.get-values <archiver> : $(options) ] : $(bin) : search-path ] ;
	196	flags darwin.archive .LIBTOOL $(condition) : $(archiver[1]) ;
	197	if $(.debug-configuration)
	198	{
11fdf7f2	199	ECHO notice\: using archiver for $(condition) at $(archiver[1]) ;
7c673cae FG	200	}
	201
	202	# - Initialize the SDKs available in the root for this tool.
	203	local sdks = [ init-available-sdk-versions $(condition) : $(root) ] ;
	204
	205	#~ ECHO --- ;
	206	#~ ECHO --- bin :: $(bin) ;
	207	#~ ECHO --- root :: $(root) ;
	208	#~ ECHO --- version :: $(version) ;
	209	#~ ECHO --- condition :: $(condition) ;
	210	#~ ECHO --- strip :: $(strip) ;
	211	#~ ECHO --- archiver :: $(archiver) ;
	212	#~ ECHO --- sdks :: $(sdks) ;
	213	#~ ECHO --- ;
	214	#~ EXIT ;
	215	}
	216
	217	# Add and set options for a discovered SDK version.
	218	local rule init-sdk ( condition * : root ? : version + : version-feature ? )
	219	{
	220	local rule version-to-feature ( version + )
	221	{
	222	switch $(version[1])
	223	{
	224	case appletv* :
	225	{
	226	return $(version[1])-$(version[2-]:J=.) ;
	227	}
	228	case iphone* :
	229	{
	230	return $(version[1])-$(version[2-]:J=.) ;
	231	}
	232	case mac* :
	233	{
	234	return $(version[2-]:J=.) ;
	235	}
	236	case * :
	237	{
	238	return $(version:J=.) ;
	239	}
	240	}
	241	}
	242
	243	if $(version-feature)
	244	{
	245	if $(.debug-configuration)
	246	{
11fdf7f2	247	ECHO notice\: available sdk for $(condition)/<macosx-version>$(version-feature) at $(root) ;
7c673cae FG	248	}
	249
	250	# Add the version to the features for specifying them.
	251	if ! $(version-feature) in [ feature.values macosx-version ]
	252	{
	253	feature.extend macosx-version : $(version-feature) ;
	254	}
	255	if ! $(version-feature) in [ feature.values macosx-version-min ]
	256	{
	257	feature.extend macosx-version-min : $(version-feature) ;
	258	}
	259
	260	# Set the flags the version needs to compile with, first
	261	# generic options.
	262	flags darwin.compile OPTIONS $(condition)/<macosx-version>$(version-feature)
	263	: -isysroot $(root) ;
	264	flags darwin.link OPTIONS $(condition)/<macosx-version>$(version-feature)
	265	: -isysroot $(root) ;
	266
	267	# Then device variation options.
	268	switch $(version[1])
	269	{
	270	case appletvsim* :
	271	{
	272	local N = $(version[2]) ;
	273	if ! $(version[3]) { N += 00 ; }
	274	else if [ regex.match (..) : $(version[3]) ] { N += $(version[3]) ; }
	275	else { N += 0$(version[3]) ; }
	276	if ! $(version[4]) { N += 00 ; }
	277	else if [ regex.match (..) : $(version[4]) ] { N += $(version[4]) ; }
	278	else { N += 0$(version[4]) ; }
	279	N = $(N:J=) ;
	280	flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
	281	: -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
	282	flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
	283	: -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
	284	}
	285
	286	case appletv* :
	287	{
	288	flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
	289	: -mtvos-version-min=$(version[2-]:J=.) ;
	290	flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
	291	: -mtvos-version-min=$(version[2-]:J=.) ;
	292	}
	293
	294	case iphonesim* :
	295	{
	296	local N = $(version[2]) ;
	297	if ! $(version[3]) { N += 00 ; }
	298	else if [ regex.match (..) : $(version[3]) ] { N += $(version[3]) ; }
	299	else { N += 0$(version[3]) ; }
	300	if ! $(version[4]) { N += 00 ; }
	301	else if [ regex.match (..) : $(version[4]) ] { N += $(version[4]) ; }
	302	else { N += 0$(version[4]) ; }
	303	N = $(N:J=) ;
	304	flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
	305	: -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
	306	flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
	307	: -D__IPHONE_OS_VERSION_MIN_REQUIRED=$(N) ;
	308	}
	309
	310	case iphone* :
	311	{
312	flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
313	: -miphoneos-version-min=$(version[2-]:J=.) ;
314	flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
315	: -miphoneos-version-min=$(version[2-]:J=.) ;
316	}
317
318	case mac* :
319	{
320	flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
321	: -mmacosx-version-min=$(version[2-]:J=.) ;
322	flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
323	: -mmacosx-version-min=$(version[2-]:J=.) ;
324	}
325	}
326
327	if $(version[3]) > 0
328	{
329	# We have a minor version of an SDK. We want to set up
330	# previous minor versions, plus the current minor version.
331	# So we recurse to set up the previous minor versions, up to
332	# the current version.
333	local minor-minus-1 = [ CALC $(version[3]) - 1 ] ;
334	return
335	[ init-sdk $(condition) : $(root)
336	: $(version[1-2]) $(minor-minus-1) : [ version-to-feature $(version[1-2]) $(minor-minus-1) ] ]
337	$(version-feature) ;
338	}
339	else
340	{
341	return $(version-feature) ;
342	}
343	}
344	else if $(version[4])
345	{
346	# We have a patch version of an SDK. We want to set up
347	# both the specific patch version, and the minor version.
348	# So we recurse to set up the patch version. Plus the minor version.
349	return
350	[ init-sdk $(condition) : $(root)
351	: $(version[1-3]) : [ version-to-feature $(version[1-3]) ] ]
352	[ init-sdk $(condition) : $(root)
353	: $(version) : [ version-to-feature $(version) ] ] ;
354	}
355	else
356	{
357	# Yes, this is intentionally recursive.
358	return
359	[ init-sdk $(condition) : $(root)
360	: $(version) : [ version-to-feature $(version) ] ] ;
361	}
362	}
363
364	# Determine the MacOSX SDK versions installed and their locations.
365	local rule init-available-sdk-versions ( condition * : root ? )
366	{
367	root ?= /Developer ;
368	local sdks-root = $(root)/SDKs ;
369	local sdks = [ GLOB $(sdks-root) : MacOSX.sdk AppleTVOS.sdk AppleTVSimulator.sdk iPhoneOS.sdk iPhoneSimulator*.sdk ] ;
370	local result ;
371	for local sdk in $(sdks)
372	{
11fdf7f2	373	local sdk-match = [ MATCH "([^0-9]+)([0-9]+)[.]([0-9x]+)[.]?([0-9x]+)?" : $(sdk:D=) ] ;
7c673cae FG	374	local sdk-platform = $(sdk-match[1]:L) ;
	375	local sdk-version = $(sdk-match[2-]) ;
	376	if $(sdk-version)
	377	{
	378	switch $(sdk-platform)
	379	{
	380	case macosx :
	381	{
	382	sdk-version = mac $(sdk-version) ;
	383	}
	384	case appletvos :
	385	{
	386	sdk-version = appletv $(sdk-version) ;
	387	}
	388	case appletvsimulator :
	389	{
	390	sdk-version = appletvsim $(sdk-version) ;
	391	}
	392	case iphoneos :
	393	{
	394	sdk-version = iphone $(sdk-version) ;
	395	}
	396	case iphonesimulator :
	397	{
	398	sdk-version = iphonesim $(sdk-version) ;
	399	}
	400	case * :
	401	{
	402	sdk-version = $(sdk-version:J=-) ;
	403	}
	404	}
	405	result += [ init-sdk $(condition) : $(sdk) : $(sdk-version) ] ;
	406	}
	407	}
	408	return $(result) ;
	409	}
	410
	411	# Generic options.
	412	flags darwin.compile OPTIONS <flags> ;
	413
	414	# The following adds objective-c support to darwin.
	415	# Thanks to http://thread.gmane.org/gmane.comp.lib.boost.build/13759
	416
	417	generators.register-c-compiler darwin.compile.m : OBJECTIVE_C : OBJ : <toolset>darwin ;
	418	generators.register-c-compiler darwin.compile.mm : OBJECTIVE_CPP : OBJ : <toolset>darwin ;
	419
	420	rule setup-address-model ( targets * : sources * : properties * )
	421	{
	422	local ps = [ property-set.create $(properties) ] ;
	423	local arch = [ $(ps).get <architecture> ] ;
	424	local instruction-set = [ $(ps).get <instruction-set> ] ;
	425	local address-model = [ $(ps).get <address-model> ] ;
	426	local osx-version = [ $(ps).get <macosx-version> ] ;
	427	local gcc-version = [ $(ps).get <toolset-darwin:version> ] ;
	428	gcc-version = $(.real-version.$(gcc-version)) ;
	429	local options ;
	430
	431	local support-ppc64 = 1 ;
	432
	433	osx-version ?= $(.host-osx-version) ;
	434
	435	switch $(osx-version)
	436	{
	437	case iphone* :
438	{
439	support-ppc64 = ;
440	}
441
442	case * :
443	if $(osx-version) && ! [ version.version-less [ regex.split $(osx-version) \\. ] : 10 6 ]
444	{
445	# When targeting 10.6:
446	# - gcc 4.2 will give a compiler errir if ppc64 compilation is requested
447	# - gcc 4.0 will compile fine, somehow, but then fail at link time
448	support-ppc64 = ;
449	}
450	}
451	switch $(arch)
452	{
453	case combined :
454	{
455	if $(address-model) = 32_64 {
456	if $(support-ppc64) {
457	options = -arch i386 -arch ppc -arch x86_64 -arch ppc64 ;
458	} else {
459	# Build 3-way binary
460	options = -arch i386 -arch ppc -arch x86_64 ;
461	}
462	} else if $(address-model) = 64 {
463	if $(support-ppc64) {
464	options = -arch x86_64 -arch ppc64 ;
465	} else {
466	errors.user-error "64-bit PPC compilation is not supported when targeting OSX 10.6 or later" ;
467	}
468	} else {
469	options = -arch i386 -arch ppc ;
470	}
471	}
472
473	case x86 :
474	{
475	if $(address-model) = 32_64 {
476	options = -arch i386 -arch x86_64 ;
477	} else if $(address-model) = 64 {
478	options = -arch x86_64 ;
479	} else {
480	options = -arch i386 ;
481	}
482	}
483
484	case power :
485	{
486	if ! $(support-ppc64)
487	&& ( $(address-model) = 32_64 \|\| $(address-model) = 64 )
488	{
489	errors.user-error "64-bit PPC compilation is not supported when targeting OSX 10.6 or later" ;
490	}
491
492	if $(address-model) = 32_64 {
493	options = -arch ppc -arch ppc64 ;
494	} else if $(address-model) = 64 {
495	options = -arch ppc64 ;
496	} else {
497	options = -arch ppc ;
498	}
499	}
500
501	case arm :
502	{
503	if $(instruction-set) {
504	options = -arch$(_)$(instruction-set) ;
505	} else {
506	options = -arch arm ;
507	}
508	}
509	}
510
511	if $(options)
512	{
513	OPTIONS on $(targets) += $(options) ;
514	}
515	}
516
7c673cae FG	517	rule compile.m ( targets * : sources * : properties * )
	518	{
	519	LANG on $(<) = "-x objective-c" ;
b32b8144	520	gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;
7c673cae FG	521	setup-address-model $(targets) : $(sources) : $(properties) ;
	522	}
	523
	524	actions compile.m
	525	{
	526	"$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
	527	}
	528
	529	rule compile.mm ( targets * : sources * : properties * )
	530	{
	531	LANG on $(<) = "-x objective-c++" ;
b32b8144	532	gcc.set-fpic-options $(targets) : $(sources) : $(properties) ;
7c673cae FG	533	setup-address-model $(targets) : $(sources) : $(properties) ;
	534	}
	535
	536	actions compile.mm
	537	{
	538	"$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
	539	}
	540
	541	# Set the max header padding to allow renaming of libs for installation.
	542	flags darwin.link.dll OPTIONS : -headerpad_max_install_names ;
	543
	544	# To link the static runtime we need to link to all the core runtime libraries.
	545	flags darwin.link OPTIONS <runtime-link>static
	546	: -nodefaultlibs -shared-libgcc -lstdc++-static -lgcc_eh -lgcc -lSystem ;
	547
	548	# Strip as much as possible when optimizing.
	549	flags darwin.link OPTIONS <optimization>speed : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;
	550	flags darwin.link OPTIONS <optimization>space : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;
	551
	552	# Dynamic/shared linking.
	553	flags darwin.compile OPTIONS <link>shared : -dynamic ;
	554
	555	# Misc options.
	556	flags darwin.compile OPTIONS : -gdwarf-2 -fexceptions ;
	557	#~ flags darwin.link OPTIONS : -fexceptions ;
	558
	559	# Add the framework names to use.
	560	flags darwin.link FRAMEWORK <framework> ;
	561
	562	#
	563	flags darwin.link FORCE_LOAD <force-load> ;
	564
	565	# This is flag is useful for debugging the link step
	566	# uncomment to see what libtool is doing under the hood
	567	#~ flags darwin.link.dll OPTIONS : -Wl,-v ;
	568
	569	# set up the -F option to include the paths to any frameworks used.
	570	local rule prepare-framework-path ( target + )
	571	{
	572	# The -framework option only takes basename of the framework.
	573	# The -F option specifies the directories where a framework
	574	# is searched for. So, if we find <framework> feature
	575	# with some path, we need to generate property -F option.
	576	local framework-paths = [ on $(target) return $(FRAMEWORK:D) ] ;
	577
	578	# Be sure to generate no -F if there's no path.
	579	for local framework-path in $(framework-paths)
	580	{
	581	if $(framework-path) != ""
	582	{
	583	FRAMEWORK_PATH on $(target) += -F$(framework-path) ;
	584	}
	585	}
	586	}
	587
	588	rule link ( targets * : sources * : properties * )
	589	{
	590	DEPENDS $(targets) : [ on $(targets) return $(FORCE_LOAD) ] ;
	591	setup-address-model $(targets) : $(sources) : $(properties) ;
	592	prepare-framework-path $(<) ;
	593	}
	594
	595	# Note that using strip without any options was reported to result in broken
	596	# binaries, at least on OS X 10.5.5, see:
597	# http://svn.boost.org/trac/boost/ticket/2347
598	# So we pass -S -x.
599	actions link bind LIBRARIES FORCE_LOAD
600	{
601	"$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" "$(>)" -Wl,-force_load$(_)"$(FORCE_LOAD)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(FRAMEWORK_PATH) -framework$(_)$(FRAMEWORK:D=:S=) $(OPTIONS) $(USER_OPTIONS)
602	$(NEED_STRIP)"$(.STRIP)" $(NEED_STRIP)-S $(NEED_STRIP)-x $(NEED_STRIP)"$(<)"
603	}
604
605	rule link.dll ( targets * : sources * : properties * )
606	{
607	setup-address-model $(targets) : $(sources) : $(properties) ;
608	prepare-framework-path $(<) ;
609	}
610
611	actions link.dll bind LIBRARIES
612	{
613	"$(CONFIG_COMMAND)" -dynamiclib -Wl,-single_module -install_name "$(<:B)$(<:S)" -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(FRAMEWORK_PATH) -framework$(_)$(FRAMEWORK:D=:S=) $(OPTIONS) $(USER_OPTIONS)
614	}
615
616	# We use libtool instead of ar to support universal binary linking
617	# TODO: Find a way to use the underlying tools, i.e. lipo, to do this.
618	actions piecemeal archive
619	{
620	"$(.LIBTOOL)" -static -o "$(<:T)" $(ARFLAGS) "$(>:T)"
621	}