fixes compiler-rt bug when printing libgcc for baremetal

[cjdb]

Summary

compiler-rt used to print /path/to/lib/clang/version/lib/libclang_rt.builtins-arm.a but should print /path/to/lib/clang/version/lib/baremetal/libclang_rt.builtins-arm.a.

[manojgupta]

clang/include/clang/Driver/ToolChain.h

662–664

I think with some overrides in Baremetal driver, this should hopefully not be needed.

clang/lib/Driver/ToolChain.cpp

401

Can you implement this function in BareMetal toolchain driver. My understanding is this is already a virtual function so implementing it there is better to override the default location.

clang/lib/Driver/ToolChains/BareMetal.cpp

40

Please add function Stringref getOSLibName() to override the default. It should return "baremetal"

67

Please add a getCompilerRTPath function which will call BareMetal::getRuntimesDir and to override ToolChain's getCompilerRTPath behavior.

163

Please implement getCompilerRTBasename function that just returns the part "clang_rt.builtins-" + getTriple().getArchName())" and call it here.

getCompilerRTBasename may need to be made virtual in Toolchain class so that it will override ToolChain class's default implementation.

[manojgupta]

clang/lib/Driver/ToolChains/BareMetal.cpp

163

Actually instead of implementing getCompilerRTBasename , just adding getArchNameForCompilerRTLib function is probably enough.

Make getArchNameForCompilerRTLib function in Toolchain.cpp part of Toolchain class and make it virtual.

Then overriding getArchNameForCompilerRTLib in BareMetal.h/.cpp by "return getTriple().getArchName()" is just what we need.

[cjdb]

Applies @manojgupta's requests.

clang/lib/Driver/ToolChains/BareMetal.cpp

163

Done, needed to prepend "lib" as well.

[manojgupta]

clang/lib/Driver/ToolChains/BareMetal.cpp

163

Thanks, overriding getArchNameForCompilerRTLib probably makes the change too large. We can revisit this in future if needed.

clang/include/clang/Driver/ToolChain.h

public:
   /// Returns the output denormal handling type in the default floating point
   /// environment for the given \p FPType if given. Otherwise, the default
   /// assumed mode for any floating point type.
   virtual llvm::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
       const llvm::fltSemantics *FPType = nullptr) const {
     return llvm::DenormalMode::getIEEE();
   }
+
+  /// Returns true if the toolchain is baremetal and false otherwise.
+  virtual bool isBareMetal() const { return false; }
 };
 
 /// Set a ToolChain's effective triple. Reset it when the registration object
 /// is destroyed.
 class RegisterEffectiveTriple {
   const ToolChain &TC;
 
 public:

clang/lib/Driver/ToolChain.cpp

case llvm::Triple::Solaris:
     return "sunos";
   case llvm::Triple::AIX:
     return "aix";
   default:
     return getOS();
   }
 }
 
 std::string ToolChain::getCompilerRTPath() const {
   SmallString<128> Path(getDriver().ResourceDir);
-  if (Triple.isOSUnknown()) {
+  if (isBareMetal()) {
+    llvm::sys::path::append(Path, "lib", "baremetal");
+  } else if (Triple.isOSUnknown()) {
     llvm::sys::path::append(Path, "lib");
   } else {
     llvm::sys::path::append(Path, "lib", getOSLibName());
   }
   return std::string(Path.str());
 }
 
 std::string ToolChain::getCompilerRTBasename(const ArgList &Args,

clang/lib/Driver/ToolChains/BareMetal.h

 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;
+  ~BareMetal() override = default;
 
   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 isBareMetal() const override { return true; }
 
   RuntimeLibType GetDefaultRuntimeLibType() const override {
     return ToolChain::RLT_CompilerRT;
   }
   CXXStdlibType GetDefaultCXXStdlibType() const override {
     return ToolChain::CST_Libcxx;
   }
 

clang/lib/Driver/ToolChains/BareMetal.cpp

 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;
 

 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
   return isARMBareMetal(Triple);
 }
 
 Tool *BareMetal::buildLinker() const {
   return new tools::baremetal::Linker(*this);
 }
 
 std::string BareMetal::getRuntimesDir() const {
   SmallString<128> Dir(getDriver().ResourceDir);
   llvm::sys::path::append(Dir, "lib", "baremetal");
   return std::string(Dir.str());
 }
 
 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                           ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc))

 }
 
 void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
                                   ArgStringList &CmdArgs) const {
   ToolChain::RuntimeLibType RLT = GetRuntimeLibType(Args);
   switch (RLT) {
   case ToolChain::RLT_CompilerRT:
     CmdArgs.push_back(
         Args.MakeArgString("-lclang_rt.builtins-" + getTriple().getArchName()));
     return;
   case ToolChain::RLT_Libgcc:
     CmdArgs.push_back("-lgcc");
     return;
   }
   llvm_unreachable("Unhandled RuntimeLibType.");
 }
 

clang/test/Driver/print-libgcc-file-name-clangrt.c

 // RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARMHF %s
 // CHECK-CLANGRT-ARMHF: libclang_rt.builtins-armhf.a
 
 // RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
 // RUN:     --target=arm-linux-gnueabi -mfloat-abi=hard \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-ABI %s
 // CHECK-CLANGRT-ARM-ABI: libclang_rt.builtins-armhf.a
+
+// RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
+// RUN:     --target=armv7m-none-eabi \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
+// RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-BAREMETAL %s
+// CHECK-CLANGRT-ARM-BAREMETAL: libclang_rt.builtins-arm.a
+
+// RUN: %clang -rtlib=compiler-rt -print-libgcc-file-name 2>&1 \
+// RUN:     --target=armv7m-none-eabi -mfloat-abi=hard \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_arch_subdir \
+// RUN:   | FileCheck --check-prefix=CHECK-CLANGRT-ARM-BAREMETAL-HF %s
+// CHECK-CLANGRT-ARM-BAREMETAL-HF: libclang_rt.builtins-armhf.a