[Boost-commit] svn:boost r61377 - trunk/tools/build/v2/tools

Subject: [Boost-commit] svn:boost r61377 - trunk/tools/build/v2/tools
From: dgregor_at_[hidden]
Date: 2010-04-18 15:43:41

Author: dgregor
Date: 2010-04-18 15:43:40 EDT (Sun, 18 Apr 2010)
New Revision: 61377
URL: http://svn.boost.org/trac/boost/changeset/61377

Log:
Experimental Boost.Build configuration for Clang.

Added:
   trunk/tools/build/v2/tools/clang-darwin.jam
      - copied, changed from r61372, /trunk/tools/build/v2/tools/darwin.jam
   trunk/tools/build/v2/tools/clang-unix.jam
      - copied, changed from r61372, /trunk/tools/build/v2/tools/gcc.jam
   trunk/tools/build/v2/tools/clang.jam   (contents, props changed)
Text files modified: 
   trunk/tools/build/v2/tools/clang-darwin.jam |   120 ++++++-------                           
   trunk/tools/build/v2/tools/clang-unix.jam   |   353 ++++++++++++++++----------------------- 
   trunk/tools/build/v2/tools/common.jam       |     2                                         
   3 files changed, 201 insertions(+), 274 deletions(-)

Copied: trunk/tools/build/v2/tools/clang-darwin.jam (from r61372, /trunk/tools/build/v2/tools/darwin.jam)
==============================================================================
--- /trunk/tools/build/v2/tools/darwin.jam	(original)
+++ trunk/tools/build/v2/tools/clang-darwin.jam	2010-04-18 15:43:40 EDT (Sun, 18 Apr 2010)
@@ -7,9 +7,6 @@
 # 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 ;
@@ -37,21 +34,27 @@
     .debug-configuration = true ;
 }
 
-feature.extend toolset : darwin ;
-import gcc ;
-toolset.inherit-generators darwin : gcc : gcc.mingw.link gcc.mingw.link.dll ;
+feature.extend toolset : clang-darwin ;
+import clang-unix ;
+feature.extend-subfeature toolset clang : platform : darwin ;
+
+toolset.inherit-generators clang-darwin
+  <toolset>clang <toolset-clang:platform>darwin
+  : clang-unix 
+  : clang-unix.mingw.link clang-unix.mingw.link.dll 
+  ;
 
-generators.override darwin.prebuilt : builtin.prebuilt ;
-generators.override darwin.searched-lib-generator : searched-lib-generator ;
+generators.override clang-darwin.prebuilt : builtin.prebuilt ;
+generators.override clang-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 ;
+generators.override clang-darwin.compile.c.pch   : pch.default-c-pch-generator   ;
+generators.override clang-darwin.compile.c++.pch : pch.default-cpp-pch-generator ;
 
-type.set-generated-target-suffix PCH : <toolset>darwin : gch ;
+type.set-generated-target-suffix PCH : <toolset>clang-darwin : gch ;
 
-toolset.inherit-rules darwin : gcc : localize ;
-toolset.inherit-flags darwin : gcc     
+toolset.inherit-rules clang-darwin : clang-unix : localize ;
+toolset.inherit-flags clang-darwin : clang-unix     
   :  <runtime-link>static
      <architecture>arm/<address-model>32
      <architecture>arm/<address-model>64
@@ -90,7 +93,7 @@
     local bin ;
     
     # - The configured compile driver command.
-    local command = [ common.get-invocation-command darwin : g++ : $(command) ] ;
+    local command = [ common.get-invocation-command clang-darwin : clang++ : $(command) ] ;
     
     # The version as reported by the compiler
     local real-version ;
@@ -126,24 +129,13 @@
     
     # - Define the condition for this toolset instance.
     local condition =
-        [ common.check-init-parameters darwin $(requirement) : version $(version) ] ;
+        [ common.check-init-parameters clang-darwin $(requirement) : version $(version) ] ;
     
     # - Set the toolset generic common options.
-    common.handle-options darwin : $(condition) : $(command) : $(options) ;
+    common.handle-options clang-darwin : $(condition) : $(command) : $(options) ;
     
-    # - GCC 4.0 and higher in Darwin does not have -fcoalesce-templates.
-    if $(real-version) < "4.0.0"
-    {
-        flags darwin.compile.c++ OPTIONS $(condition) : -fcoalesce-templates ;
-    }
-    # - GCC 4.2 and higher in Darwin does not have -Wno-long-double.
-    if $(real-version) < "4.2.0"
-    {
-        flags darwin.compile OPTIONS $(condition) : -Wno-long-double ;
-    }
-
-    # - Set the link flags common with the GCC toolset.
-    gcc.init-link-flags darwin darwin $(condition) ;
+    # - Set the link flags common with the clang-unix toolset.
+    clang-unix.init-link-flags clang-darwin darwin $(condition) ;
 
     # - The symbol strip program.
     local strip ;
@@ -151,13 +143,13 @@
     {
         # 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
+        flags clang-darwin.link.dll OPTIONS
             $(condition)/<main-target-type>LIB/<link>shared/<address-model>32/<strip>on : -Wl,-x ;
-        flags darwin.link.dll OPTIONS
+        flags clang-darwin.link.dll OPTIONS
             $(condition)/<main-target-type>LIB/<link>shared/<address-model>/<strip>on : -Wl,-x ;
-        flags darwin.link OPTIONS
+        flags clang-darwin.link OPTIONS
             $(condition)/<main-target-type>EXE/<address-model>32/<strip>on : -s ;
-        flags darwin.link OPTIONS
+        flags clang-darwin.link OPTIONS
             $(condition)/<main-target-type>EXE/<address-model>/<strip>on : -s ;
     }
     else
@@ -165,11 +157,11 @@
         # 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 : "" ;
+        flags clang-darwin.link NEED_STRIP $(condition)/<strip>on : "" ;
         strip =
-            [ common.get-invocation-command darwin
+            [ common.get-invocation-command clang-darwin
                 : strip : [ feature.get-values <striper> : $(options) ] : $(bin) : search-path ] ;
-        flags darwin.link .STRIP $(condition) : $(strip[1]) ;
+        flags clang-darwin.link .STRIP $(condition) : $(strip[1]) ;
         if $(.debug-configuration)
         {
             ECHO notice: using strip for $(condition) at $(strip[1]) ;
@@ -179,9 +171,9 @@
     # - The archive builder (libtool is the default as creating
     #   archives in darwin is complicated.
     local archiver =
-        [ common.get-invocation-command darwin
+        [ common.get-invocation-command clang-darwin
             : libtool : [ feature.get-values <archiver> : $(options) ] : $(bin) : search-path ] ;
-    flags darwin.archive .LIBTOOL $(condition) : $(archiver[1]) ;
+    flags clang-darwin.archive .LIBTOOL $(condition) : $(archiver[1]) ;
     if $(.debug-configuration)
     {
         ECHO notice: using archiver for $(condition) at $(archiver[1]) ;
@@ -243,9 +235,9 @@
         
         # Set the flags the version needs to compile with, first
         # generic options.
-        flags darwin.compile OPTIONS $(condition)/<macosx-version>$(version-feature)
+        flags clang-darwin.compile OPTIONS $(condition)/<macosx-version>$(version-feature)
             : -isysroot $(sdk) ;
-        flags darwin.link OPTIONS $(condition)/<macosx-version>$(version-feature)
+        flags clang-darwin.link OPTIONS $(condition)/<macosx-version>$(version-feature)
             : -isysroot $(sdk) ;
         
         # Then device variation options.
@@ -253,17 +245,17 @@
         {
             case iphone* :
             {
-                flags darwin.compile OPTIONS <macosx-version-min>$(version-feature)
+                flags clang-darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                     : -miphoneos-version-min=$(version[2-]:J=.) ;
-                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
+                flags clang-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)
+                flags clang-darwin.compile OPTIONS <macosx-version-min>$(version-feature)
                     : -miphoneos-version-min=$(version[2-]:J=.) ;
-                flags darwin.link OPTIONS <macosx-version-min>$(version-feature)
+                flags clang-darwin.link OPTIONS <macosx-version-min>$(version-feature)
                     : -miphoneos-version-min=$(version[2-]:J=.) ;
             }
         }
@@ -330,13 +322,13 @@
 }
 
 # Generic options.
-flags darwin.compile OPTIONS <flags> ;
+flags clang-darwin.compile OPTIONS <flags> ;
 
-# The following adds objective-c support to darwin.
+# The following adds objective-c support to clang-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 ;
+generators.register-c-compiler clang-darwin.compile.m : OBJECTIVE_C : OBJ : <toolset>clang-darwin ;
+generators.register-c-compiler clang-darwin.compile.mm : OBJECTIVE_CPP : OBJ : <toolset>clang-darwin ;
 
 rule setup-address-model ( targets * : sources * : properties * )
 {
@@ -344,8 +336,8 @@
     local arch = [ $(ps).get <architecture> ] ;
     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 clang-unix-version = [ $(ps).get <toolset-clang-darwin:version> ] ;
+    clang-unix-version = $(.real-version.$(clang-unix-version)) ;
     local options ;
     
     local support-ppc64 = 1 ;
@@ -363,8 +355,8 @@
         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
+            # - clang-unix 4.2 will give a compiler errir if ppc64 compilation is requested
+            # - clang-unix 4.0 will compile fine, somehow, but then fail at link time
             support-ppc64 = ;
         }
     }
@@ -432,18 +424,18 @@
 
 rule setup-threading ( targets * : sources * : properties * )
 {
-    gcc.setup-threading $(targets) : $(sources) : $(properties) ;
+    clang-unix.setup-threading $(targets) : $(sources) : $(properties) ;
 }
 
 rule setup-fpic ( targets * : sources * : properties * )
 {
-    gcc.setup-fpic $(targets) : $(sources) : $(properties) ;
+    clang-unix.setup-fpic $(targets) : $(sources) : $(properties) ;
 }
 
 rule compile.m ( targets * : sources * : properties * )
 {
     LANG on $(<) = "-x objective-c" ;
-    gcc.setup-fpic $(targets) : $(sources) : $(properties) ;
+    clang-unix.setup-fpic $(targets) : $(sources) : $(properties) ;
     setup-address-model $(targets) : $(sources) : $(properties) ;
 }
 
@@ -455,7 +447,7 @@
 rule compile.mm  ( targets * : sources * : properties * )
 {
     LANG on $(<) = "-x objective-c++" ;
-    gcc.setup-fpic $(targets) : $(sources) : $(properties) ;
+    clang-unix.setup-fpic $(targets) : $(sources) : $(properties) ;
     setup-address-model $(targets) : $(sources) : $(properties) ;
 }
 
@@ -465,28 +457,28 @@
 }
 
 # Set the max header padding to allow renaming of libs for installation.
-flags darwin.link.dll OPTIONS : -headerpad_max_install_names ;
+flags clang-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
+flags clang-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 ;
+flags clang-darwin.link OPTIONS <optimization>speed : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;
+flags clang-darwin.link OPTIONS <optimization>space : -Wl,-dead_strip -no_dead_strip_inits_and_terms ;
 
 # Dynamic/shared linking.
-flags darwin.compile OPTIONS <link>shared : -dynamic ;
+flags clang-darwin.compile OPTIONS <link>shared : -dynamic ;
 
 # Misc options.
-flags darwin.compile OPTIONS : -no-cpp-precomp -gdwarf-2 ;
+flags clang-darwin.compile OPTIONS : -gdwarf-2 ;
 
 # Add the framework names to use.
-flags darwin.link FRAMEWORK <framework> ;
+flags clang-darwin.link FRAMEWORK <framework> ;
 
 # 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 ;
+#~ flags clang-darwin.link.dll OPTIONS : -Wl,-v ;
 
 _ = " " ;
 

Copied: trunk/tools/build/v2/tools/clang-unix.jam (from r61372, /trunk/tools/build/v2/tools/gcc.jam)
==============================================================================
--- /trunk/tools/build/v2/tools/gcc.jam	(original)
+++ trunk/tools/build/v2/tools/clang-unix.jam	2010-04-18 15:43:40 EDT (Sun, 18 Apr 2010)
@@ -25,7 +25,6 @@
 import regex ;
 import set ;
 import unix ;
-import fortran ;
 
 
 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
@@ -34,35 +33,35 @@
 }
 
 
-feature.extend toolset : gcc ;
-# feature.subfeature toolset gcc : flavor : : optional ;
+feature.extend toolset : clang-unix ;
+# feature.subfeature toolset clang : flavor : : optional ;
 
-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 ;
-
-# Make gcc toolset object files use the "o" suffix on all platforms.
-type.set-generated-target-suffix OBJ : <toolset>gcc : o ;
-type.set-generated-target-suffix OBJ : <toolset>gcc <target-os>windows : o ;
-type.set-generated-target-suffix OBJ : <toolset>gcc <target-os>cygwin : o ;
+toolset.inherit-generators clang-unix : unix : unix.link unix.link.dll ;
+toolset.inherit-flags clang-unix : unix ;
+toolset.inherit-rules clang-unix : unix ;
+
+generators.override clang-unix.prebuilt : builtin.prebuilt ;
+generators.override clang-unix.searched-lib-generator : searched-lib-generator ;
+
+# Make clang-unix toolset object files use the "o" suffix on all platforms.
+type.set-generated-target-suffix OBJ : <toolset>clang-unix : o ;
+type.set-generated-target-suffix OBJ : <toolset>clang-unix <target-os>windows : o ;
+type.set-generated-target-suffix OBJ : <toolset>clang-unix <target-os>cygwin : o ;
 
-# Initializes the gcc toolset for the given version. If necessary, command may
+# Initializes the clang-unix 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 specified as
 # <option-name>option-value. Valid option names are: cxxflags, linkflags and
 # linker-type. Accepted linker-type values are aix, darwin, gnu, hpux, osf or
 # sun and the default value will be selected based on the current OS.
 # Example:
-#   using gcc : 3.4 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;
+#   using clang-unix : 1.5 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;
 #
 rule init ( version ? : command * : options * )
 {
-    # Information about the gcc command...
+    # Information about the clang command...
     #   The command.
-    local command = [ common.get-invocation-command gcc : g++ : $(command) ] ;
+    local command = [ common.get-invocation-command clang-unix : clang++ : $(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.
@@ -94,20 +93,20 @@
     local condition ;
     if $(flavor)
     {
-        condition = [ common.check-init-parameters gcc
+        condition = [ common.check-init-parameters clang-unix
             : version $(version)
             : flavor $(flavor)
             ] ;
     }
     else
     {
-        condition = [ common.check-init-parameters gcc
+        condition = [ common.check-init-parameters clang-unix
             : version $(version)
             ] ;
-        condition = $(condition) ;  #/<toolset-gcc:flavor> ;
+        condition = $(condition) ;  #/<toolset-clang-unix:flavor> ;
     }
 
-    common.handle-options gcc : $(condition) : $(command) : $(options) ;
+    common.handle-options clang-unix : $(condition) : $(command) : $(options) ;
 
     local linker = [ feature.get-values <linker-type> : $(options) ] ;
     # The logic below should actually be keyed on <target-os>
@@ -134,10 +133,10 @@
             linker = gnu ;
         }
     }
-    init-link-flags gcc $(linker) $(condition) ;
+    init-link-flags clang-unix $(linker) $(condition) ;
 
 
-    # If gcc is installed in non-standard location, we'd need to add
+    # If clang 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)
@@ -149,12 +148,12 @@
         local lib_path = $(root)/bin $(root)/lib $(root)/lib32 $(root)/lib64 ;
         if $(.debug-configuration)
         {
-            ECHO notice: using gcc libraries :: $(condition) :: $(lib_path) ;
+            ECHO notice: using clang libraries :: $(condition) :: $(lib_path) ;
         }
-        toolset.flags gcc.link RUN_PATH $(condition) : $(lib_path) ;
+        toolset.flags clang-unix.link RUN_PATH $(condition) : $(lib_path) ;
     }
 
-    # If it's not a system gcc install we should adjust the various programs as
+    # If it's not a system clang 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.
     
@@ -162,33 +161,33 @@
 " ;
 
     # - The archive builder.
-    local archiver = [ common.get-invocation-command gcc
+    local archiver = [ common.get-invocation-command clang-unix
             : [ NORMALIZE_PATH [ MATCH "(.*)[$(nl)]+" : [ SHELL "$(command-string) -print-prog-name=ar" ] ] ]
             : [ feature.get-values <archiver> : $(options) ] 
             : $(bin) 
             : search-path ] ;
-    toolset.flags gcc.archive .AR $(condition) : $(archiver[1]) ;
+    toolset.flags clang-unix.archive .AR $(condition) : $(archiver[1]) ;
     if $(.debug-configuration)
     {
-        ECHO notice: using gcc archiver :: $(condition) :: $(archiver[1]) ;
+        ECHO notice: using clang-unix archiver :: $(condition) :: $(archiver[1]) ;
     }
 
     # - Ranlib
-    local ranlib = [ common.get-invocation-command gcc
+    local ranlib = [ common.get-invocation-command clang-unix
             : [ NORMALIZE_PATH [ MATCH "(.*)[$(nl)]+" : [ SHELL "$(command-string) -print-prog-name=ranlib" ] ] ]
             : [ feature.get-values <ranlib> : $(options) ] 
             : $(bin) 
             : search-path ] ;
-    toolset.flags gcc.archive .RANLIB $(condition) : $(ranlib[1]) ;
+    toolset.flags clang-unix.archive .RANLIB $(condition) : $(ranlib[1]) ;
     if $(.debug-configuration)
     {
-        ECHO notice: using gcc ranlib :: $(condition) :: $(ranlib[1]) ;
+        ECHO notice: using clang-unix ranlib :: $(condition) :: $(ranlib[1]) ;
     }
 
 
     # - The resource compiler.
     local rc =
-        [ common.get-invocation-command-nodefault gcc
+        [ common.get-invocation-command-nodefault clang-unix
             : windres : [ feature.get-values <rc> : $(options) ] : $(bin) : search-path ] ;
     local rc-type =
         [ feature.get-values <rc-type> : $(options) ] ;
@@ -199,7 +198,7 @@
         # 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 = [ common.get-invocation-command clang-unix : as : : $(bin) : search-path ] ;
         rc-type = null ;
     }
     rc.configure $(rc) : $(condition) : <rc-type>$(rc-type) ;
@@ -212,23 +211,22 @@
     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 ;
-generators.register-fortran-compiler gcc.compile.fortran : FORTRAN FORTRAN90 : OBJ : <toolset>gcc ;
+generators.register-c-compiler clang-unix.compile.c++ : CPP : OBJ : <toolset>clang-unix ;
+generators.register-c-compiler clang-unix.compile.c   : C   : OBJ : <toolset>clang-unix ;
+generators.register-c-compiler clang-unix.compile.asm : ASM : OBJ : <toolset>clang-unix ;
 
 # 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
+# logic in clang-unix-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 ;
+type.set-generated-target-suffix PCH : <toolset>clang-unix : gch ;
 
-# GCC-specific pch generator.
-class gcc-pch-generator : pch-generator
+# clang-specific pch generator.
+class clang-unix-pch-generator : pch-generator
 {
     import project ;
     import property-set ;
@@ -280,32 +278,32 @@
 # 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 ] ;
+generators.register [ new clang-unix-pch-generator clang-unix.compile.c.pch   : H :   C_PCH : <pch>on <toolset>clang-unix ] ;
+generators.register [ new clang-unix-pch-generator clang-unix.compile.c++.pch : H : CPP_PCH : <pch>on <toolset>clang-unix ] ;
 
 # 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 ;
+generators.override clang-unix.compile.c.pch   : pch.default-c-pch-generator   ;
+generators.override clang-unix.compile.c++.pch : pch.default-cpp-pch-generator ;
 
-toolset.flags gcc.compile PCH_FILE <pch>on : <pch-file> ;
+toolset.flags clang-unix.compile PCH_FILE <pch>on : <pch-file> ;
 
 # Declare flags and action for compilation.
-toolset.flags gcc.compile OPTIONS <optimization>off   : -O0 ;
-toolset.flags gcc.compile OPTIONS <optimization>speed : -O3 ;
-toolset.flags gcc.compile OPTIONS <optimization>space : -Os ;
-
-toolset.flags gcc.compile OPTIONS <inlining>off  : -fno-inline ;
-toolset.flags gcc.compile OPTIONS <inlining>on   : -Wno-inline ;
-toolset.flags gcc.compile OPTIONS <inlining>full : -finline-functions -Wno-inline ;
-
-toolset.flags gcc.compile OPTIONS <warnings>off : -w ;
-toolset.flags gcc.compile OPTIONS <warnings>on  : -Wall ;
-toolset.flags gcc.compile OPTIONS <warnings>all : -Wall -pedantic ;
-toolset.flags gcc.compile OPTIONS <warnings-as-errors>on : -Werror ;
-
-toolset.flags gcc.compile OPTIONS <debug-symbols>on : -g ;
-toolset.flags gcc.compile OPTIONS <profiling>on : -pg ;
-toolset.flags gcc.compile OPTIONS <rtti>off : -fno-rtti ;
+toolset.flags clang-unix.compile OPTIONS <optimization>off   : -O0 ;
+toolset.flags clang-unix.compile OPTIONS <optimization>speed : -O3 ;
+toolset.flags clang-unix.compile OPTIONS <optimization>space : -Os ;
+
+toolset.flags clang-unix.compile OPTIONS <inlining>off  : -fno-inline ;
+toolset.flags clang-unix.compile OPTIONS <inlining>on   : -Wno-inline ;
+toolset.flags clang-unix.compile OPTIONS <inlining>full : -finline-functions -Wno-inline ;
+
+toolset.flags clang-unix.compile OPTIONS <warnings>off : -w ;
+toolset.flags clang-unix.compile OPTIONS <warnings>on  : -Wall ;
+toolset.flags clang-unix.compile OPTIONS <warnings>all : -Wall -pedantic ;
+toolset.flags clang-unix.compile OPTIONS <warnings-as-errors>on : -Werror ;
+
+toolset.flags clang-unix.compile OPTIONS <debug-symbols>on : -g ;
+toolset.flags clang-unix.compile OPTIONS <profiling>on : -pg ;
+toolset.flags clang-unix.compile OPTIONS <rtti>off : -fno-rtti ;
 
 rule setup-fpic ( targets * : sources * : properties * )
 {
@@ -393,12 +391,11 @@
     SONAME_OPTION = +h ;
 }
 
-toolset.flags gcc.compile USER_OPTIONS <cflags> ;
-toolset.flags gcc.compile.c++ USER_OPTIONS <cxxflags> ;
-toolset.flags gcc.compile DEFINES <define> ;
-toolset.flags gcc.compile INCLUDES <include> ;
-toolset.flags gcc.compile.c++ TEMPLATE_DEPTH <c++-template-depth> ;
-toolset.flags gcc.compile.fortran USER_OPTIONS <fflags> ;
+toolset.flags clang-unix.compile USER_OPTIONS <cflags> ;
+toolset.flags clang-unix.compile.c++ USER_OPTIONS <cxxflags> ;
+toolset.flags clang-unix.compile DEFINES <define> ;
+toolset.flags clang-unix.compile INCLUDES <include> ;
+toolset.flags clang-unix.compile.c++ TEMPLATE_DEPTH <c++-template-depth> ;
 
 rule compile.c++.pch ( targets * : sources * : properties * )
 {
@@ -460,7 +457,7 @@
     setup-fpic $(targets) : $(sources) : $(properties) ;
     setup-address-model $(targets) : $(sources) : $(properties) ;
     
-    # If we use the name g++ then default file suffix -> language mapping does
+    # If we use the name clang++ 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
@@ -470,13 +467,6 @@
     DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
 }
 
-rule compile.fortran ( targets * : sources * : properties * )
-{
-    setup-threading $(targets) : $(sources) : $(properties) ;
-    setup-fpic $(targets) : $(sources) : $(properties) ;
-    setup-address-model $(targets) : $(sources) : $(properties) ;
-}
-
 actions compile.c++ bind PCH_FILE
 {
     "$(CONFIG_COMMAND)" $(LANG) -ftemplate-depth-$(TEMPLATE_DEPTH) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<:W)" "$(>:W)"
@@ -487,11 +477,6 @@
     "$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
 }
 
-actions compile.fortran
-{
-  "$(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" ;
@@ -504,8 +489,8 @@
 
 # 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
+# clang/libc.
+class clang-unix-linking-generator : unix-linking-generator
 {
     rule run ( project name ? : property-set : sources + )
     {
@@ -526,7 +511,7 @@
             if <link>shared in $(properties)
             {
                 reason =
-                    "On gcc, DLL can't be build with '<runtime-link>static'." ;
+                    "On clang, DLL can't be build with '<runtime-link>static'." ;
             }
             else if [ type.is-derived $(self.target-types[1]) EXE ]
             {
@@ -536,7 +521,7 @@
                     if $(type) &&  [ type.is-derived $(type) SHARED_LIB ]
                     {
                         reason =
-                            "On gcc, using DLLS together with the"
+                            "On clang, using DLLS together with the"
                             "<runtime-link>static options is not possible " ;
                     }
                 }
@@ -565,68 +550,68 @@
 # selected when target-os=windows.
 
 local g ;
-g = [ new gcc-linking-generator gcc.mingw.link
+g = [ new clang-unix-linking-generator clang-unix.mingw.link
       : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
       : EXE
-      : <toolset>gcc <target-os>windows ] ;
-$(g).set-rule-name gcc.link ;
+      : <toolset>clang-unix <target-os>windows ] ;
+$(g).set-rule-name clang-unix.link ;
 generators.register $(g) ;
 
-g = [ new gcc-linking-generator gcc.mingw.link.dll
+g = [ new clang-unix-linking-generator clang-unix.mingw.link.dll
       : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
       : IMPORT_LIB SHARED_LIB
-      : <toolset>gcc <target-os>windows ] ;
-$(g).set-rule-name gcc.link.dll ;
+      : <toolset>clang-unix <target-os>windows ] ;
+$(g).set-rule-name clang-unix.link.dll ;
 generators.register $(g) ;
 
 generators.register
-  [ new gcc-linking-generator gcc.link
+  [ new clang-unix-linking-generator clang-unix.link
       : LIB OBJ
       : EXE
-      : <toolset>gcc ] ;
+      : <toolset>clang-unix ] ;
 generators.register
-  [ new gcc-linking-generator gcc.link.dll
+  [ new clang-unix-linking-generator clang-unix.link.dll
       : LIB OBJ
       : SHARED_LIB
-      : <toolset>gcc ] ;
+      : <toolset>clang-unix ] ;
 
-generators.override gcc.mingw.link : gcc.link ;
-generators.override gcc.mingw.link.dll : gcc.link.dll ;
+generators.override clang-unix.mingw.link : clang-unix.link ;
+generators.override clang-unix.mingw.link.dll : clang-unix.link.dll ;
 
 # Cygwin is similar to msvc and mingw in that it uses import libraries.
 # While in simple cases, it can directly link to a shared library,
 # it is believed to be slower, and not always possible. Define cygwin-specific
 # generators here.
 
-g = [ new gcc-linking-generator gcc.cygwin.link
+g = [ new clang-unix-linking-generator clang-unix.cygwin.link
       : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
       : EXE
-      : <toolset>gcc <target-os>cygwin ] ;
-$(g).set-rule-name gcc.link ;
+      : <toolset>clang-unix <target-os>cygwin ] ;
+$(g).set-rule-name clang-unix.link ;
 generators.register $(g) ;
 
-g = [ new gcc-linking-generator gcc.cygwin.link.dll
+g = [ new clang-unix-linking-generator clang-unix.cygwin.link.dll
       : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB
       : IMPORT_LIB SHARED_LIB
-      : <toolset>gcc <target-os>cygwin ] ;
-$(g).set-rule-name gcc.link.dll ;
+      : <toolset>clang-unix <target-os>cygwin ] ;
+$(g).set-rule-name clang-unix.link.dll ;
 generators.register $(g) ;
 
-generators.override gcc.cygwin.link : gcc.link ;
-generators.override gcc.cygwin.link.dll : gcc.link.dll ;
+generators.override clang-unix.cygwin.link : clang-unix.link ;
+generators.override clang-unix.cygwin.link.dll : clang-unix.link.dll ;
 
 # Declare flags for linking.
 # First, the common flags.
-toolset.flags gcc.link OPTIONS <debug-symbols>on : -g ;
-toolset.flags gcc.link OPTIONS <profiling>on : -pg ;
-toolset.flags gcc.link USER_OPTIONS <linkflags> ;
-toolset.flags gcc.link LINKPATH <library-path> ;
-toolset.flags gcc.link FINDLIBS-ST <find-static-library> ;
-toolset.flags gcc.link FINDLIBS-SA <find-shared-library> ;
-toolset.flags gcc.link LIBRARIES <library-file> ;
+toolset.flags clang-unix.link OPTIONS <debug-symbols>on : -g ;
+toolset.flags clang-unix.link OPTIONS <profiling>on : -pg ;
+toolset.flags clang-unix.link USER_OPTIONS <linkflags> ;
+toolset.flags clang-unix.link LINKPATH <library-path> ;
+toolset.flags clang-unix.link FINDLIBS-ST <find-static-library> ;
+toolset.flags clang-unix.link FINDLIBS-SA <find-shared-library> ;
+toolset.flags clang-unix.link LIBRARIES <library-file> ;
 
-toolset.flags gcc.link.dll .IMPLIB-COMMAND <target-os>windows : "-Wl,--out-implib," ;
-toolset.flags gcc.link.dll .IMPLIB-COMMAND <target-os>cygwin : "-Wl,--out-implib," ;
+toolset.flags clang-unix.link.dll .IMPLIB-COMMAND <target-os>windows : "-Wl,--out-implib," ;
+toolset.flags clang-unix.link.dll .IMPLIB-COMMAND <target-os>cygwin : "-Wl,--out-implib," ;
 
 # 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
@@ -634,7 +619,7 @@
 # cannot be specified.
 if [ os.name ] != HPUX
 {
-    toolset.flags gcc.link OPTIONS <runtime-link>static : -static ;
+    toolset.flags clang-unix.link OPTIONS <runtime-link>static : -static ;
 }
 
 # Now, the vendor specific flags.
@@ -685,7 +670,7 @@
         {
         # 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 the gcc toolset, but does not
+        # option-compatible with and inherits from the clang toolset, but does not
         # support -s.
         toolset.flags $(toolset).link OPTIONS     $(condition)/<strip>on          : -Wl,--strip-all   : unchecked ;
         toolset.flags $(toolset).link RPATH       $(condition)                    : <dll-path>        : unchecked ;
@@ -815,9 +800,9 @@
     setup-address-model $(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
+    # parallel is just slower. For now, serialize only clang links, it might be a
     # good idea to serialize all links.
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
+    JAM_SEMAPHORE on $(targets) = <s>clang-unix-link-semaphore ;
     quote-rpath $(targets) ;
 }
 
@@ -827,14 +812,14 @@
 
 }
 
-# Default value. Mostly for the sake of intel-linux that inherits from gcc, but
+# Default value. Mostly for the sake of intel-linux that inherits from clang, but
 # does not have 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 ;
 .RANLIB = ranlib ;
 
-toolset.flags gcc.archive AROPTIONS <archiveflags> ;
+toolset.flags clang-unix.archive AROPTIONS <archiveflags> ;
 
 rule archive ( targets * : sources * : properties * )
 {
@@ -881,7 +866,7 @@
     setup-threading $(targets) : $(sources) : $(properties) ;
     setup-address-model $(targets) : $(sources) : $(properties) ;
     SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
+    JAM_SEMAPHORE on $(targets) = <s>clang-unix-link-semaphore ;
     quote-rpath $(targets) ;
 }
 
@@ -926,7 +911,7 @@
             }
             case sgi :
             {
-                # gcc on IRIX does not support multi-threading so do not set anything
+                # clang on IRIX does not support multi-threading so do not set anything
                 # here.
             }
             case darwin :
@@ -968,90 +953,38 @@
 # Set architecture/instruction-set options.
 #
 # x86 and compatible
-# The 'native' option appeared in gcc 4.2 so we cannot safely use it
-# as default. Use conservative i386 instead.
-cpu-flags gcc OPTIONS : x86 : native : -march=native ;
-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 : core2 : -march=core2 ;
-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 clang-unix OPTIONS : x86 : native : -march=native : default ;
+cpu-flags clang-unix OPTIONS : x86 : i386 : -march=i386 ;
+cpu-flags clang-unix OPTIONS : x86 : i486 : -march=i486 ;
+cpu-flags clang-unix OPTIONS : x86 : i586 : -march=i586 ;
+cpu-flags clang-unix OPTIONS : x86 : i686 : -march=i686 ;
+cpu-flags clang-unix OPTIONS : x86 : pentium : -march=pentium ;
+cpu-flags clang-unix OPTIONS : x86 : pentium-mmx : -march=pentium-mmx ;
+cpu-flags clang-unix OPTIONS : x86 : pentiumpro : -march=pentiumpro ;
+cpu-flags clang-unix OPTIONS : x86 : pentium2 : -march=pentium2 ;
+cpu-flags clang-unix OPTIONS : x86 : pentium3 : -march=pentium3 ;
+cpu-flags clang-unix OPTIONS : x86 : pentium3m : -march=pentium3m ;
+cpu-flags clang-unix OPTIONS : x86 : pentium-m : -march=pentium-m ;
+cpu-flags clang-unix OPTIONS : x86 : pentium4 : -march=pentium4 ;
+cpu-flags clang-unix OPTIONS : x86 : pentium4m : -march=pentium4m ;
+cpu-flags clang-unix OPTIONS : x86 : prescott : -march=prescott ;
+cpu-flags clang-unix OPTIONS : x86 : nocona : -march=nocona ;
+cpu-flags clang-unix OPTIONS : x86 : core2 : -march=core2 ;
+cpu-flags clang-unix OPTIONS : x86 : k6 : -march=k6 ;
+cpu-flags clang-unix OPTIONS : x86 : k6-2 : -march=k6-2 ;
+cpu-flags clang-unix OPTIONS : x86 : k6-3 : -march=k6-3 ;
+cpu-flags clang-unix OPTIONS : x86 : athlon : -march=athlon ;
+cpu-flags clang-unix OPTIONS : x86 : athlon-tbird : -march=athlon-tbird ;
+cpu-flags clang-unix OPTIONS : x86 : athlon-4 : -march=athlon-4 ;
+cpu-flags clang-unix OPTIONS : x86 : athlon-xp : -march=athlon-xp ;
+cpu-flags clang-unix 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
-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
-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
-toolset.flags gcc AROPTIONS <address-model>64/<target-os>aix : "-X 64" ;
+cpu-flags clang-unix OPTIONS : x86 : k8 : -march=k8 ;
+cpu-flags clang-unix OPTIONS : x86 : opteron : -march=opteron ;
+cpu-flags clang-unix OPTIONS : x86 : athlon64 : -march=athlon64 ;
+cpu-flags clang-unix OPTIONS : x86 : athlon-fx : -march=athlon-fx ;
+cpu-flags clang-unix OPTIONS : x86 : winchip-c6 : -march=winchip-c6 ;
+cpu-flags clang-unix OPTIONS : x86 : winchip2 : -march=winchip2 ;
+cpu-flags clang-unix OPTIONS : x86 : c3 : -march=c3 ;
+cpu-flags clang-unix OPTIONS : x86 : c3-2 : -march=c3-2 ;
+

Added: trunk/tools/build/v2/tools/clang.jam
==============================================================================
--- (empty file)
+++ trunk/tools/build/v2/tools/clang.jam	2010-04-18 15:43:40 EDT (Sun, 18 Apr 2010)
@@ -0,0 +1,27 @@
+# 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)
+
+# This is a generic 'clang' toolset. Depending on the current system, it
+# forwards either to 'clang-unix' or 'clang-darwin' modules.
+
+import feature ;
+import os ;
+import toolset ;
+
+feature.extend toolset : clang ;
+feature.subfeature toolset clang : platform : : propagated link-incompatible ;
+
+rule init ( * : * )
+{
+    if [ os.name ] = MACOSX
+    {
+        toolset.using clang-darwin : 
+          $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
+    }
+    else
+    {
+        toolset.using clang-unix : 
+          $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
+    }
+}

Modified: trunk/tools/build/v2/tools/common.jam
==============================================================================
--- trunk/tools/build/v2/tools/common.jam	(original)
+++ trunk/tools/build/v2/tools/common.jam	2010-04-18 15:43:40 EDT (Sun, 18 Apr 2010)
@@ -825,6 +825,8 @@
     switch [ $(property-set).get <toolset> ]
     {
         case borland* : tag += bcb ;
+        case clang-unix* : tag += gcc ;
+        case clang-darwin* : tag += xgcc ;
         case como* : tag += como ;
         case cw : tag += cw ;
         case darwin* : tag += xgcc ;