[Driver] Support linking to compiler-rt on AVR

[benshi001]

As changes in https://reviews.llvm.org/D123200,
it whould be better to support "--rtlib=compiler-rt" on AVR first.

[benshi001]

clang/lib/Driver/ToolChains/AVR.cpp

430

This method decides the file name of compiler-rt, it is expected to be

libclang_rt.builtins-avrfamily.a, such as

libclang_rt.builtins-avr51.a
libclang_rt.builtins-avrtiny.a
libclang_rt.builtins-avrxmega3.a

433

This method decides the library path of compiler-rt, it is
$(RESOURCE_DIR)/lib/avr or $(RESOURCE_DIR)/lib/. The resource dir is either explicitly specified via user option -resource-dir or has default value $(LLVM_INSTALL_DIR)/lib/clang/$(LLVM_VERSION. such as

/opt/avr-tool-chain/lib/clang/14.0.1/lib/avr
/opt/avr-tool-chain/lib/clang/14.0.1/lib/

444

Currently we still use libgcc if --rtlib option is not specified.

489

Currently we only allow --rtlib=libgcc and --rtlib=compiler-rt

517

If --rtlib is not specified or specified to libgcc, then we generate -L$PATH_TO_LIBGCC

557

If --rtlib is not specified or specified to libgcc, then we generate -lgcc

570

If --rtlib=compiler-rt is explicitly specified, we directly put the libclang.builtins-avrxxx.a as input file, other than -lclang.builtins-avrxxx, this is a tradition from other platforms, such as x86 and arm.

[MaskRay]

clang/lib/Driver/ToolChains/AVR.cpp

430

In -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on mode this should be lib/clang/$version/lib/$triple/libclang_rt.xxx.a where there is no -microarch infix.

[benshi001]

clang/lib/Driver/ToolChains/AVR.cpp

430

But I would expect each subarch has its own specific build with specific
optimization. That is the way in avr-gcc distribution.

[benshi001]

clang/lib/Driver/ToolChains/AVR.cpp

430

This hook buildCompilerRTBasename with be called twice by the base class. The first time is called with AddArch = false, for which I do not append -microarch infix.

For the second call with AddArch = true, I will append -microarch infix.

clang/lib/Driver/ToolChains/AVR.h

public:
   void
   addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                         llvm::opt::ArgStringList &CC1Args,
                         Action::OffloadKind DeviceOffloadKind) const override;
 
   llvm::Optional<std::string> findAVRLibcInstallation() const;
   StringRef getGCCInstallPath() const { return GCCInstallPath; }
 
+  std::string buildCompilerRTBasename(const llvm::opt::ArgList &Args,
+                                      StringRef Component, FileType Type,
+                                      bool AddArch) const override;
+
+  std::string getCompilerRTPath() const override;
+
+  ToolChain::RuntimeLibType GetDefaultRuntimeLibType() const override;
+
 protected:
   Tool *buildLinker() const override;
 
 private:
   StringRef GCCInstallPath;
+  std::string MCU;
 };
 
 } // end namespace toolchains
 
 namespace tools {
 namespace AVR {
 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
 public:

clang/lib/Driver/ToolChains/AVR.cpp

 #include "clang/Driver/Options.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 namespace {

 } // end anonymous namespace
 
 /// AVR Toolchain
 AVRToolChain::AVRToolChain(const Driver &D, const llvm::Triple &Triple,
                            const ArgList &Args)
     : Generic_ELF(D, Triple, Args) {
   GCCInstallation.init(Triple, Args);
 
-  std::string CPU = getCPUName(D, Args, Triple);
-  if (CPU.empty())
+  MCU = getCPUName(D, Args, Triple);
+  if (MCU.empty())
     D.Diag(diag::warn_drv_avr_mcu_not_specified);
 
   // Only add default libraries if the user hasn't explicitly opted out.
   if (!Args.hasArg(options::OPT_nostdlib) &&
-      !Args.hasArg(options::OPT_nodefaultlibs) &&
-      GCCInstallation.isValid()) {
+      !Args.hasArg(options::OPT_nodefaultlibs) && GCCInstallation.isValid()) {
     GCCInstallPath = GCCInstallation.getInstallPath();
     std::string GCCParentPath(GCCInstallation.getParentLibPath());
     getProgramPaths().push_back(GCCParentPath + "/../bin");
   }
 }
 
 void AVRToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                              ArgStringList &CC1Args) const {
if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
     CC1Args.push_back("-fno-use-init-array");
   // Use `-fno-use-cxa-atexit` as default, since avr-libc does not support
   // `__cxa_atexit()`.
   if (!DriverArgs.hasFlag(options::OPT_fuse_cxa_atexit,
                           options::OPT_fno_use_cxa_atexit, false))
     CC1Args.push_back("-fno-use-cxa-atexit");
 }
 
+std::string
+AVRToolChain::buildCompilerRTBasename(const llvm::opt::ArgList &Args,
+                                      StringRef Component, FileType Type,
+                                      bool AddArch) const {
+  const char *Prefix = "lib";
+  // libgcc distributed with avr-gcc always has '.a' suffix even on windows.
+  const char *Suffix = ".a";
+
+  // Each device family has its own compiler-rt build.
+  std::string Arch;
+  if (AddArch) {
+    Optional<StringRef> FamilyName = GetMCUFamilyName(MCU);
+    if (FamilyName)
+      Arch = "-" + (*FamilyName).str();
+  }
+
+  return (Prefix + Twine("clang_rt.") + Component + Arch + Suffix).str();
+}
+
+std::string AVRToolChain::getCompilerRTPath() const {
+  // Return "$ResourceDir/lib/avr/" if exists.
+  SmallString<128> Path0(getDriver().ResourceDir);
+  llvm::sys::path::append(Path0, "lib", "avr");
+  if (llvm::sys::fs::is_directory(Path0))
+    return std::string(Path0.str());
+
+  // Fall back to "ResourceDir/lib/".
+  SmallString<128> Path1(getDriver().ResourceDir);
+  llvm::sys::path::append(Path1, "lib");
+  return std::string(Path1.str());
+}
+
+ToolChain::RuntimeLibType AVRToolChain::GetDefaultRuntimeLibType() const {
+  return GCCInstallation.isValid() ? ToolChain::RLT_Libgcc
+                                   : ToolChain::RLT_CompilerRT;
+}
+
 Tool *AVRToolChain::buildLinker() const {
   return new tools::AVR::Linker(getTriple(), *this);
 }
 
 void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs, const ArgList &Args,
                                const char *LinkingOutput) const {
void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   // Enable garbage collection of unused sections.
   CmdArgs.push_back("--gc-sections");
 
   // Add library search paths before we specify libraries.
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   getToolChain().AddFilePathLibArgs(Args, CmdArgs);
 
+  // Get the runtime library, currently we only support libgcc and compiler-rt.
+  auto RtLib = TC.GetRuntimeLibType(Args);
+  assert(
+      (RtLib == ToolChain::RLT_Libgcc || RtLib == ToolChain::RLT_CompilerRT) &&
+      "unknown runtime library");
+
   // Only add default libraries if the user hasn't explicitly opted out.
   bool LinkStdlib = false;
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (!CPU.empty()) {
-        Optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
-        Optional<std::string> AVRLibcRoot = TC.findAVRLibcInstallation();
 
       if (!FamilyName) {
         // We do not have an entry for this CPU in the family
         // mapping table yet.
         D.Diag(diag::warn_drv_avr_family_linking_stdlibs_not_implemented)
             << CPU;
       } else if (TC.getGCCInstallPath().empty()) {
         // We can not link since there is no avr-ld.
         D.Diag(diag::warn_drv_avr_gcc_not_found);
       } else if (!AVRLibcRoot) {
         // No avr-libc found and so no runtime linked.
         D.Diag(diag::warn_drv_avr_libc_not_found);
       } else {
         std::string SubPath = GetMCUSubPath(CPU);
+        // Add avr-libc path.
         CmdArgs.push_back(
             Args.MakeArgString(Twine("-L") + *AVRLibcRoot + "/lib/" + SubPath));
-        CmdArgs.push_back(
-            Args.MakeArgString("-L" + TC.getGCCInstallPath() + "/" + SubPath));
+        // Add path of libgcc.
+        if (RtLib == ToolChain::RLT_Libgcc)
+          CmdArgs.push_back(Args.MakeArgString("-L" + TC.getGCCInstallPath() +
+                                               "/" + SubPath));
         LinkStdlib = true;
       }
     }
 
     if (!LinkStdlib)
       D.Diag(diag::warn_drv_avr_stdlib_not_linked);
   }
 
   if (SectionAddressData.hasValue()) {
     std::string DataSectionArg = std::string("-Tdata=0x") +
                                  llvm::utohexstr(SectionAddressData.getValue());
     CmdArgs.push_back(Args.MakeArgString(DataSectionArg));
   } else {
     // We do not have an entry for this CPU in the address mapping table yet.
     D.Diag(diag::warn_drv_avr_linker_section_addresses_not_implemented) << CPU;
   }
 
   // If the family name is known, we can link with the device-specific libgcc.
   // Without it, libgcc will simply not be linked. This matches avr-gcc
   // behavior.
   if (LinkStdlib) {
     assert(!CPU.empty() && "CPU name must be known in order to link stdlibs");
 
+    // Link to compiler-rt.
+    if (RtLib == ToolChain::RLT_CompilerRT) {
+      std::string RtLib =
+          getToolChain().getCompilerRT(Args, "builtins", ToolChain::FT_Static);
+      if (llvm::sys::fs::exists(RtLib))
+        CmdArgs.push_back(Args.MakeArgString(RtLib));
+    }
+
     CmdArgs.push_back("--start-group");
 
     // Add the object file for the CRT.
     std::string CrtFileName = std::string("-l:crt") + CPU + std::string(".o");
     CmdArgs.push_back(Args.MakeArgString(CrtFileName));
 
+    // Link to libgcc.
+    if (RtLib == ToolChain::RLT_Libgcc)
       CmdArgs.push_back("-lgcc");
+
+    // Link to generic libraries of avr-libc.
     CmdArgs.push_back("-lm");
     CmdArgs.push_back("-lc");
 
     // Add the link library specific to the MCU.
     CmdArgs.push_back(Args.MakeArgString(std::string("-l") + CPU));
 
     CmdArgs.push_back("--end-group");
 
     // Specify the family name as the emulation mode to use.
     // This is almost always required because otherwise avr-ld
     // will assume 'avr2' and warn about the program being larger
     // than the bare minimum supports.
     CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName));
   }
 
   C.addCommand(std::make_unique<Command>(
       JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker),
       CmdArgs, Inputs, Output));
 }
 
 llvm::Optional<std::string> AVRToolChain::findAVRLibcInstallation() const {
   // Search avr-libc installation according to avr-gcc installation.
   std::string GCCParent(GCCInstallation.getParentLibPath());
   std::string Path(GCCParent + "/avr");
   if (llvm::sys::fs::is_directory(Path))
     return Path;
   Path = GCCParent + "/../avr";
   if (llvm::sys::fs::is_directory(Path))
     return Path;
 
-  // Search avr-libc installation from possible locations, and return the first
-  // one that exists, if there is no avr-gcc installed.
+  // Search avr-libc installation from possible locations, and return the
+  // first one that exists, if there is no avr-gcc installed.
   for (StringRef PossiblePath : PossibleAVRLibcLocations) {
     std::string Path = getDriver().SysRoot + PossiblePath.str();
     if (llvm::sys::fs::is_directory(Path))
       return Path;
   }
 
   return llvm::None;
 }

clang/test/Driver/avr-toolchain.c

 // LINKA-NOT: warning: {{.*}} data section address
 
 // RUN: %clang -### --target=avr --sysroot=%S/Inputs/ -mmcu=atmega328 %s 2>&1 | FileCheck --check-prefixes=NOGCC %s
 // NOGCC: warning: no avr-gcc installation can be found on the system, cannot link standard libraries
 // NOGCC: warning: standard library not linked and so no interrupt vector table or compiler runtime routines will be linked
 // NOGCC-NOT: warning: {{.*}} microcontroller
 // NOGCC-NOT: warning: {{.*}} avr-libc
 // NOGCC-NOT: warning: {{.*}} data section address
+
+// RUN: %clang %s -### --target=avr -mmcu=atmega328 --sysroot=%S/Inputs/basic_avr_tree/ -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir 2>&1 | FileCheck --check-prefix=LIBGCC %s
+// RUN: %clang %s -### --target=avr -mmcu=atmega328 --sysroot=%S/Inputs/basic_avr_tree/ -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir --rtlib=libgcc 2>&1 | FileCheck --check-prefix=LIBGCC %s
+// LIBGCC: "-lgcc"
+// LIBGCC-NOT: libclang_rt
+
+// RUN: %clang %s -### --target=avr -mmcu=atmega328 --sysroot=%S/Inputs/basic_avr_tree/ -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir --rtlib=compiler-rt 2>&1 | FileCheck --check-prefix=COMRT %s
+// COMRT: libclang_rt.builtins-avr5.a
+// COMRT-NOT: "-lgcc"