diff options
Diffstat (limited to 'dev-util')
| -rw-r--r-- | dev-util/boost-build/54f811b7593dc751ec1b306cad27f32cfce81f36.patch | 928 | ||||
| -rw-r--r-- | dev-util/boost-build/remove-gcc-link-semaphore.patch | 20 |
2 files changed, 928 insertions, 20 deletions
diff --git a/dev-util/boost-build/54f811b7593dc751ec1b306cad27f32cfce81f36.patch b/dev-util/boost-build/54f811b7593dc751ec1b306cad27f32cfce81f36.patch new file mode 100644 index 0000000..51218f2 --- /dev/null +++ b/dev-util/boost-build/54f811b7593dc751ec1b306cad27f32cfce81f36.patch @@ -0,0 +1,928 @@ +From 54f811b7593dc751ec1b306cad27f32cfce81f36 Mon Sep 17 00:00:00 2001 +From: Rene Rivera <grafikrobot@gmail.com> +Date: Fri, 28 Aug 2020 10:36:41 -0500 +Subject: [PATCH] Remove limit on one link at a time limit. + +The reason for limiting links to one at a time is long obsolete. Hence +we can remove almost all uses of JAM_SEMAPHORE to impose that +one-link-at-a-time limit. +--- + tools/clang-darwin.jam | 3 - + tools/clang-linux.jam | 20 +++--- + tools/clang-vxworks.jam | 25 ++++---- + tools/cray.jam | 5 -- + tools/embarcadero.jam | 124 ++++++++++++++++++------------------ + tools/gcc.jam | 10 --- + tools/intel-darwin.jam | 43 ++++++------- + tools/intel-linux.jam | 68 ++++++++++---------- + tools/intel-vxworks.jam | 5 +- + tools/qcc.jam | 5 -- + 10 files changed, 135 insertions(+), 173 deletions(-) + +diff --git a/tools/clang-darwin.jam b/tools/clang-darwin.jam +index 11f62d298b..0618d9f054 100644 +--- a/tools/clang-darwin.jam ++++ b/tools/clang-darwin.jam +@@ -173,9 +173,6 @@ actions piecemeal archive + rule link ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- # Serialize execution of the 'link' action, since +- # running N links in parallel is just slower. +- JAM_SEMAPHORE on $(targets) = <s>clang-darwin-link-semaphore ; + } + + actions link bind LIBRARIES +diff --git a/tools/clang-linux.jam b/tools/clang-linux.jam +index d5c9ed744e..28ddcde7ba 100644 +--- a/tools/clang-linux.jam ++++ b/tools/clang-linux.jam +@@ -207,16 +207,15 @@ SPACE = " " ; + + rule link ( targets * : sources * : properties * ) { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>clang-linux-link-semaphore ; +- ++ + local tosw ; + local pselect = [ property.select <target-os> : $(properties) ] ; +- ++ + if $(pselect) + { +- ++ + local tosv = [ feature.get-values <target-os> : $(pselect) ] ; +- ++ + if $(tosv) = windows + { + tosw = 1 ; +@@ -238,16 +237,15 @@ rule link ( targets * : sources * : properties * ) { + + rule link.dll ( targets * : sources * : properties * ) { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>clang-linux-link-semaphore ; +- ++ + local tosw ; + local pselect = [ property.select <target-os> : $(properties) ] ; +- ++ + if $(pselect) + { +- ++ + local tosv = [ feature.get-values <target-os> : $(pselect) ] ; +- ++ + if $(tosv) = windows + { + tosw = 1 ; +@@ -285,5 +283,5 @@ actions link-w bind LIBRARIES { + # Target OS is Windows, does not need the RPATH and SONAME stuff + actions link.dll-w bind LIBRARIES { + "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" -shared @"@($(<[1]:T).rsp:E=$(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP))" $(OPTIONS) $(USER_OPTIONS) +- ++ + } +diff --git a/tools/clang-vxworks.jam b/tools/clang-vxworks.jam +index d5dfc33a0d..33fe3ef2bf 100644 +--- a/tools/clang-vxworks.jam ++++ b/tools/clang-vxworks.jam +@@ -16,9 +16,9 @@ import generators ; + + feature.extend-subfeature toolset clang : platform : vxworks ; + +-toolset.inherit-generators clang-vxworks +- <toolset>clang <toolset-clang:platform>vxworks +- : gcc ++toolset.inherit-generators clang-vxworks ++ <toolset>clang <toolset-clang:platform>vxworks ++ : gcc + # Don't inherit PCH generators. They were not tested, and probably + # don't work for this compiler. + : gcc.mingw.link gcc.mingw.link.dll gcc.compile.c.pch gcc.compile.c++.pch +@@ -30,12 +30,12 @@ generators.override clang-vxworks.searched-lib-generator : searched-lib-generato + + + toolset.inherit-rules clang-vxworks : gcc ; +-toolset.inherit-flags clang-vxworks : gcc ++toolset.inherit-flags clang-vxworks : gcc + : <inlining>full + <architecture>x86/<address-model>32 + <architecture>x86/<address-model>64 + ; +- ++ + if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ] + { + .debug-configuration = true ; +@@ -45,22 +45,22 @@ if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ] + # compile and link options allow you to specify addition command line options for each version + rule init ( version ? : command * : options * ) + { +- command = [ common.get-invocation-command clang-vxworks : ccllvm ++ command = [ common.get-invocation-command clang-vxworks : ccllvm + : $(command) ] ; +- ++ + linker = [ get-values <linker> : $(options) ] ; + linker ?= ld ; +- ++ + # Determine the version + local command-string = $(command:J=" ") ; + if $(command) +- { ++ { + version ?= [ MATCH "^([0-9.]+)" + : [ SHELL "$(command-string) -dumpversion" ] ] ; + } + + local condition = [ common.check-init-parameters clang-vxworks +- : version $(version) ] ; ++ : version $(version) ] ; + + common.handle-options clang-vxworks : $(condition) : $(command) : $(options) ; + +@@ -112,14 +112,11 @@ actions piecemeal archive + rule link ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- # Serialize execution of the 'link' action, since +- # running N links in parallel is just slower. +- JAM_SEMAPHORE on $(targets) = <s>clang-vxworks-link-semaphore ; + } + + actions link bind LIBRARIES + { +- "$(.LD)" $(USER_OPTIONS) -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" $(START-GROUP) $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) ++ "$(.LD)" $(USER_OPTIONS) -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" $(START-GROUP) $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) + } + + actions link.dll bind LIBRARIES +diff --git a/tools/cray.jam b/tools/cray.jam +index d586af3af4..e4f4ec0d4b 100644 +--- a/tools/cray.jam ++++ b/tools/cray.jam +@@ -644,10 +644,6 @@ rule gcc-link-procedure ( targets * : sources * : properties * ) + # Copied from 'gcc.jam'. + + 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 ; + gcc.quote-rpath $(targets) ; + } + +@@ -657,7 +653,6 @@ rule gcc-link-dll-procedure ( targets * : sources * : properties * ) + # Copied from 'gcc.jam'. + + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; + gcc.quote-rpath $(targets) ; + } + +diff --git a/tools/embarcadero.jam b/tools/embarcadero.jam +index c54a1ef5eb..9bf094f21b 100644 +--- a/tools/embarcadero.jam ++++ b/tools/embarcadero.jam +@@ -25,7 +25,7 @@ several versions of the compiler. + + `version`: + +-The version should be the compiler version if specified. if the ++The version should be the compiler version if specified. if the + version is not specified Boost Build will find the latest installed + version of Embarcadero C++ and use that for the version. If the version + is specified Boost Build does not check if this matches any particular +@@ -146,8 +146,8 @@ generators.override embarcadero.prebuilt : builtin.prebuilt ; + generators.override embarcadero.searched-lib-generator : searched-lib-generator ; + + toolset.inherit-rules embarcadero : clang-linux ; +-toolset.inherit-flags embarcadero +- : clang-linux ++toolset.inherit-flags embarcadero ++ : clang-linux + : <runtime-link>shared + <link>shared + <threading>multi +@@ -192,9 +192,9 @@ rule init ( version ? : command * : options * ) + local compiler = bcc64 ; + local preprocessor = cpp64 ; + local amodel = 64 ; +- ++ + local optam = [ feature.get-values <address-model> : $(options) ] ; +- ++ + if $(optam) + { + if $(optam) = 32 +@@ -208,29 +208,29 @@ rule init ( version ? : command * : options * ) + $(optam) = "" ; + } + } +- ++ + command = [ common.get-invocation-command embarcadero : $(compiler) : $(command) ] ; +- ++ + switch $(command[1]:BL) + { + case bcc32x : + compiler = bcc32x ; + preprocessor = cpp32x ; + amodel = 32 ; +- case bcc64 : ++ case bcc64 : + compiler = bcc64 ; + preprocessor = cpp64 ; + amodel = 64 ; +- case "bcc32x.exe" : ++ case "bcc32x.exe" : + compiler = bcc32x ; + preprocessor = cpp32x ; + amodel = 32 ; +- case "bcc64.exe" : ++ case "bcc64.exe" : + compiler = bcc64 ; + preprocessor = cpp64 ; + amodel = 64 ; + } +- ++ + if $(optam) && $(optam) != $(amodel) + { + errors.user-error "embarcadero initialization: compiler and address model" : +@@ -250,43 +250,43 @@ rule init ( version ? : command * : options * ) + cl_version = 5.0 ; + } + } +- ++ + local condition = [ common.check-init-parameters embarcadero : version $(version) ] ; + handle-options $(condition) : $(command) : $(options) ; +- ++ + # Support for the Embarcadero root directory. If the Embarcadero binary + # directory is not in the PATH we need to tell the underlying clang + # implementation where to find the Embarcadero header/library files + # and set the correct runtime path so that we can execute Embarcadero + # programs and find Embarcadero DLLs. +- ++ + local root = [ feature.get-values <root> : $(options) ] ; +- ++ + # 1) Look in registry +- ++ + if ! $(root) + { +- ++ + local sdkdir = [ get_sdk_dir ] ; +- ++ + if $(sdkdir) + { +- ++ + local bdsv = [ get_bds_version $(sdkdir) ] ; +- ++ + if $(bdsv) + { +- ++ + local has_dec = [ MATCH "(.+[.])" : $(bdsv) ] ; + local bdsv_full ; +- ++ + if ! $(has_dec) + { + bdsv_full = $(bdsv).0 ; + } +- ++ + local troot = [ W32_GETREG "HKEY_LOCAL_MACHINE\\SOFTWARE\\Embarcadero\\BDS\\$(bdsv)" : RootDir ] ; +- ++ + if $(troot) + { + troot = $(troot:T) ; +@@ -320,44 +320,44 @@ rule init ( version ? : command * : options * ) + troot = [ concatenate $(troot) : name ] ; + root = $(troot:D) ; + } +- } ++ } + } + } + } + } + } +- +- ++ ++ + # 2) Look for path in the command +- ++ + if ! $(root) + { +- ++ + local cpath = $(command[1]:D) ; +- ++ + if $(cpath) + { + root = $(cpath:P) ; + } + } +- ++ + # 3) Search for the directory of the command +- +- if ! $(root) ++ ++ if ! $(root) + { +- ++ + local pdirs = [ path.programs-path ] ; +- ++ + for local dir in $(pdirs) + { +- ++ + local match = [ MATCH "/(.:.+)" : $(dir) ] ; +- ++ + if $(match) + { + dir = "$(match)" ; + } +- ++ + if [ CHECK_IF_FILE $(dir)/$(command) ] + { + root = $(dir:P) ; +@@ -370,24 +370,24 @@ rule init ( version ? : command * : options * ) + } + } + } +- +- if ! $(root) ++ ++ if ! $(root) + { + errors.user-error "Embarcadero toolset initialization: the root directory for the Embarcadero installation can not be found" ; + } + else + { +- ++ + local lib_path = $(root)/bin $(root)/bin64 $(root)/Bpl C:/Users/Public/Documents/Embarcadero ; + if $(.debug-configuration) + { + ECHO "notice:" using Embarcadero libraries with clang compilation"::" $(condition) "::" $(lib_path) ; + } + flags embarcadero.link RUN_PATH $(condition) : $(lib_path) ; +- ++ + local system_include_option = "-isystem " ; + local system_include_directories = $(root)/include/windows/crtl $(root)/include/windows/sdk $(root)/include/windows/rtl $(root)/include/dinkumware64 ; +- ++ + local lib_dir_release ; + local lib_dir_debug ; + local archiver ; +@@ -396,7 +396,7 @@ rule init ( version ? : command * : options * ) + local assembler ; + local asmflags ; + local asmoutput ; +- ++ + if $(compiler) = bcc32x + { + lib_dir_release = $(root)/lib/win32c/release $(root)/lib/win32c/release/psdk ; +@@ -405,7 +405,7 @@ rule init ( version ? : command * : options * ) + arflags = /P512 ; + implib = implib ; + assembler = $(root)/bin/tasm32 ; +- ++ + # /ml makes all symbol names case-sensitive + + asmflags = /ml ; +@@ -413,14 +413,14 @@ rule init ( version ? : command * : options * ) + } + else if $(compiler) = bcc64 + { +- ++ + lib_dir_release = $(root)/lib/win64/release $(root)/lib/win64/release/psdk ; + lib_dir_debug = $(root)/lib/win64/debug ; + archiver = tlib64 ; + arflags = /P2048 ; + implib = mkexp ; + } +- ++ + flags embarcadero.compile .EMB_SYSINC $(condition) : $(system_include_option)$(system_include_directories) ; + flags embarcadero.link LINKPATH $(condition)/<variant>release : $(lib_dir_release) ; + flags embarcadero.link LINKPATH $(condition)/<variant>debug : $(lib_dir_debug) $(lib_dir_release) ; +@@ -432,9 +432,9 @@ rule init ( version ? : command * : options * ) + flags embarcadero.asm USER_OPTIONS $(condition) : [ feature.get-values <asmflags> : $(options) ] ; + flags embarcadero.archive AROPTIONS $(condition) : [ feature.get-values <archiveflags> : $(options) ] ; + flags embarcadero.link.dll .IMPLIB_COMMAND $(condition) : $(root)/bin/$(implib) ; +- ++ + local mte = [ feature.get-values <user-interface> : $(options) ] ; +- ++ + if $(mte) + { + flags embarcadero OPTIONS <main-target-type>EXE/$(condition) : <user-interface>$(mte) ; +@@ -453,7 +453,7 @@ local rule concatenate ( path : name ) + local result ; + local has_ending_slash = [ MATCH ".*([/\\])$" : $(path) ] ; + local has_backward_slash = [ MATCH ".*([\\])" : $(path) ] ; +- ++ + if $(has_ending_slash) + { + result = $(path)$(name) ; +@@ -471,28 +471,28 @@ local rule concatenate ( path : name ) + + local rule get_sdk_dir ( ) + { +- ++ + local ret ; + local appdata = [ os.environ APPDATA ] ; +- ++ + if $(appdata) + { + ret = $(appdata:T)/Embarcadero/BDS ; + } + return $(ret) ; + } +- ++ + local rule get_bds_version ( sdir ) + { +- ++ + local ret ; + local flist = [ GLOB $(sdir) : * ] ; +- ++ + if $(flist) + { +- ++ + local dirs ; +- ++ + for local file in $(flist) + { + if ! [ CHECK_IF_FILE $(file) ] +@@ -502,9 +502,9 @@ local rule get_bds_version ( sdir ) + } + if $(dirs) + { +- ++ + local ldir = $(dirs[-1]) ; +- ++ + ret = $(ldir:B) ; + } + } +@@ -559,7 +559,7 @@ local opt_drtl = -tR ; + local opt_dapp = -tW ; + local opt_compile_flags = -DNDEBUG ; + local opt_lflags = "-lS:1048576 -lSc:4098 -lH:1048576 -lHc:8192" ; +- ++ + flags embarcadero OPTIONS <user-interface>console : $(opt_console) ; + flags embarcadero OPTIONS <user-interface>gui : $(opt_dapp) ; + flags embarcadero OPTIONS <runtime-link>shared : $(opt_drtl) ; +@@ -602,16 +602,14 @@ rule archive ( targets * : sources * : properties * ) + } + + actions updated together piecemeal archive +-{ ++{ + "$(.AR)" $(AROPTIONS) $(.ARFLAGS) /u /a /C "$(<)" +-"$(>)" + } + + rule link ( targets * : sources * : properties * ) { +- JAM_SEMAPHORE on $(targets) = <s>embarcadero-link-semaphore ; + } + + rule link.dll ( targets * : sources * : properties * ) { +- JAM_SEMAPHORE on $(targets) = <s>embarcadero-link-semaphore ; + } + + actions link bind LIBRARIES { +diff --git a/tools/gcc.jam b/tools/gcc.jam +index ff3209f7b8..1fb10e01ab 100644 +--- a/tools/gcc.jam ++++ b/tools/gcc.jam +@@ -1096,33 +1096,23 @@ rule quote-rpath ( targets * ) + 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 ; + quote-rpath $(targets) ; + } + + rule link.dll ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; + quote-rpath $(targets) ; + } + + rule link.mingw ( 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 ; + } + + rule link.dll.mingw ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; + } + + actions link.mingw bind LIBRARIES +diff --git a/tools/intel-darwin.jam b/tools/intel-darwin.jam +index 6dc5d8e3bf..7da7b079c6 100644 +--- a/tools/intel-darwin.jam ++++ b/tools/intel-darwin.jam +@@ -16,9 +16,9 @@ import generators ; + + feature.extend-subfeature toolset intel : platform : darwin ; + +-toolset.inherit-generators intel-darwin +- <toolset>intel <toolset-intel:platform>darwin +- : gcc ++toolset.inherit-generators intel-darwin ++ <toolset>intel <toolset-intel:platform>darwin ++ : gcc + # Don't inherit PCH generators. They were not tested, and probably + # don't work for this compiler. + : gcc.mingw.link gcc.mingw.link.dll gcc.compile.c.pch gcc.compile.c++.pch +@@ -29,20 +29,20 @@ generators.override intel-darwin.prebuilt : builtin.prebuilt ; + generators.override intel-darwin.searched-lib-generator : searched-lib-generator ; + + toolset.inherit-rules intel-darwin : gcc ; +-toolset.inherit-flags intel-darwin : gcc +- : <inlining>off <inlining>on <inlining>full <optimization>space ++toolset.inherit-flags intel-darwin : gcc ++ : <inlining>off <inlining>on <inlining>full <optimization>space + <warnings>off <warnings>all <warnings>on + <warnings>extra <warnings>pedantic + <warnings-as-errors>off <warnings-as-errors>on + <architecture>x86/<address-model>32 + <architecture>x86/<address-model>64 + ; +- ++ + if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ] + { + .debug-configuration = true ; + } +- ++ + # Initializes the intel-darwin toolset + # version in mandatory + # name (default icc) is used to invoke the specified intel compiler +@@ -51,8 +51,8 @@ rule init ( version ? : command * : options * ) + { + local condition = [ common.check-init-parameters intel-darwin + : version $(version) ] ; +- +- command = [ common.get-invocation-command intel-darwin : icc ++ ++ command = [ common.get-invocation-command intel-darwin : icc + : $(command) : /opt/intel_cc_80/bin ] ; + + common.handle-options intel-darwin : $(condition) : $(command) : $(options) ; +@@ -67,12 +67,12 @@ rule init ( version ? : command * : options * ) + { + bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ; + root ?= $(bin:D) ; +- ++ + if $(root) + { + # Libraries required to run the executable may be in either +- # $(root)/lib (10.1 and earlier) +- # or ++ # $(root)/lib (10.1 and earlier) ++ # or + # $(root)/lib/architecture-name (11.0 and later: + local lib_path = $(root)/lib $(root:P)/lib/$(bin:B) ; + if $(.debug-configuration) +@@ -80,7 +80,7 @@ rule init ( version ? : command * : options * ) + ECHO notice\: using intel libraries "::" $(condition) "::" $(lib_path) ; + } + flags intel-darwin.link RUN_PATH $(condition) : $(lib_path) ; +- } ++ } + } + + local m = [ MATCH (..).* : $(version) ] ; +@@ -90,7 +90,7 @@ rule init ( version ? : command * : options * ) + } + + local major = $(m) ; +- ++ + if $(major) = "9" { + flags intel-darwin.compile OPTIONS $(condition)/<inlining>off : -Ob0 ; + flags intel-darwin.compile OPTIONS $(condition)/<inlining>on : -Ob1 ; +@@ -136,7 +136,7 @@ flags intel-darwin.compile.c++ OPTIONS <cxxflags> ; + + flags intel-darwin.compile OPTIONS <optimization>space : -O1 ; # no specific space optimization flag in icc + +-# ++# + .cpu-type-em64t = prescott nocona core2 corei7 corei7-avx core-avx-i + conroe conroe-xe conroe-l allendale merom + merom-xe kentsfield kentsfield-xe penryn wolfdale +@@ -190,11 +190,11 @@ 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 ++ # 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: + # +@@ -226,9 +226,6 @@ flags intel-darwin.link USER_OPTIONS <linkflags> ; + rule link ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- # Serialize execution of the 'link' action, since +- # running N links in parallel is just slower. +- JAM_SEMAPHORE on $(targets) = <s>intel-darwin-link-semaphore ; + } + + actions link bind LIBRARIES +diff --git a/tools/intel-linux.jam b/tools/intel-linux.jam +index 920cefed0f..d97ee231c0 100644 +--- a/tools/intel-linux.jam ++++ b/tools/intel-linux.jam +@@ -19,7 +19,7 @@ import numbers ; + + feature.extend-subfeature toolset intel : platform : linux ; + +-toolset.inherit-generators intel-linux ++toolset.inherit-generators intel-linux + <toolset>intel <toolset-intel:platform>linux : gcc : gcc.mingw.link gcc.mingw.link.dll ; + generators.override intel-linux.prebuilt : builtin.lib-generator ; + generators.override intel-linux.prebuilt : builtin.prebuilt ; +@@ -28,23 +28,23 @@ generators.override intel-linux.searched-lib-generator : searched-lib-generator + # Override default do-nothing generators. + generators.override intel-linux.compile.c.pch : pch.default-c-pch-generator ; + generators.override intel-linux.compile.c++.pch : pch.default-cpp-pch-generator ; +- ++ + type.set-generated-target-suffix PCH : <toolset>intel <toolset-intel:platform>linux : pchi ; + + toolset.inherit-rules intel-linux : gcc ; +-toolset.inherit-flags intel-linux : gcc ++toolset.inherit-flags intel-linux : gcc + : <inlining>off <inlining>on <inlining>full + <optimization>space <optimization>speed + <warnings>off <warnings>all <warnings>on + <warnings>extra <warnings>pedantic + <warnings-as-errors>off <warnings-as-errors>on + ; +- ++ + if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ] + { + .debug-configuration = true ; + } +- ++ + # Initializes the intel-linux toolset + # version in mandatory + # name (default icpc) is used to invoke the specified intel-linux compiler +@@ -53,7 +53,7 @@ rule init ( version ? : command * : options * ) + { + local condition = [ common.check-init-parameters intel-linux + : version $(version) ] ; +- ++ + if $(.debug-configuration) + { + ECHO "notice: intel-linux version is" $(version) ; +@@ -66,83 +66,83 @@ rule init ( version ? : command * : options * ) + # to a sane 'intel' folder in /opt. + if [ MATCH "(12[.]0|12)" : $(version) ] + { default_path = /opt/intel/bin ; } +- # Intel C++ Compiler 11.1. ++ # Intel C++ Compiler 11.1. + else if [ MATCH "(11[.]1)" : $(version) ] + { default_path = /opt/intel_cce_11.1.064.x86_64/bin ; } +- # Intel C++ Compiler 11.0. ++ # Intel C++ Compiler 11.0. + else if [ MATCH "(11[.]0|11)" : $(version) ] + { default_path = /opt/intel_cce_11.0.074.x86_64/bin ; } +- # Intel C++ Compiler 10.1. ++ # Intel C++ Compiler 10.1. + else if [ MATCH "(10[.]1)" : $(version) ] + { default_path = /opt/intel_cce_10.1.013_x64/bin ; } +- # Intel C++ Compiler 9.1. ++ # Intel C++ Compiler 9.1. + else if [ MATCH "(9[.]1)" : $(version) ] + { default_path = /opt/intel_cc_91/bin ; } +- # Intel C++ Compiler 9.0. ++ # Intel C++ Compiler 9.0. + else if [ MATCH "(9[.]0|9)" : $(version) ] + { default_path = /opt/intel_cc_90/bin ; } +- # Intel C++ Compiler 8.1. ++ # Intel C++ Compiler 8.1. + else if [ MATCH "(8[.]1)" : $(version) ] + { default_path = /opt/intel_cc_81/bin ; } + # Intel C++ Compiler 8.0 - this used to be the default, so now it's the +- # fallback. +- else ++ # fallback. ++ else + { default_path = /opt/intel_cc_80/bin ; } +- ++ + if $(.debug-configuration) + { + ECHO "notice: default search path for intel-linux is" $(default_path) ; + } + +- command = [ common.get-invocation-command intel-linux : icpc ++ command = [ common.get-invocation-command intel-linux : icpc + : $(command) : $(default_path) ] ; +- ++ + common.handle-options intel-linux : $(condition) : $(command) : $(options) ; +- ++ + local root = [ feature.get-values <root> : $(options) ] ; + local bin ; + if $(command) || $(root) + { + bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ; + root ?= $(bin:D) ; +- ++ + local command-string = $(command:J=" ") ; + local version-output = [ SHELL "$(command-string) --version" ] ; + local real-version = [ MATCH "([0-9.]+)" : $(version-output) ] ; + local major = [ MATCH "([0-9]+).*" : $(real-version) ] ; +- ++ + # If we failed to determine major version, use the behaviour for + # the current compiler. + if $(major) && [ numbers.less $(major) 10 ] + { + flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-Ob0" ; + flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-Ob1" ; +- flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-Ob2" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-Ob2" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ; + } + else if $(major) && [ numbers.less $(major) 11 ] + { +- flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; +- flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; +- flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ; + } + else # newer version of intel do have -Os (at least 11+, don't know about 10) +- { +- flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; +- flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; +- flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ; ++ { ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; ++ flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-Os" ; + flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ; +- } +- ++ } ++ + if $(root) + { + # Libraries required to run the executable may be in either +- # $(root)/lib (10.1 and earlier) +- # or ++ # $(root)/lib (10.1 and earlier) ++ # or + # $(root)/lib/architecture-name (11.0 and later: + local lib_path = $(root)/lib $(root:P)/lib/$(bin:B) ; + if $(.debug-configuration) +@@ -150,7 +150,7 @@ rule init ( version ? : command * : options * ) + ECHO notice\: using intel libraries "::" $(condition) "::" $(lib_path) ; + } + flags intel-linux.link RUN_PATH $(condition) : $(lib_path) ; +- } ++ } + } + } + +@@ -213,7 +213,6 @@ actions compile.c.pch + rule link ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>intel-linux-link-semaphore ; + } + + actions link bind LIBRARIES +@@ -224,7 +223,6 @@ actions link bind LIBRARIES + rule link.dll ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>intel-linux-link-semaphore ; + } + + # Differ from 'link' above only by -shared. +diff --git a/tools/intel-vxworks.jam b/tools/intel-vxworks.jam +index c217ead32c..e70e4e2610 100644 +--- a/tools/intel-vxworks.jam ++++ b/tools/intel-vxworks.jam +@@ -156,7 +156,7 @@ flags intel-vxworks ARFLAGS <archiveflags> ; + + rule archive ( targets * : sources * : properties * ) + { +- # Always remove archive and start again. ++ # Always remove archive and start again. + # of the archive. + # + local clean.a = $(targets[1])(clean) ; +@@ -179,9 +179,6 @@ flags intel-vxworks.link USER_OPTIONS <linkflags> ; + rule link ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- # Serialize execution of the 'link' action, since +- # running N links in parallel is just slower. +- JAM_SEMAPHORE on $(targets) = <s>intel-vxworks-link-semaphore ; + } + + actions link bind LIBRARIES +diff --git a/tools/qcc.jam b/tools/qcc.jam +index 740e90705d..aac6059661 100644 +--- a/tools/qcc.jam ++++ b/tools/qcc.jam +@@ -240,10 +240,6 @@ toolset.flags qcc.link RPATH_LINK : <xdll-path> : unchecked ; + 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 qcc links while it might +- # be a good idea to serialize all links. +- JAM_SEMAPHORE on $(targets) = <s>qcc-link-semaphore ; + check-target-platform $(1) ; + } + +@@ -289,7 +285,6 @@ actions piecemeal archive + rule link.dll ( targets * : sources * : properties * ) + { + SPACE on $(targets) = " " ; +- JAM_SEMAPHORE on $(targets) = <s>qcc-link-semaphore ; + check-target-platform $(1) ; + } + diff --git a/dev-util/boost-build/remove-gcc-link-semaphore.patch b/dev-util/boost-build/remove-gcc-link-semaphore.patch deleted file mode 100644 index 41e2a2a..0000000 --- a/dev-util/boost-build/remove-gcc-link-semaphore.patch +++ /dev/null @@ -1,20 +0,0 @@ ---- a/tools/gcc.jam 2020-06-15 10:53:45.252253351 +0100 -+++ b/tools/gcc.jam 2020-05-26 16:17:53.190885235 +0100 -@@ -1104,7 +1104,7 @@ - # 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 ; -+#JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; - quote-rpath $(targets) ; - } - -@@ -1116,7 +1116,7 @@ - rule link.dll ( targets * : sources * : properties * ) - { - SPACE on $(targets) = " " ; -- JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; -+#JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ; - quote-rpath $(targets) ; - } - |