# Solaris GCC Toolchain discovery.

# https://llvm.org/bugs/show_bug.cgi?id=24606

--- lib/Support/Host.cpp	2014-12-16 19:38:04.000000000 -0800

+++ lib/Support/Host.cpp	2016-02-09 09:59:19.281147309 -0800

@@ -39,6 +39,11 @@

 #include <mach/machine.h>

 #endif

+#if defined(sun) || defined(__sun) || defined(__sun__)

+#include <cstring>

+#include <kstat.h>

+#endif

+

 #define DEBUG_TYPE "host-detection"

 //===----------------------------------------------------------------------===//

@@ -674,6 +679,43 @@

   return "generic";

 }

+#elif ((defined(sun) || defined(__sun) || defined(__sun__)) && \

+       (defined(sparc) || defined(__sparc) || defined(__sparc__)))

+StringRef sys::getHostCPUName() {

+  kstat_ctl_t *KC = 0;

+  kstat_t *KSP = 0;

+  kstat_named_t *KNP = 0;

+  static char Buffer[256];

+  static bool Init = false;

+  const char *Value;

+

+  if (!Init) {

+    KC = kstat_open();

+    if (KC) {

+      KSP = kstat_lookup(KC, "cpu_info", -1, "cpu_info0");

+      kstat_read(KC, KSP, NULL);

+      KNP = reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "brand"));

+      Value = (const char *) KNP->value.str.addr.ptr;

+      (void) std::sprintf(Buffer, "%s (", Value);

+

+      KNP =

+        reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP, "cpu_type"));

+      Value = (const char*) KNP->value.c;

+      (void) std::strcat(Buffer, Value);

+      (void) std::strcat(Buffer, ") ");

+

+      KNP =

+        reinterpret_cast<kstat_named_t*>(kstat_data_lookup(KSP,

+                                                           "implementation"));

+      Value = (const char*) KNP->value.str.addr.ptr;

+      (void) std::strcat(Buffer, Value);

+      Init = true;

+      kstat_close(KC);

+    }

+  }

+

+  return Buffer;

+}

 #else

 StringRef sys::getHostCPUName() {

   return "generic";

--- tools/clang/include/clang/Driver/Options.td	Sat Jul 18 11:44:46 2015

+++ tools/clang/include/clang/Driver/Options.td	Thu Aug 20 22:46:37 2015

@@ -1129,6 +1129,11 @@

 def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,

   HelpText<"The thread model to use, e.g. posix, single (posix by default)">;

+def mvis : Flag<["-"], "mvis">, Group<m_Group>;

+def mvis2 : Flag<["-"], "mvis2">, Group<m_Group>;

+def mvis3 : Flag<["-"], "mvis3">, Group<m_Group>;

+def mimpure_text: Flag<["-"], "mimpure-text">, Group<m_Group>;

+

 def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>;

 def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>;

 def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>;

@@ -1690,6 +1695,7 @@

 defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_gcc_optimization_f_Group>;

 def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_gcc_optimization_f_Group>;

 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>;

+def fuse_as_EQ : Joined<["-"], "fuse-as=">, Group<f_Group>;

 defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>;

 def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>;

--- tools/clang/lib/Frontend/InitHeaderSearch.cpp	Thu Dec  4 16:22:48 2014

+++ tools/clang/lib/Frontend/InitHeaderSearch.cpp	Fri Aug 21 23:23:27 2015

@@ -122,7 +122,7 @@

   // Add the path with sysroot prepended, if desired and this is a system header

   // group.

   if (HasSysroot) {

-    SmallString<256> MappedPathStorage;

+    SmallString<PATH_MAX> MappedPathStorage;

     StringRef MappedPathStr = Path.toStringRef(MappedPathStorage);

     if (CanPrefixSysroot(MappedPathStr)) {

       AddUnmappedPath(IncludeSysroot + Path, Group, isFramework);

@@ -138,7 +138,7 @@

   assert(!Path.isTriviallyEmpty() && "can't handle empty path here");

   FileManager &FM = Headers.getFileMgr();

-  SmallString<256> MappedPathStorage;

+  SmallString<PATH_MAX> MappedPathStorage;

   StringRef MappedPathStr = Path.toStringRef(MappedPathStorage);

   // Compute the DirectoryLookup type.

@@ -187,12 +187,16 @@

   // Add the multilib dirs

   llvm::Triple::ArchType arch = triple.getArch();

-  bool is64bit = arch == llvm::Triple::ppc64 || arch == llvm::Triple::x86_64;

+  bool is64bit = arch == llvm::Triple::ppc64 || arch == llvm::Triple::x86_64 ||

+    arch == llvm::Triple::sparcv9;

   if (is64bit)

     AddPath(Base + "/" + ArchDir + "/" + Dir64, CXXSystem, false);

   else

     AddPath(Base + "/" + ArchDir + "/" + Dir32, CXXSystem, false);

+  // Add GCC's "C" include dir

+  AddPath(Base + "/include", CXXSystem, false);

+

   // Add the backward dir

   AddPath(Base + "/backward", CXXSystem, false);

 }

@@ -442,8 +446,7 @@

                                 "", "", "", triple);

     break;

   case llvm::Triple::Solaris:

-    AddGnuCPlusPlusIncludePaths("/usr/gcc/4.5/include/c++/4.5.2/",

-                                "i386-pc-solaris2.11", "", "", triple);

+    // All of this is handled in the driver.

     break;

   default:

     break;

@@ -462,6 +465,7 @@

     break; // Everything else continues to use this routine's logic.

   case llvm::Triple::Linux:

+  case llvm::Triple::Solaris:

     return;

   case llvm::Triple::Win32:

@@ -484,7 +488,7 @@

           // Remove clang from foo/lib/clang

           StringRef Lib = llvm::sys::path::parent_path(NoVer);

           // Remove lib from foo/lib

-          SmallString<128> P = llvm::sys::path::parent_path(Lib);

+          SmallString<PATH_MAX> P = llvm::sys::path::parent_path(Lib);

           // Get foo/include/c++/v1

           llvm::sys::path::append(P, "include", "c++", "v1");

@@ -491,10 +495,6 @@

           AddUnmappedPath(P.str(), CXXSystem, false);

         }

       }

-      // On Solaris, include the support directory for things like xlocale and

-      // fudged system headers.

-      if (triple.getOS() == llvm::Triple::Solaris) 

-        AddPath("/usr/include/c++/v1/support/solaris", CXXSystem, false);

       AddPath("/usr/include/c++/v1", CXXSystem, false);

     } else {

--- tools/clang/lib/Driver/Tools.h	Wed Jan 28 15:52:21 2015

+++ tools/clang/lib/Driver/Tools.h	Thu Aug 20 22:46:37 2015

@@ -529,6 +529,9 @@

     bool hasIntegratedCPP() const override { return false; }

+    void RenderExtraToolArgs(const JobAction &JA,

+                             ArgStringList &CmdArgs) const;

+

     void ConstructJob(Compilation &C, const JobAction &JA,

                       const InputInfo &Output, const InputInfoList &Inputs,

                       const llvm::opt::ArgList &TCArgs,

@@ -541,6 +544,9 @@

     bool hasIntegratedCPP() const override { return false; }

     bool isLinkJob() const override { return true; }

+    void RenderExtraToolArgs(const JobAction &JA,

+                             ArgStringList &CmdArgs) const;

+

     void ConstructJob(Compilation &C, const JobAction &JA,

                       const InputInfo &Output, const InputInfoList &Inputs,

                       const llvm::opt::ArgList &TCArgs,

--- tools/clang/lib/Driver/Tools.cpp	Sat Jul 18 11:44:46 2015

+++ tools/clang/lib/Driver/Tools.cpp	Sat Aug 22 17:26:16 2015

@@ -60,6 +60,12 @@

   }

 }

+static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,

+                      ArgStringList &CmdArgs, const ArgList &Args);

+

+static void AddLibgcc(const Driver &D, ArgStringList &CmdArgs,

+                       const ArgList &Args, const std::string& Exec);

+

 /// CheckPreprocessingOptions - Perform some validation of preprocessing

 /// arguments that is shared with gcc.

 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {

@@ -1360,14 +1366,30 @@

   return "";

 }

+static const char *getSparcTargetCPU(const ArgList &Args,

+                                     const llvm::Triple &Triple);

+

+static const char *getSparcTargetCPUFeature(const char* CPU,

+                                            const ArgList &Args,

+                                            const llvm::Triple &Triple);

+

 static void getSparcTargetFeatures(const ArgList &Args,

-                                   std::vector<const char *> &Features) {

-  bool SoftFloatABI = true;

+                                   std::vector<const char *> &Features,

+                                   const llvm::Triple &Triple) {

+  bool SoftFloatABI;

+

+  if ((Triple.getOS() == llvm::Triple::Solaris) ||

+      (Triple.getOS() == llvm::Triple::Linux))

+    SoftFloatABI = false;

+  else

+    SoftFloatABI = true;

+

   if (Arg *A =

           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {

     if (A->getOption().matches(options::OPT_mhard_float))

       SoftFloatABI = false;

   }

+

   if (SoftFloatABI)

     Features.push_back("+soft-float");

 }

@@ -1375,17 +1397,31 @@

 void Clang::AddSparcTargetArgs(const ArgList &Args,

                              ArgStringList &CmdArgs) const {

   const Driver &D = getToolChain().getDriver();

+  const llvm::Triple &T = getToolChain().getTriple();

   // Select the float ABI as determined by -msoft-float and -mhard-float.

+  // There is no support for soft-float ABI in Solaris.

   StringRef FloatABI;

   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,

                                options::OPT_mhard_float)) {

-    if (A->getOption().matches(options::OPT_msoft_float))

+    if (A->getOption().matches(options::OPT_msoft_float)) {

+      if ((T.getOS() == llvm::Triple::Solaris) ||

+          (T.getOS() == llvm::Triple::Linux)) {

+        D.Diag(diag::warn_drv_clang_unsupported) << "-msoft-float";

+        D.Diag(diag::warn_drv_overriding_flag_option) <<

+          "-msoft-float" << "-mhard-float";

+        FloatABI = "hard";

+      } else {

       FloatABI = "soft";

-    else if (A->getOption().matches(options::OPT_mhard_float))

+      }

+    } else if (A->getOption().matches(options::OPT_mhard_float))

       FloatABI = "hard";

   }

+  if (((T.getOS() == llvm::Triple::Solaris) ||

+       (T.getOS() == llvm::Triple::Linux)) && FloatABI.empty())

+    FloatABI = "hard";

+

   // If unspecified, choose the default based on the platform.

   if (FloatABI.empty()) {

     // Assume "soft", but warn the user we are guessing.

@@ -1400,10 +1436,93 @@

     CmdArgs.push_back("-msoft-float");

   } else {

     assert(FloatABI == "hard" && "Invalid float abi!");

-    CmdArgs.push_back("-mhard-float");

   }

+

+  std::string Feature;

+  if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {

+    Feature = "-march=";

+    Feature += A->getValue();

+    CmdArgs.push_back(Args.MakeArgString("-target-feature"));

+    CmdArgs.push_back(Args.MakeArgString(Feature.c_str()));

 }

+  if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {

+    Feature = "-mtune=";

+    Feature += A->getValue();

+    CmdArgs.push_back(Args.MakeArgString("-target-feature"));

+    CmdArgs.push_back(Args.MakeArgString(Feature.c_str()));

+  }

+

+  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {

+    Feature = "-mcpu=";

+    Feature += A->getValue();

+    CmdArgs.push_back(Args.MakeArgString("-target-feature"));

+    CmdArgs.push_back(Args.MakeArgString(Feature.c_str()));

+  }

+}

+

+static const char *getSparcTargetCPU(const ArgList &Args,

+                                     const llvm::Triple &Triple) {

+    StringRef V;

+

+    if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {

+      V = A->getValue();

+      switch (Triple.getOS()) {

+      case llvm::Triple::Solaris:

+      case llvm::Triple::Linux:

+        if (V == "v8plus" || V == "v8plusa" ||

+            V == "v8plusb" || V == "v9" ||

+            V == "v9a" || V == "v9b" ||

+            V == "sparcmaf" || V == "sparc4" )

+          return Args.MakeArgString(V);

+        break;

+      default:

+        return Args.MakeArgString("v8plusa");

+        break;

+      }

+    }

+

+    if (Arg *AA = Args.getLastArg(options::OPT_m64))

+      return "v9a";

+

+    return "v8plusa";

+}

+

+static const char *getSparcTargetCPUFeature(const char* CPU,

+                                            const ArgList &Args,

+                                            const llvm::Triple &Triple) {

+  StringRef V;

+  if (Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) {

+    V = A->getValue();

+

+    if (V.empty())

+      if (Arg *AA = Args.getLastArg(options::OPT_m64))

+        return "vis";

+

+    if (V == "ultrasparc" || V == "ultrasparc2" ||

+        V == "ultrasparc3" || V == "sparcmaf" || V == "sparc4" )

+      return Args.MakeArgString(A->getValue());

+  }

+

+  if (!CPU)

+    return 0;

+

+  std::string C = CPU;

+

+  if (C == "v8plus" || C == "v9")

+    return "";

+

+  if (C == "v8plusa" || C == "v9a")

+    return "vis1";

+  else if (C == "v8plusb" || C == "v9b")

+    return "vis2";

+  else if (C == "sparcmaf" || C == "sparc4")

+    return "vis3";

+

+  return 0;

+}

+

+

 static const char *getSystemZTargetCPU(const ArgList &Args) {

   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))

     return A->getValue();

@@ -1872,7 +1991,7 @@

     break;

   case llvm::Triple::sparc:

   case llvm::Triple::sparcv9:

-    getSparcTargetFeatures(Args, Features);

+    getSparcTargetFeatures(Args, Features, Triple);

     break;

   case llvm::Triple::aarch64:

   case llvm::Triple::aarch64_be:

@@ -2695,6 +2814,23 @@

     }

   }

+  // Solaris-specific defaults for PIE

+  if (getToolChain().getTriple().getOS() == llvm::Triple::Solaris) {

+    switch (getToolChain().getTriple().getArch()) {

+    case llvm::Triple::x86:

+      IsPICLevelTwo = false; // "-fpie"

+      break;

+    case llvm::Triple::sparc:

+    case llvm::Triple::x86_64:

+    case llvm::Triple::sparcv9:

+      IsPICLevelTwo = true; // "-fPIE"

+      break;

+

+    default:

+      break;

+    }

+  }

+

   // For the PIC and PIE flag options, this logic is different from the

   // legacy logic in very old versions of GCC, as that logic was just

   // a bug no one had ever fixed. This logic is both more rational and

@@ -2740,6 +2876,47 @@

   if (Args.hasArg(options::OPT_static))

     PIC = PIE = false;

+  if (Triple.getOS() == llvm::Triple::Solaris) {

+    if (Arg *A = Args.getLastArg(options::OPT_shared)) {

+      PIC = true;

+      PIE = false;

+      CmdArgs.push_back("-mrelocation-model");

+      CmdArgs.push_back("pic");

+      if (IsPICLevelTwo) {

+        CmdArgs.push_back("-pic-level");

+        CmdArgs.push_back("2");

+      }

+    } else if (PIC) {

+      PIC = true;

+      PIE = false;

+      CmdArgs.push_back("-mrelocation-model");

+      CmdArgs.push_back("pic");

+      if (IsPICLevelTwo) {

+        CmdArgs.push_back("-pic-level");

+        CmdArgs.push_back("2");

+      }

+    } else if (PIE) {

+      PIC = PIE = true;

+      CmdArgs.push_back("-mrelocation-model");

+      CmdArgs.push_back("pic");

+      if (IsPICLevelTwo) {

+        CmdArgs.push_back("-pie-level");

+        CmdArgs.push_back("2");

+      }

+    } else if (Args.hasArg(options::OPT_static)) {

+      // Solaris doesn't to static relocations.

+      PIC = PIE = false;

+      CmdArgs.push_back("-mrelocation-model");

+      CmdArgs.push_back("dynamic-no-pic");

+    } else {

+      // This is a Solaris non-PIE executable.

+      // Solaris doesn't to static relocations.

+      PIC = PIE = false;

+      CmdArgs.push_back("-mrelocation-model");

+      CmdArgs.push_back("dynamic-no-pic");

+    }

+  }

+

   if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {

     // This is a very special mode. It trumps the other modes, almost no one

     // uses it, and it isn't even valid on any OS but Darwin.

@@ -2762,6 +2939,8 @@

   } else {

     // Currently, LLVM only knows about PIC vs. static; the PIE differences are

     // handled in Clang's IRGen by the -pie-level flag.

+    // Solaris already took care of PIC/PIE/non-PIC above.

+    if (Triple.getOS() != llvm::Triple::Solaris) {

     CmdArgs.push_back("-mrelocation-model");

     CmdArgs.push_back(PIC ? "pic" : "static");

@@ -2774,6 +2953,7 @@

       }

     }

   }

+  }

   CmdArgs.push_back("-mthread-model");

   if (Arg *A = Args.getLastArg(options::OPT_mthread_model))

@@ -3180,12 +3360,13 @@

       // FIXME: we should support specifying dwarf version with

       // -gline-tables-only.

       CmdArgs.push_back("-gline-tables-only");

-      // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.

+      // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.

       const llvm::Triple &Triple = getToolChain().getTriple();

       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||

-          Triple.getOS() == llvm::Triple::FreeBSD ||

-          Triple.getOS() == llvm::Triple::Solaris)

+          Triple.getOS() == llvm::Triple::FreeBSD)

         CmdArgs.push_back("-gdwarf-2");

+      else if (Triple.getOS() == llvm::Triple::Solaris)

+        CmdArgs.push_back("-gdwarf-4");

     } else if (A->getOption().matches(options::OPT_gdwarf_2))

       CmdArgs.push_back("-gdwarf-2");

     else if (A->getOption().matches(options::OPT_gdwarf_3))

@@ -3194,12 +3375,13 @@

       CmdArgs.push_back("-gdwarf-4");

     else if (!A->getOption().matches(options::OPT_g0) &&

              !A->getOption().matches(options::OPT_ggdb0)) {

-      // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.

+      // Default is dwarf-2 for Darwin, OpenBSD and FreeBSD.

       const llvm::Triple &Triple = getToolChain().getTriple();

       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||

-          Triple.getOS() == llvm::Triple::FreeBSD ||

-          Triple.getOS() == llvm::Triple::Solaris)

+          Triple.getOS() == llvm::Triple::FreeBSD)

         CmdArgs.push_back("-gdwarf-2");

+      else if (Triple.getOS() == llvm::Triple::Solaris)

+        CmdArgs.push_back("-gdwarf-4");

       else

         CmdArgs.push_back("-g");

     }

@@ -3594,6 +3776,7 @@

     // If -fmessage-length=N was not specified, determine whether this is a

     // terminal and, if so, implicitly define -fmessage-length appropriately.

     unsigned N = llvm::sys::Process::StandardErrColumns();

+    if (N == 0) N = 72U;

     CmdArgs.push_back(Args.MakeArgString(Twine(N)));

   }

@@ -3735,6 +3918,7 @@

     CmdArgs.push_back("-backend-option");

     CmdArgs.push_back("-force-align-stack");

   }

+

   if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,

                    false)) {

     CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));

@@ -3743,6 +3927,10 @@

   if (Args.hasArg(options::OPT_mstack_alignment)) {

     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);

     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));

+  } else {

+    if ((getToolChain().getTriple().getArch() == llvm::Triple::sparc) ||

+        (getToolChain().getTriple().getArch() == llvm::Triple::sparcv9))

+      CmdArgs.push_back("-mstack-alignment=16");

   }

   if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||

@@ -6049,6 +6237,10 @@

   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));

 }

+void solaris::Assemble::RenderExtraToolArgs(const JobAction &JA,

+                                            ArgStringList &CmdArgs) const {

+}

+

 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,

                                       const InputInfo &Output,

                                       const InputInfoList &Inputs,

@@ -6055,61 +6247,321 @@

                                       const ArgList &Args,