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 ↗

(On Diff #297890)

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:
   virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     FileType Type = ToolChain::FT_Static) const;
 
   const char *
   getCompilerRTArgString(const llvm::opt::ArgList &Args, StringRef Component,
                          FileType Type = ToolChain::FT_Static) const;
 
-  std::string getCompilerRTBasename(const llvm::opt::ArgList &Args,
-                                    StringRef Component,
-                                    FileType Type = ToolChain::FT_Static,
-                                    bool AddArch = true) const;
+  virtual std::string
+  getCompilerRTBasename(const llvm::opt::ArgList &Args, StringRef Component,
 
   // Returns target specific runtime path if it exists.
   virtual Optional<std::string> getRuntimePath() const;
 
   // Returns target specific C++ library path if it exists.
   virtual Optional<std::string> getCXXStdlibPath() const;
 
   // Returns <ResourceDir>/lib/<OSName>/<arch>.  This is used by runtimes (such
   // as OpenMP) to find arch-specific libraries.
   std::string getArchSpecificLibPath() const;
 
   // Returns <OSname> part of above.
-  StringRef getOSLibName() const;
+  virtual StringRef getOSLibName() const;
 
   /// needsProfileRT - returns true if instrumentation profile is on.
   static bool needsProfileRT(const llvm::opt::ArgList &Args);
 
   /// Returns true if gcov instrumentation (-fprofile-arcs or --coverage) is on.
   static bool needsGCovInstrumentation(const llvm::opt::ArgList &Args);
 
   /// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
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();
   }
 };
 
 /// Set a ToolChain's effective triple. Reset it when the registration object
 /// is destroyed.
 class RegisterEffectiveTriple {
   const ToolChain &TC;
 
 public:
   RegisterEffectiveTriple(const ToolChain &TC, llvm::Triple T) : TC(TC) {
     TC.setEffectiveTriple(std::move(T));
   }

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; }
 
+  StringRef getOSLibName() const override { return "baremetal"; }
+
+  std::string getCompilerRTPath() const override;
+  std::string getCompilerRTBasename(const llvm::opt::ArgList &Args,
+                                    StringRef Component,
+                                    FileType Type = ToolChain::FT_Static,
+                                    bool AddArch = true) 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"; }

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::getCompilerRTPath() const { return getRuntimesDir(); }
+
+std::string BareMetal::getCompilerRTBasename(const llvm::opt::ArgList &,
+                                             StringRef, FileType, bool) const {
+  return ("libclang_rt.builtins-" + getTriple().getArchName() + ".a").str();
+}
+
 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-armv7m.a