Don't defer to the GCC driver for linking arm-baremetal

[jroelofs]

pass through linker flags, and remove my own paths from the test.

[joerg]

While I fully agree that the current fallback-to-GCC behavior is far from helpful, I'm not sure how much sense providing linker support for bare-metal makes. I would expect this to changes wildly depending on the specific environment.

[jroelofs]

I would expect this to changes wildly depending on the specific environment.

My assertion is that our default "specific environment" ought to cater to using llvm's own tools... at least until someone comes along and says they actually want -fuse-ld=gcc, or whatever.

[compnerd]

cmake/caches/BaremetalARM.cmake

2

Please rename this file to BareMetalARMv6.cmake. (I'm interested in the suffix primarily).

lib/Driver/ToolChains/BareMetal.cpp

69

Why not just the standard arm directory?

75

This seems wrong. The libc++ headers should *not* be in the resource dir. This should be based off of the sysroot IMO.

108–109

I think that this is a bit extreme. We already have -stdlib=libc++ and -stdlib=libstdc++. Why not just honor that?

lib/Driver/ToolChains/BareMetal.h

43

I think that this really should be ld still, as that is the canonical name for the linker.

58

Unnecessary?

68

Update this accordingly.

[jroelofs]

cmake/caches/BaremetalARM.cmake

2

My plan is to eventually add multilibs to this configuration, so while that makes sense short term, I don't think it makes sense long term.

With that in mind, do you still want me to rename it?

lib/Driver/ToolChains/BareMetal.cpp

69

There are a few differences between the stuff in the existing ones, and what is needed on baremetal. For example __enable_execute_stack, emutls, as well as anything else that assumes existence of pthreads support shouldn't be there.

75

Oh, excellent point. I was just making that same argument a few weeks ago.

108–109

I wasn't going for "support every possible thing out of the tin", instead preferring incremental development :)

[jroelofs]

lib/Driver/ToolChains/BareMetal.h

43

You mean lld?

$ lld
lld is a generic driver.
Invoke ld.lld (Unix), ld (macOS) or lld-link (Windows) instead.

Or are you saying: "make binutils ld the default, not llvm's lld"?

[jroelofs]

lib/Driver/ToolChains/BareMetal.cpp

108–109

Added support for -stdlib=.

I made the assumption that -stdlib=libstdc++ implies the user wants libsupc++ as their ABI library, though someone may want libstdc++ + libc++abi, or other combinations. If that's the case, we can add -abilib=, and likewise -unwinder=... but let's save that for another patch, on another day.

[compnerd]

cmake/caches/BaremetalARM.cmake

2

I think it makes sense longer term still. ARMv6 vs ARMv7. Even if you do multilib, that wouldnt take care of that right?

lib/Driver/ToolChains/BareMetal.cpp

69

Well, I think that "baremetal" here is a bad idea. How about using the android approach? Use clang_rt.builtins-arm-baremetal.a ?

108–109

Yeah, switching between libc++/libc++abi and libstdc++/libsupc++ sounds reasonable. Anything beyond that is something which doesnt work well within the driver anyways. I should polish off my -unwinder patch.

lib/Driver/ToolChains/BareMetal.h

43

Im saying use the name "ld". ld is a symlink on most linux distributions these days. ld -> ld.gold, ld.bfd, ld.lld

[jroelofs]

cmake/caches/BaremetalARM.cmake

2

It's not limited to just ARMv6m multilibs... imagine it had:

set(LLVM_BUILTIN_TARGETS "armv6m-none-eabi;armv7m-none-eabi" CACHE STRING "Builtin Targets")

Then naming the file BaremetalARMv6m.cmake will be inappropriately specific.

Granted, the way clangrt is built/used now isn't very conducive to multilibs that differ by more than just the arch, since the name currently has to be of the form: libclang_rt-builtins-${triple's subarch}.a, which for example doesn't allow for differentiating between:

v7m;@mthumb@march=armv7-m
v7m-PIC;@mthumb@march=armv7-m@fPIC

or

v7a-neon;@march=armv7-a@mfloat-abi=softfp@mfpu=neon
v7a-vfpv3-d16;@march=armv7-a@mfloat-abi=softfp@mfpu=vfpv3-d16

lib/Driver/ToolChains/BareMetal.cpp

69

Why? Given the way the cmake goop works in lib/runtimes + compiler-rt, the folder name there has to be the same as the CMAKE_SYSTEM_NAME. The alternative, I guess, is to call it 'generic', but I'm not convinced that's better than 'baremetal'.

lib/Driver/ToolChains/BareMetal.h

43

I don't think this makes sense. I don't care about "most linux distributions", but rather about putting together an LLVM baremetal distribution based as much as possible on LLVM components. If someone wants a different linker, they can use -fuse-ld= and/or -B.

Also, doesn't using a symlink named ld cause lld to behave like a mach-o linker? We really want the elf one here.

[ruiu]

lib/Driver/ToolChains/BareMetal.h

43

If you invoke lld as ld, it behaves as a Mach-O linker on macOS. On other OSes, it behaves as an ELF linker.

[compnerd]

lib/Driver/ToolChains/BareMetal.cpp

69

Because I can have a baremetal environment that uses a different architecture. How do you differentiate between the MIPS and ARM bare metal runtimes? The way that the compiler actually looks up the builtins is that it uses clang_rt.[component]-[arch][-variant]

lib/Driver/ToolChains/BareMetal.h

43

ld really is just the unix name for the linker. I think that at some point we are going to have to consider cross-linking with lld. Adding a -flavor <flavor> with -fuse-ld=lld makes sense I think.

[jroelofs]

lib/Driver/ToolChains/BareMetal.cpp

69

Yes, and that's still how they're being looked up (and built/installed), even in this patch:

lib/clang/[version]/lib/[cmake_system_name]/libclangrt.[component]-[arch][-variant].a

Having arch+variant in the name means they won't intersect, just as they don't for any other system. The only difference here is that baremetal doesn't really have a "system" per se, and it's not appropriate to use the darwin/linux/whatever ones, hence the 'baremetal' folder.

[jroelofs]

cmake/caches/BaremetalARM.cmake

11

hmm. not sure why these two aren't getting built.

[jroelofs]

fixed the v7m/v7em part of the build

[compnerd]

Looks generally pretty good. This is going to be a pretty cool addition!

lib/Driver/ToolChains/BareMetal.cpp

69

Ah. I see, I was visualizing the tree incorrectly. Using baremetal this way is fine by me.

111

Is this layout consistent between libc++ and libstdc++?

131–134

Use StringSwitch?

lib/Driver/ToolChains/BareMetal.h

40

Is the profiler support in compiler-rt sufficiently standalone to build it for baremetal?

[jroelofs]

implement feedback

[jroelofs]

lib/Driver/ToolChains/BareMetal.cpp

111

Damn, no it's not.

131–134

StringSwitch isn't great when you want to error out of the default case. That being said, this whole function is unnecessary: I can just defer to the base class' implementation, which does almost the same thing.

lib/Driver/ToolChains/BareMetal.h

40

IIRC, there was a test case that wanted this on for one of the arm-none-eabi triples. This is when my patches were against 4.0. After rebasing to trunk, I think that particular test is gone (split up into separate ones, I guess?).

I'll leave it off for now until someone confirms it is actually supported.

lib/Driver/ToolChains/Linux.cpp

379

Noticed that this was in the wrong place, and also, surprisingly, that it was incorrectly qualified.

[jroelofs]

Fix a cmake warning:

Platform/baremetal to use this system, please send your config file to [e-mail] so it can be added to cmake
Your CMakeCache.txt file was copied to CopyOfCMakeCache.txt. Please send that file to [e-mail].

Generic does what we want already, it just has a name that's not useful.

[jroelofs]

r303873

[mgorny]

This causes a test failure with non-standard CLANG_RESOURCE_DIR:

Command Output (stderr):
--
/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/baremetal.cpp:8:22: error: expected string not found in input
// CHECK-V6M-C-SAME: "-resource-dir" "[[PREFIX_DIR]]{{[/\\]+}}lib{{(64)?}}{{[/\\]+}}clang{{[/\\]+}}[[VERSION:[^"]*]]"
                     ^
<stdin>:5:128: note: scanning from here
 "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/clang" "-cc1" "-triple" "thumbv6m-none--eabi" "-emit-obj" "-mrelax-all" "-disable-free" "-disable-llvm-verifier" "-discard-value-names" "-main-file-name" "baremetal.cpp" "-mrelocation-model" "static" "-mthread-model" "single" "-mdisable-fp-elim" "-fmath-errno" "-no-integrated-as" "-mconstructor-aliases" "-nostdsysteminc" "-target-cpu" "cortex-m0" "-target-feature" "+soft-float-abi" "-target-feature" "+strict-align" "-target-abi" "aapcs" "-mfloat-abi" "soft" "-dwarf-column-info" "-debugger-tuning=gdb" "-resource-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0" "-isysroot" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include/c++/v1" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0/include" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include" "-fdeprecated-macro" "-fdebug-compilation-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/test/Driver" "-ferror-limit" "19" "-fmessage-length" "0" "-fallow-half-arguments-and-returns" "-fno-signed-char" "-fobjc-runtime=gcc" "-fcxx-exceptions" "-fexceptions" "-fdiagnostics-show-option" "-o" "/var/tmp/portage/sys-devel/clang-9999/temp/baremetal-6b1d37.o" "-x" "c++" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/baremetal.cpp"
                                                                                                                               ^
<stdin>:5:128: note: with variable "PREFIX_DIR" equal to "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/."
 "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/clang" "-cc1" "-triple" "thumbv6m-none--eabi" "-emit-obj" "-mrelax-all" "-disable-free" "-disable-llvm-verifier" "-discard-value-names" "-main-file-name" "baremetal.cpp" "-mrelocation-model" "static" "-mthread-model" "single" "-mdisable-fp-elim" "-fmath-errno" "-no-integrated-as" "-mconstructor-aliases" "-nostdsysteminc" "-target-cpu" "cortex-m0" "-target-feature" "+soft-float-abi" "-target-feature" "+strict-align" "-target-abi" "aapcs" "-mfloat-abi" "soft" "-dwarf-column-info" "-debugger-tuning=gdb" "-resource-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0" "-isysroot" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include/c++/v1" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0/include" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include" "-fdeprecated-macro" "-fdebug-compilation-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/test/Driver" "-ferror-limit" "19" "-fmessage-length" "0" "-fallow-half-arguments-and-returns" "-fno-signed-char" "-fobjc-runtime=gcc" "-fcxx-exceptions" "-fexceptions" "-fdiagnostics-show-option" "-o" "/var/tmp/portage/sys-devel/clang-9999/temp/baremetal-6b1d37.o" "-x" "c++" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/baremetal.cpp"
                                                                                                                               ^
<stdin>:5:588: note: possible intended match here
 "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/clang" "-cc1" "-triple" "thumbv6m-none--eabi" "-emit-obj" "-mrelax-all" "-disable-free" "-disable-llvm-verifier" "-discard-value-names" "-main-file-name" "baremetal.cpp" "-mrelocation-model" "static" "-mthread-model" "single" "-mdisable-fp-elim" "-fmath-errno" "-no-integrated-as" "-mconstructor-aliases" "-nostdsysteminc" "-target-cpu" "cortex-m0" "-target-feature" "+soft-float-abi" "-target-feature" "+strict-align" "-target-abi" "aapcs" "-mfloat-abi" "soft" "-dwarf-column-info" "-debugger-tuning=gdb" "-resource-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0" "-isysroot" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include/c++/v1" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/./bin/../../../../lib/clang/5.0.0/include" "-internal-isystem" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/Inputs/baremetal_arm/include" "-fdeprecated-macro" "-fdebug-compilation-dir" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999-abi_x86_32.x86/test/Driver" "-ferror-limit" "19" "-fmessage-length" "0" "-fallow-half-arguments-and-returns" "-fno-signed-char" "-fobjc-runtime=gcc" "-fcxx-exceptions" "-fexceptions" "-fdiagnostics-show-option" "-o" "/var/tmp/portage/sys-devel/clang-9999/temp/baremetal-6b1d37.o" "-x" "c++" "/var/tmp/portage/sys-devel/clang-9999/work/x/y/clang-9999/test/Driver/baremetal.cpp"

[jroelofs]

In D33259#772184, @mgorny wrote:

This causes a test failure with non-standard CLANG_RESOURCE_DIR:

https://reviews.llvm.org/D33877

(thanks for the patch)

cmake/caches/BaremetalARM.cmake

+set(LLVM_TARGETS_TO_BUILD ARM;X86 CACHE STRING "")
+
+# Builtins
+set(LLVM_BUILTIN_TARGETS "armv7m-none-eabi;armv6m-none-eabi;armv7em-none-eabi" CACHE STRING "Builtin Targets")
+
+set(BUILTINS_armv6m-none-eabi_CMAKE_SYSROOT ${BAREMETAL_ARMV6M_SYSROOT} CACHE STRING "armv6m-none-eabi Sysroot")
+set(BUILTINS_armv6m-none-eabi_CMAKE_SYSTEM_NAME Generic CACHE STRING "armv6m-none-eabi System Name")
+set(BUILTINS_armv6m-none-eabi_COMPILER_RT_BAREMETAL_BUILD ON CACHE BOOL "armv6m-none-eabi Baremetal build")
+set(BUILTINS_armv6m-none-eabi_COMPILER_RT_OS_DIR "baremetal" CACHE STRING "armv6m-none-eabi os dir")
+
+set(BUILTINS_armv7m-none-eabi_CMAKE_SYSROOT ${BAREMETAL_ARMV7M_SYSROOT} CACHE STRING "armv7m-none-eabi Sysroot")
+set(BUILTINS_armv7m-none-eabi_CMAKE_SYSTEM_NAME Generic CACHE STRING "armv7m-none-eabi System Name")
+set(BUILTINS_armv7m-none-eabi_COMPILER_RT_BAREMETAL_BUILD ON CACHE BOOL "armv7m-none-eabi Baremetal build")
+set(BUILTINS_armv7m-none-eabi_CMAKE_C_FLAGS "-mfpu=fp-armv8" CACHE STRING "armv7m-none-eabi C Flags")
+set(BUILTINS_armv7m-none-eabi_CMAKE_ASM_FLAGS "-mfpu=fp-armv8" CACHE STRING "armv7m-none-eabi ASM Flags")
+set(BUILTINS_armv7m-none-eabi_COMPILER_RT_OS_DIR "baremetal" CACHE STRING "armv7m-none-eabi os dir")
+
+set(BUILTINS_armv7em-none-eabi_CMAKE_SYSROOT ${BAREMETAL_ARMV7EM_SYSROOT} CACHE STRING "armv7em-none-eabi Sysroot")
+set(BUILTINS_armv7em-none-eabi_CMAKE_SYSTEM_NAME Generic CACHE STRING "armv7em-none-eabi System Name")
+set(BUILTINS_armv7em-none-eabi_COMPILER_RT_BAREMETAL_BUILD ON CACHE BOOL "armv7em-none-eabi Baremetal build")
+set(BUILTINS_armv7em-none-eabi_CMAKE_C_FLAGS "-mfpu=fp-armv8" CACHE STRING "armv7em-none-eabi C Flags")
+set(BUILTINS_armv7em-none-eabi_CMAKE_ASM_FLAGS "-mfpu=fp-armv8" CACHE STRING "armv7em-none-eabi ASM Flags")
+set(BUILTINS_armv7em-none-eabi_COMPILER_RT_OS_DIR "baremetal" CACHE STRING "armv7em-none-eabi os dir")
+
+set(LLVM_INSTALL_TOOLCHAIN_ONLY ON CACHE BOOL "")
+set(LLVM_TOOLCHAIN_TOOLS
+  llc
+  llvm-ar
+  llvm-cxxfilt
+  llvm-dwarfdump
+  llvm-dsymutil
+  llvm-nm
+  llvm-objdump
+  llvm-ranlib
+  llvm-readobj
+  llvm-size
+  llvm-symbolizer
+  opt
+  CACHE STRING "")
+
+set(LLVM_DISTRIBUTION_COMPONENTS
+  clang
+  lld
+  clang-headers
+  builtins-armv6m-none-eabi
+  builtins-armv7m-none-eabi
+  builtins-armv7em-none-eabi
+  runtimes
+  ${LLVM_TOOLCHAIN_TOOLS}
+  CACHE STRING "")

lib/Driver/CMakeLists.txt

add_clang_library(clangDriver
   ToolChains/Arch/Mips.cpp
   ToolChains/Arch/PPC.cpp
   ToolChains/Arch/Sparc.cpp
   ToolChains/Arch/SystemZ.cpp
   ToolChains/Arch/X86.cpp
   ToolChains/AMDGPU.cpp
   ToolChains/AVR.cpp
   ToolChains/Bitrig.cpp
+  ToolChains/BareMetal.cpp
   ToolChains/Clang.cpp
   ToolChains/CloudABI.cpp
   ToolChains/CommonArgs.cpp
   ToolChains/Contiki.cpp
   ToolChains/CrossWindows.cpp
   ToolChains/Cuda.cpp
   ToolChains/Darwin.cpp
   ToolChains/DragonFly.cpp

lib/Driver/Driver.cpp

 #include "ToolChains/Contiki.h"
 #include "ToolChains/CrossWindows.h"
 #include "ToolChains/Cuda.h"
 #include "ToolChains/Darwin.h"
 #include "ToolChains/DragonFly.h"
 #include "ToolChains/FreeBSD.h"
 #include "ToolChains/Fuchsia.h"
 #include "ToolChains/Gnu.h"
+#include "ToolChains/BareMetal.h"
 #include "ToolChains/Haiku.h"
 #include "ToolChains/Hexagon.h"
 #include "ToolChains/Lanai.h"
 #include "ToolChains/Linux.h"
 #include "ToolChains/MinGW.h"
 #include "ToolChains/Minix.h"
 #include "ToolChains/MipsLinux.h"
 #include "ToolChains/MSVC.h"

         break;
       case llvm::Triple::avr:
         TC = llvm::make_unique<toolchains::AVRToolChain>(*this, Target, Args);
         break;
       default:
         if (Target.getVendor() == llvm::Triple::Myriad)
           TC = llvm::make_unique<toolchains::MyriadToolChain>(*this, Target,
                                                               Args);
+        else if (toolchains::BareMetal::handlesTarget(Target))
+          TC = llvm::make_unique<toolchains::BareMetal>(*this, Target, Args);
         else if (Target.isOSBinFormatELF())
           TC = llvm::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
         else if (Target.isOSBinFormatMachO())
           TC = llvm::make_unique<toolchains::MachO>(*this, Target, Args);
         else
           TC = llvm::make_unique<toolchains::Generic_GCC>(*this, Target, Args);
       }
     }

lib/Driver/ToolChains/BareMetal.h

+//===--- BareMetal.h - Bare Metal Tool and ToolChain -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_BAREMETAL_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_BAREMETAL_H
+
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+#include <string>
+
+namespace clang {
+namespace driver {
+
+namespace toolchains {
+
+class LLVM_LIBRARY_VISIBILITY BareMetal : public ToolChain {
+public:
+  BareMetal(const Driver &D, const llvm::Triple &Triple,
+            const llvm::opt::ArgList &Args);
+  ~BareMetal() override;
+
+  static bool handlesTarget(const llvm::Triple &Triple);
+protected:
+  Tool *buildLinker() const override;
+
+public:
+  bool useIntegratedAs() const override { return true; }
+  bool isCrossCompiling() const override { return true; }
+  bool isPICDefault() const override { return false; }
+  bool isPIEDefault() const override { return false; }
+  bool isPICDefaultForced() const override { return false; }
+  bool SupportsProfiling() const override { return false; }
+  bool SupportsObjCGC() const override { return false; }
+  std::string getThreadModel() const override;
+  bool isThreadModelSupported(const StringRef Model) const override;
+
+  RuntimeLibType GetDefaultRuntimeLibType() const override {
+    return ToolChain::RLT_CompilerRT;
+  }
+  CXXStdlibType GetDefaultCXXStdlibType() const override {
+    return ToolChain::CST_Libcxx;
+  }
+
+  const char *getDefaultLinker() const override { return "ld.lld"; }
+
+  std::string getRuntimesDir() const;
+  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                                 llvm::opt::ArgStringList &CC1Args) const override;
+  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+                             llvm::opt::ArgStringList &CC1Args) const override;
+  std::string findLibCxxIncludePath(ToolChain::CXXStdlibType LibType) const;
+  void AddClangCXXStdlibIncludeArgs(
+      const llvm::opt::ArgList &DriverArgs,
+      llvm::opt::ArgStringList &CC1Args) const override;
+  void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+                           llvm::opt::ArgStringList &CmdArgs) const override;
+  void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
+                         llvm::opt::ArgStringList &CmdArgs) const;
+};
+
+} // namespace toolchains
+
+namespace tools {
+namespace baremetal {
+
+class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+public:
+  Linker(const ToolChain &TC) : Tool("baremetal::Linker", "ld.lld", TC) {}
+  bool isLinkJob() const override { return true; }
+  bool hasIntegratedCPP() const override { return false; }
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+};
+
+} // namespace baremetal
+} // namespace tools
+
+} // namespace driver
+} // namespace clang
+
+#endif

lib/Driver/ToolChains/BareMetal.cpp

+//===--- BaremMetal.cpp - Bare Metal ToolChain ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "BareMetal.h"
+
+#include "CommonArgs.h"
+#include "InputInfo.h"
+#include "Gnu.h"
+
+#include "clang/Basic/VirtualFileSystem.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm::opt;
+using namespace clang;
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang::driver::toolchains;
+
+BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
+                           const ArgList &Args)
+    : ToolChain(D, Triple, Args) {
+  getProgramPaths().push_back(getDriver().getInstalledDir());
+  if (getDriver().getInstalledDir() != getDriver().Dir)
+    getProgramPaths().push_back(getDriver().Dir);
+}
+
+BareMetal::~BareMetal() {}
+
+/// Is the triple {arm,thumb}-none-none-{eabi,eabihf} ?
+static bool isARMBareMetal(const llvm::Triple &Triple) {
+  if (Triple.getArch() != llvm::Triple::arm &&
+      Triple.getArch() != llvm::Triple::thumb)
+    return false;
+
+  if (Triple.getVendor() != llvm::Triple::UnknownVendor)
+    return false;
+
+  if (Triple.getOS() != llvm::Triple::UnknownOS)
+    return false;
+
+  if (Triple.getEnvironment() != llvm::Triple::EABI &&
+      Triple.getEnvironment() != llvm::Triple::EABIHF)
+    return false;
+
+  return true;
+}
+
+bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
+  return isARMBareMetal(Triple);
+}
+
+Tool *BareMetal::buildLinker() const {
+  return new tools::baremetal::Linker(*this);
+}
+
+std::string BareMetal::getThreadModel() const {
+  return "single";
+}
+
+bool BareMetal::isThreadModelSupported(const StringRef Model) const {
+  return Model == "single";
+}
+
+std::string BareMetal::getRuntimesDir() const {
+  SmallString<128> Dir(getDriver().ResourceDir);
+  llvm::sys::path::append(Dir, "lib", "baremetal");
+  return Dir.str();
+}
+
+void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
+                                          ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdinc))
+    return;
+
+  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+    SmallString<128> Dir(getDriver().ResourceDir);
+    llvm::sys::path::append(Dir, "include");
+    addSystemInclude(DriverArgs, CC1Args, Dir.str());
+  }
+
+  if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
+    SmallString<128> Dir(getDriver().SysRoot);
+    llvm::sys::path::append(Dir, "include");
+    addSystemInclude(DriverArgs, CC1Args, Dir.str());
+  }
+}
+
+void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
+                                      ArgStringList &CC1Args) const {
+  CC1Args.push_back("-nostdsysteminc");
+}
+
+std::string BareMetal::findLibCxxIncludePath(CXXStdlibType LibType) const {
+  StringRef SysRoot = getDriver().SysRoot;
+  if (SysRoot.empty())
+    return "";
+
+  switch (LibType) {
+  case ToolChain::CST_Libcxx: {
+    SmallString<128> Dir(SysRoot);
+    llvm::sys::path::append(Dir, "include", "c++", "v1");
+    return Dir.str();
+  }
+  case ToolChain::CST_Libstdcxx: {
+    SmallString<128> Dir(SysRoot);
+    llvm::sys::path::append(Dir, "include", "c++");
+    std::error_code EC;
+    Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
+    // Walk the subdirs, and find the one with the newest gcc version:
+    for (vfs::directory_iterator LI =
+           getDriver().getVFS().dir_begin(Dir.str(), EC), LE;
+         !EC && LI != LE; LI = LI.increment(EC)) {
+      StringRef VersionText = llvm::sys::path::filename(LI->getName());
+      auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
+      if (CandidateVersion.Major == -1)
+        continue;
+      if (CandidateVersion <= Version)
+        continue;
+      Version = CandidateVersion;
+    }
+    if (Version.Major == -1)
+      return "";
+    llvm::sys::path::append(Dir, Version.Text);
+    return Dir.str();
+  }
+  }
+}
+
+void BareMetal::AddClangCXXStdlibIncludeArgs(
+    const ArgList &DriverArgs, ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
+      DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+      DriverArgs.hasArg(options::OPT_nostdincxx))
+    return;
+
+  std::string Path = findLibCxxIncludePath(GetCXXStdlibType(DriverArgs));
+  if (!Path.empty())
+    addSystemInclude(DriverArgs, CC1Args, Path);
+}
+
+void BareMetal::AddCXXStdlibLibArgs(const ArgList &Args,
+                                    ArgStringList &CmdArgs) const {
+  switch (GetCXXStdlibType(Args)) {
+  case ToolChain::CST_Libcxx:
+    CmdArgs.push_back("-lc++");
+    CmdArgs.push_back("-lc++abi");
+    break;
+  case ToolChain::CST_Libstdcxx:
+    CmdArgs.push_back("-lstdc++");
+    CmdArgs.push_back("-lsupc++");
+    break;
+  }
+  CmdArgs.push_back("-lunwind");
+}
+
+void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
+                                  ArgStringList &CmdArgs) const {
+  CmdArgs.push_back(Args.MakeArgString("-lclang_rt.builtins-" +
+                                       getTriple().getArchName() + ".a"));
+}
+
+void baremetal::Linker::ConstructJob(Compilation &C, const JobAction &JA,
+                                     const InputInfo &Output,
+                                     const InputInfoList &Inputs,
+                                     const ArgList &Args,
+                                     const char *LinkingOutput) const {
+  ArgStringList CmdArgs;
+
+  auto &TC = static_cast<const toolchains::BareMetal&>(getToolChain());
+
+  AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
+
+  CmdArgs.push_back("-Bstatic");
+
+  CmdArgs.push_back(Args.MakeArgString("-L" + TC.getRuntimesDir()));
+
+  Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
+                            options::OPT_e, options::OPT_s, options::OPT_t,
+                            options::OPT_Z_Flag, options::OPT_r});
+
+  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+    if (C.getDriver().CCCIsCXX())
+      TC.AddCXXStdlibLibArgs(Args, CmdArgs);
+
+    CmdArgs.push_back("-lc");
+    CmdArgs.push_back("-lm");
+
+    TC.AddLinkRuntimeLib(Args, CmdArgs);
+  }
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  C.addCommand(llvm::make_unique<Command>(JA, *this,
+                                          Args.MakeArgString(TC.GetLinkerPath()),
+                                          CmdArgs, Inputs));
+}

lib/Driver/ToolChains/Gnu.cpp

     // Provide a lexicographic sort to make this a total ordering.
     return PatchSuffix < RHSPatchSuffix;
   }
 
   // The versions are equal.
   return false;
 }
 
+/// \brief Parse a GCCVersion object out of a string of text.
+///
+/// This is the primary means of forming GCCVersion objects.
+/*static*/
+Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) {
+  const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
+  std::pair<StringRef, StringRef> First = VersionText.split('.');
+  std::pair<StringRef, StringRef> Second = First.second.split('.');
+
+  GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
+  if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
+    return BadVersion;
+  GoodVersion.MajorStr = First.first.str();
+  if (First.second.empty())
+    return GoodVersion;
+  if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
+    return BadVersion;
+  GoodVersion.MinorStr = Second.first.str();
+
+  // First look for a number prefix and parse that if present. Otherwise just
+  // stash the entire patch string in the suffix, and leave the number
+  // unspecified. This covers versions strings such as:
+  //   5        (handled above)
+  //   4.4
+  //   4.4.0
+  //   4.4.x
+  //   4.4.2-rc4
+  //   4.4.x-patched
+  // And retains any patch number it finds.
+  StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
+  if (!PatchText.empty()) {
+    if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
+      // Try to parse the number and any suffix.
+      if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
+          GoodVersion.Patch < 0)
+        return BadVersion;
+      GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
+    }
+  }
+
+  return GoodVersion;
+}
+
 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
   const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
   if (A)
     return A->getValue();
   return GCC_INSTALL_PREFIX;
 }
 
 /// \brief Initialize a GCCInstallationDetector from the driver.

lib/Driver/ToolChains/Linux.cpp

#endif
   // directory ('Dir' below) or the ResourceDir.
   if (StringRef(D.Dir).startswith(SysRoot))
     addPathIfExists(D, D.Dir + "/../lib", Paths);
 
   addPathIfExists(D, SysRoot + "/lib", Paths);
   addPathIfExists(D, SysRoot + "/usr/lib", Paths);
 }
 
-/// \brief Parse a GCCVersion object out of a string of text.
-///
-/// This is the primary means of forming GCCVersion objects.
-/*static*/
-Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) {
-  const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
-  std::pair<StringRef, StringRef> First = VersionText.split('.');
-  std::pair<StringRef, StringRef> Second = First.second.split('.');
-
-  GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
-  if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
-    return BadVersion;
-  GoodVersion.MajorStr = First.first.str();
-  if (First.second.empty())
-    return GoodVersion;
-  if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
-    return BadVersion;
-  GoodVersion.MinorStr = Second.first.str();
-
-  // First look for a number prefix and parse that if present. Otherwise just
-  // stash the entire patch string in the suffix, and leave the number
-  // unspecified. This covers versions strings such as:
-  //   5        (handled above)
-  //   4.4
-  //   4.4.0
-  //   4.4.x
-  //   4.4.2-rc4
-  //   4.4.x-patched
-  // And retains any patch number it finds.
-  StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
-  if (!PatchText.empty()) {
-    if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
-      // Try to parse the number and any suffix.
-      if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
-          GoodVersion.Patch < 0)
-        return BadVersion;
-      GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
-    }
-  }
-
-  return GoodVersion;
-}
-
 bool Linux::HasNativeLLVMSupport() const { return true; }
 
 Tool *Linux::buildLinker() const { return new tools::gnutools::Linker(*this); }
 
 Tool *Linux::buildAssembler() const {
   return new tools::gnutools::Assembler(*this);
 }
 

test/Driver/baremetal.cpp

+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     -T semihosted.lds \
+// RUN:     -L some/directory/user/asked/for \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-C %s
+// CHECK-V6M-C: "[[PREFIX_DIR:.*]]/bin/clang" "-cc1" "-triple" "thumbv6m-none--eabi"
+// CHECK-V6M-C-SAME: "-resource-dir" "[[PREFIX_DIR]]/lib/clang/[[VERSION:[^"]*]]"
+// CHECK-V6M-C-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
+// CHECK-V6M-C-SAME: "-internal-isystem" "[[SYSROOT]]/include/c++/v1"
+// CHECk-V6M-C-SAME: "-internal-isystem" "[[SYSROOT]]/include"
+// CHECK-V6M-C-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
+// CHECK-V6M-C-NEXT: "[[PREFIX_DIR:.*]]/bin/ld.lld" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-C-SAME: "-L[[PREFIX_DIR]]/lib/clang/[[VERSION]]/lib/baremetal"
+// CHECK-V6M-C-SAME: "-T" "semihosted.lds" "-Lsome/directory/user/asked/for"
+// CHECK-V6M-C-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a"
+// CHECK-V6M-C-SAME: "-o" "{{.*}}.o"
+
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     -nostdlibinc -nobuiltininc \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-LIBINC %s
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     -nostdinc \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-LIBINC %s
+// CHECK-V6M-LIBINC-NOT: "-internal-isystem"
+
+// RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-DEFAULTCXX %s
+// CHECK-V6M-DEFAULTCXX: "[[PREFIX_DIR:.*]]/bin/ld.lld" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-DEFAULTCXX-SAME: "-L[[PREFIX_DIR]]/lib/clang/{{.*}}/lib/baremetal"
+// CHECK-V6M-DEFAULTCXX-SAME: "-lc++" "-lc++abi" "-lunwind"
+// CHECK-V6M-DEFAULTCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a"
+// CHECK-V6M-DEFAULTCXX-SAME: "-o" "{{.*}}.o"
+
+// RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:     -stdlib=libc++ \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-LIBCXX %s
+// CHECK-V6M-LIBCXX-NOT: "-internal-isystem" "{{[^"]+}}/include/c++/{{[^v].*}}"
+// CHECK-V6M-LIBCXX: "-internal-isystem" "{{[^"]+}}/include/c++/v1"
+// CHECK-V6M-LIBCXX: "[[PREFIX_DIR:.*]]/bin/ld.lld" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-LIBCXX-SAME: "-L[[PREFIX_DIR]]/lib/clang/{{.*}}/lib/baremetal"
+// CHECK-V6M-LIBCXX-SAME: "-lc++" "-lc++abi" "-lunwind"
+// CHECK-V6M-LIBCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a"
+// CHECK-V6M-LIBCXX-SAME: "-o" "{{.*}}.o"
+
+// RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:     -stdlib=libstdc++ \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-LIBSTDCXX %s
+// CHECK-V6M-LIBSTDCXX-NOT: "-internal-isystem" "{{[^"]+}}/include/c++/v1"
+// CHECK-V6M-LIBSTDCXX: "-internal-isystem" "{{[^"]+}}/include/c++/6.0.0"
+// CHECK-V6M-LIBSTDCXX: "[[PREFIX_DIR:.*]]/bin/ld.lld" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-LIBSTDCXX-SAME: "-L[[PREFIX_DIR]]/lib/clang/{{.*}}/lib/baremetal"
+// CHECK-V6M-LIBSTDCXX-SAME: "-lstdc++" "-lsupc++" "-lunwind"
+// CHECK-V6M-LIBSTDCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a"
+// CHECK-V6M-LIBSTDCXX-SAME: "-o" "{{.*}}.o"
+
+// RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target armv6m-none-eabi \
+// RUN:     --sysroot=%S/Inputs/baremetal_arm \
+// RUN:     -nodefaultlibs \
+// RUN:   | FileCheck --check-prefix=CHECK-V6M-NDL %s
+// CHECK-V6M-NDL: "[[PREFIX_DIR:.*]]/bin/ld.lld" "{{.*}}.o" "-Bstatic"
+// CHECK-V6M-NDL-SAME: "-L[[PREFIX_DIR]]/lib/clang/{{.*}}/lib/baremetal" "-o" "{{.*}}.o"
+
+// RUN: %clangxx -target arm-none-eabi -v 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-THREAD-MODEL
+// CHECK-THREAD-MODEL: Thread model: single