Ported to Dyson: gnu ld and as, Debian multiarch

2 files changed, 497 insertions, 0 deletions

diff --git a/debian/patches/dyson-driver-gnutoolchain.patch b/debian/patches/dyson-driver-gnutoolchain.patch
new file mode 100644
index 0000000..32ec5e0
--- /dev/null
+++ b/debian/patches/dyson-driver-gnutoolchain.patch
@@ -0,0 +1,496 @@
+Description: dirty port to Dyson: GNU ld and Debian multiarch
+Index: llvm-3.5.git/clang/lib/Driver/Tools.cpp
+===================================================================
+--- llvm-3.5.git.orig/clang/lib/Driver/Tools.cpp
++++ llvm-3.5.git/clang/lib/Driver/Tools.cpp
+@@ -44,6 +44,10 @@ using namespace clang::driver::tools;
+ using namespace clang;
+ using namespace llvm::opt;
+ 
++// Forward declaration
++static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
++                      ArgStringList &CmdArgs, const ArgList &Args);
++
+ static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
+   Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
+                                     options::OPT_fpic, options::OPT_fno_pic,
+@@ -5898,47 +5902,44 @@ void solaris::Link::ConstructJob(Compila
+                                   const InputInfoList &Inputs,
+                                   const ArgList &Args,
+                                   const char *LinkingOutput) const {
+-  // FIXME: Find a real GCC, don't hard-code versions here
+-  std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
+-  const llvm::Triple &T = getToolChain().getTriple();
+-  std::string LibPath = "/usr/lib/";
+-  llvm::Triple::ArchType Arch = T.getArch();
+-  switch (Arch) {
++  const toolchains::Linux& ToolChain =
++    static_cast<const toolchains::Linux&>(getToolChain());
++  const Driver &D = ToolChain.getDriver();
++
++  ArgStringList CmdArgs;
++
++  if (!D.SysRoot.empty())
++    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
++
++  if (Args.hasArg(options::OPT_rdynamic))
++    CmdArgs.push_back("-export-dynamic");
++
++  if (Args.hasArg(options::OPT_s))
++    CmdArgs.push_back("-s");
++
++  for (const auto &Opt : ToolChain.ExtraOpts)
++    CmdArgs.push_back(Opt.c_str());
++
++  if (!Args.hasArg(options::OPT_static)) {
++    CmdArgs.push_back("--eh-frame-hdr");
++  }
++
++  CmdArgs.push_back("-m");
++  switch (ToolChain.getTriple().getArch()) {
+   case llvm::Triple::x86:
+-    GCCLibPath +=
+-        ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
++    CmdArgs.push_back("elf_i386_sol2");
+     break;
+   case llvm::Triple::x86_64:
+-    GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
+-    GCCLibPath += "/4.5.2/amd64/";
+-    LibPath += "amd64/";
++    CmdArgs.push_back("elf_x86_64_sol2");
+     break;
+   default:
+     llvm_unreachable("Unsupported architecture");
+   }
+ 
+-  ArgStringList CmdArgs;
+-
+-  // Demangle C++ names in errors
+-  CmdArgs.push_back("-C");
+-
+-  if ((!Args.hasArg(options::OPT_nostdlib)) &&
+-      (!Args.hasArg(options::OPT_shared))) {
+-    CmdArgs.push_back("-e");
+-    CmdArgs.push_back("_start");
+-  }
+-
+   if (Args.hasArg(options::OPT_static)) {
+-    CmdArgs.push_back("-Bstatic");
+-    CmdArgs.push_back("-dn");
+-  } else {
+-    CmdArgs.push_back("-Bdynamic");
+-    if (Args.hasArg(options::OPT_shared)) {
+-      CmdArgs.push_back("-shared");
+-    } else {
+-      CmdArgs.push_back("--dynamic-linker");
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
+-    }
++    CmdArgs.push_back("-static");
++  } else if (Args.hasArg(options::OPT_shared)) {
++    CmdArgs.push_back("-shared");
+   }
+ 
+   if (Output.isFilename()) {
+@@ -5947,55 +5948,92 @@ void solaris::Link::ConstructJob(Compila
+   } else {
+     assert(Output.isNothing() && "Invalid output.");
+   }
+-
+   if (!Args.hasArg(options::OPT_nostdlib) &&
+       !Args.hasArg(options::OPT_nostartfiles)) {
+     if (!Args.hasArg(options::OPT_shared)) {
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
+-      CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("values-Xa.o")));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
+     } else {
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
+-      CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("values-Xa.o")));
++      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
+     }
+-    if (getToolChain().getDriver().CCCIsCXX())
+-      CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
+   }
+ 
+-  CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
+-
+   Args.AddAllArgs(CmdArgs, options::OPT_L);
+   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
+   Args.AddAllArgs(CmdArgs, options::OPT_e);
+   Args.AddAllArgs(CmdArgs, options::OPT_r);
+ 
+-  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
++  const ToolChain::path_list Paths = ToolChain.getFilePaths();
++
++  for (const auto &Path : Paths)
++    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
++
++  if (D.IsUsingLTO(Args))
++    AddGoldPlugin(ToolChain, Args, CmdArgs);
++
++  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
++    CmdArgs.push_back("--no-demangle");
++
++  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
++  addSanitizerRuntimes(ToolChain, Args, CmdArgs);
++  addProfileRT(ToolChain, Args, CmdArgs);
++
++  if (D.CCCIsCXX() &&
++      !Args.hasArg(options::OPT_nostdlib) &&
++      !Args.hasArg(options::OPT_nodefaultlibs)) {
++    bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
++      !Args.hasArg(options::OPT_static);
++    if (OnlyLibstdcxxStatic)
++      CmdArgs.push_back("-Bstatic");
++    ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
++    if (OnlyLibstdcxxStatic)
++      CmdArgs.push_back("-Bdynamic");
++    CmdArgs.push_back("-lm");
++  }
+ 
+   if (!Args.hasArg(options::OPT_nostdlib) &&
+       !Args.hasArg(options::OPT_nodefaultlibs)) {
+-    if (getToolChain().getDriver().CCCIsCXX())
+-      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
+-    CmdArgs.push_back("-lgcc_s");
+-    if (!Args.hasArg(options::OPT_shared)) {
+-      CmdArgs.push_back("-lgcc");
++      if (D.CCCIsCXX()) {
++        ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
++      }
++
++      LibOpenMP UsedOpenMPLib = LibUnknown;
++      if (Args.hasArg(options::OPT_fopenmp)) {
++        UsedOpenMPLib = LibGOMP;
++      } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
++        UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
++            .Case("libgomp",  LibGOMP)
++            .Case("libiomp5", LibIOMP5)
++            .Default(LibUnknown);
++        if (UsedOpenMPLib == LibUnknown)
++          D.Diag(diag::err_drv_unsupported_option_argument)
++            << A->getOption().getName() << A->getValue();
++      }
++      switch (UsedOpenMPLib) {
++      case LibGOMP:
++        CmdArgs.push_back("-lgomp");
++        break;
++      case LibIOMP5:
++        CmdArgs.push_back("-liomp5");
++        break;
++      case LibUnknown:
++        break;
++      }
++      AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
+       CmdArgs.push_back("-lc");
+-      CmdArgs.push_back("-lm");
+     }
+-  }
+ 
+   if (!Args.hasArg(options::OPT_nostdlib) &&
+       !Args.hasArg(options::OPT_nostartfiles)) {
+-    CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
++    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
+   }
+-  CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
+-
+-  addProfileRT(getToolChain(), Args, CmdArgs);
++  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
+ 
+-  const char *Exec =
+-    Args.MakeArgString(getToolChain().GetLinkerPath());
+-  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
++  C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
+ }
+ 
+ void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
+Index: llvm-3.5.git/clang/lib/Driver/ToolChains.cpp
+===================================================================
+--- llvm-3.5.git.orig/clang/lib/Driver/ToolChains.cpp
++++ llvm-3.5.git/clang/lib/Driver/ToolChains.cpp
+@@ -2754,36 +2754,92 @@ Tool *AuroraUX::buildLinker() const {
+   return new tools::auroraux::Link(*this);
+ }
+ 
+-/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.
+-
+ Solaris::Solaris(const Driver &D, const llvm::Triple& Triple,
+                  const ArgList &Args)
+-  : Generic_GCC(D, Triple, Args) {
+-
+-  getProgramPaths().push_back(getDriver().getInstalledDir());
+-  if (getDriver().getInstalledDir() != getDriver().Dir)
+-    getProgramPaths().push_back(getDriver().Dir);
+-
+-  getFilePaths().push_back(getDriver().Dir + "/../lib");
+-  getFilePaths().push_back("/usr/lib");
++  : Linux(D, Triple, Args) {
+ }
+ 
+ Tool *Solaris::buildAssembler() const {
+-  return new tools::solaris::Assemble(*this);
++  return new tools::gnutools::Assemble(*this);
+ }
+ 
+ Tool *Solaris::buildLinker() const {
+   return new tools::solaris::Link(*this);
+ }
+ 
++void Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
++                                      ArgStringList &CC1Args) const {
++  const Driver &D = getDriver();
++  std::string SysRoot = computeSysRoot();
++
++  if (DriverArgs.hasArg(options::OPT_nostdinc))
++    return;
++
++  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
++    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
++
++  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
++    SmallString<128> P(D.ResourceDir);
++    llvm::sys::path::append(P, "include");
++    addSystemInclude(DriverArgs, CC1Args, P.str());
++  }
++
++  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
++    return;
++
++  // Check for configure-time C include directories.
++  StringRef CIncludeDirs(C_INCLUDE_DIRS);
++  if (CIncludeDirs != "") {
++    SmallVector<StringRef, 5> dirs;
++    CIncludeDirs.split(dirs, ":");
++    for (StringRef dir : dirs) {
++      StringRef Prefix = llvm::sys::path::is_absolute(dir) ? SysRoot : "";
++      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
++    }
++    return;
++  }
++
++  // Force the inclusion of the gcc headers (objc/objc.h)
++  addExternCSystemIncludeIfExists(
++     DriverArgs, CC1Args, GCCInstallation.getInstallPath() + "/include");
++
++  // Implement generic Debian multiarch support.
++  const StringRef X86_64MultiarchIncludeDirs[] = {
++    "/usr/include/x86_64-illumos",
++    "/usr/include/x86_64-kopensolaris-gnu"
++  };
++  const StringRef X86MultiarchIncludeDirs[] = {
++    "/usr/include/i386-illumos",
++    "/usr/include/i386-kopensolaris-gnu"
++  };
++
++  ArrayRef<StringRef> MultiarchIncludeDirs;
++  if (getTriple().getArch() == llvm::Triple::x86_64) {
++    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;
++  } else if (getTriple().getArch() == llvm::Triple::x86) {
++    MultiarchIncludeDirs = X86MultiarchIncludeDirs;
++  }
++
++  for (StringRef Dir : MultiarchIncludeDirs) {
++    if (llvm::sys::fs::exists(SysRoot + Dir)) {
++      addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir);
++      break;
++    }
++  }
++
++  // Add an include of '/include' directly. This isn't provided by default by
++  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
++  // add even when Clang is acting as-if it were a system compiler.
++  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
++
++  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
++}
++
+ /// Distribution (very bare-bones at the moment).
+ 
+ enum Distro {
+   ArchLinux,
+-  DebianLenny,
+-  DebianSqueeze,
+-  DebianWheezy,
+-  DebianJessie,
++  Debian,
+   Exherbo,
+   RHEL4,
+   RHEL5,
+@@ -2814,10 +2870,6 @@ static bool IsOpenSUSE(enum Distro Distr
+   return Distro == OpenSUSE;
+ }
+ 
+-static bool IsDebian(enum Distro Distro) {
+-  return Distro >= DebianLenny && Distro <= DebianJessie;
+-}
+-
+ static bool IsUbuntu(enum Distro Distro) {
+   return Distro >= UbuntuHardy && Distro <= UbuntuTrusty;
+ }
+@@ -2869,16 +2921,7 @@ static Distro DetectDistro(llvm::Triple:
+ 
+   File = llvm::MemoryBuffer::getFile("/etc/debian_version");
+   if (File) {
+-    StringRef Data = File.get()->getBuffer();
+-    if (Data[0] == '5')
+-      return DebianLenny;
+-    else if (Data.startswith("squeeze/sid") || Data[0] == '6')
+-      return DebianSqueeze;
+-    else if (Data.startswith("wheezy/sid")  || Data[0] == '7')
+-      return DebianWheezy;
+-    else if (Data.startswith("jessie/sid")  || Data[0] == '8')
+-      return DebianJessie;
+-    return UnknownDistro;
++      return Debian;
+   }
+ 
+   if (llvm::sys::fs::exists("/etc/SuSE-release"))
+@@ -2932,10 +2975,20 @@ static std::string getMultiarchTriple(co
+     }
+     return TargetTriple.str();
+   case llvm::Triple::x86:
++    if (TargetTriple.getOS() == llvm::Triple::Solaris) {
++      if (llvm::sys::fs::exists(SysRoot + "/lib/i386-illumos"))
++          return "i386-illumos";
++      return TargetTriple.str();
++    }
+     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
+       return "i386-linux-gnu";
+     return TargetTriple.str();
+   case llvm::Triple::x86_64:
++    if (TargetTriple.getOS() == llvm::Triple::Solaris) {
++      if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-illumos"))
++          return "x86_64-illumos";
++      return TargetTriple.str();
++    }
+     // We don't want this for x32, otherwise it will match x86_64 libs
+     if (TargetTriple.getEnvironment() != llvm::Triple::GNUX32 &&
+         llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
+@@ -3068,7 +3121,7 @@ Linux::Linux(const Driver &D, const llvm
+         (IsUbuntu(Distro) && Distro >= UbuntuMaverick))
+       ExtraOpts.push_back("--hash-style=gnu");
+ 
+-    if (IsDebian(Distro) || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
++    if (Distro == Debian || IsOpenSUSE(Distro) || Distro == UbuntuLucid ||
+         Distro == UbuntuJaunty || Distro == UbuntuKarmic)
+       ExtraOpts.push_back("--hash-style=both");
+   }
+@@ -3076,8 +3129,7 @@ Linux::Linux(const Driver &D, const llvm
+   if (IsRedhat(Distro))
+     ExtraOpts.push_back("--no-add-needed");
+ 
+-  if (Distro == DebianSqueeze || Distro == DebianWheezy ||
+-      Distro == DebianJessie || IsOpenSUSE(Distro) ||
++  if (Distro == Debian || IsOpenSUSE(Distro) ||
+       (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) ||
+       (IsUbuntu(Distro) && Distro >= UbuntuKarmic))
+     ExtraOpts.push_back("--build-id");
+@@ -3460,7 +3512,8 @@ void Linux::AddClangCXXStdlibIncludeArgs
+   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
+   StringRef LibDir = GCCInstallation.getParentLibPath();
+   StringRef InstallDir = GCCInstallation.getInstallPath();
+-  StringRef TripleStr = GCCInstallation.getTriple().str();
++  std::string includeMultiarch = getMultiarchTriple(GCCInstallation.getTriple(), getDriver().SysRoot);
++  StringRef TripleStr(includeMultiarch);
+   const Multilib &Multilib = GCCInstallation.getMultilib();
+   const GCCVersion &Version = GCCInstallation.getVersion();
+ 
+Index: llvm-3.5.git/clang/lib/Driver/ToolChains.h
+===================================================================
+--- llvm-3.5.git.orig/clang/lib/Driver/ToolChains.h
++++ llvm-3.5.git/clang/lib/Driver/ToolChains.h
+@@ -516,19 +516,6 @@ protected:
+   Tool *buildLinker() const override;
+ };
+ 
+-class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
+-public:
+-  Solaris(const Driver &D, const llvm::Triple &Triple,
+-          const llvm::opt::ArgList &Args);
+-
+-  bool IsIntegratedAssemblerDefault() const override { return true; }
+-protected:
+-  Tool *buildAssembler() const override;
+-  Tool *buildLinker() const override;
+-
+-};
+-
+-
+ class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
+ public:
+   OpenBSD(const Driver &D, const llvm::Triple &Triple,
+@@ -675,6 +662,7 @@ public:
+ protected:
+   Tool *buildAssembler() const override;
+   Tool *buildLinker() const override;
++  std::string computeSysRoot() const;
+ 
+ private:
+   static bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
+@@ -684,8 +672,23 @@ private:
+   static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
+                                        const llvm::opt::ArgList &DriverArgs,
+                                        llvm::opt::ArgStringList &CC1Args);
++};
++
++class LLVM_LIBRARY_VISIBILITY Solaris : public Linux {
++public:
++  Solaris(const Driver &D, const llvm::Triple &Triple,
++          const llvm::opt::ArgList &Args);
++  void
++  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
++                            llvm::opt::ArgStringList &CC1Args) const override;
++  bool IsIntegratedAssemblerDefault() const override { return true; }
++  // At Dyson PIE is not supported:
++  bool isPIEDefault() const override { return false; }
++
++protected:
++  Tool *buildAssembler() const override;
++  Tool *buildLinker() const override;
+ 
+-  std::string computeSysRoot() const;
+ };
+ 
+ class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux {
+Index: llvm-3.5.git/clang/lib/Driver/Tools.h
+===================================================================
+--- llvm-3.5.git.orig/clang/lib/Driver/Tools.h
++++ llvm-3.5.git/clang/lib/Driver/Tools.h
+@@ -492,7 +492,6 @@ namespace minix {
+   };
+ } // end namespace minix
+ 
+-  /// solaris -- Directly call Solaris assembler and linker
+ namespace solaris {
+   class LLVM_LIBRARY_VISIBILITY Assemble : public Tool  {
+   public:
+Index: llvm-3.5.git/clang/lib/Frontend/InitHeaderSearch.cpp
+===================================================================
+--- llvm-3.5.git.orig/clang/lib/Frontend/InitHeaderSearch.cpp
++++ llvm-3.5.git/clang/lib/Frontend/InitHeaderSearch.cpp
+@@ -390,6 +390,7 @@ AddDefaultCPlusPlusIncludePaths(const ll
+ 
+   switch (os) {
+   case llvm::Triple::Linux:
++  case llvm::Triple::Solaris:
+     llvm_unreachable("Include management is handled in the driver.");
+ 
+   case llvm::Triple::Win32:
+@@ -442,10 +443,6 @@ AddDefaultCPlusPlusIncludePaths(const ll
+     AddGnuCPlusPlusIncludePaths("/usr/gnu/include/c++/4.4.3",
+                                 "", "", "", triple);
+     break;
+-  case llvm::Triple::Solaris:
+-    AddGnuCPlusPlusIncludePaths("/usr/gcc/4.5/include/c++/4.5.2/",
+-                                "i386-pc-solaris2.11", "", "", triple);
+-    // Solaris - Fall though..
+   case llvm::Triple::AuroraUX:
+     // AuroraUX
+     AddGnuCPlusPlusIncludePaths("/opt/gcc4/include/c++/4.2.4",
diff --git a/debian/patches/series b/debian/patches/series
index 5fb41fc..6ce6a7d 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -46,3 +46,4 @@ gcc-compat-1.diff
 gcc-compat-2.diff
 dyson-coreutils.patch
 dyson-gnu-ld.patch
+dyson-driver-gnutoolchain.patch