1 # 23701635 clang produces amd64 opcodes, but calls 32-bit assembler by default

     2 # 23854357 clang should check for GNU ld

     3 # 22778650 clang should support OpenMP because it can

     4 # 24314745 clang should support PIE executables in Solaris

     5 # 3.9.X for upstream.

     6 --- tools/clang/include/clang/Driver/Options.td	2016-01-06 16:27:42.000000000 -0500

     7 +++ tools/clang/include/clang/Driver/Options.td	2016-05-08 23:19:20.553431263 -0400

     8 @@ -669,6 +669,9 @@

     9    Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"

    10    " | on (according to FP_CONTRACT pragma, default) | off (never fuse)">;

    11  

    12 +def fabi_version_EQ : Joined<["-"], "fabi-version=">, Group<f_Group>,

    13 +  Flags<[CC1Option]>, HelpText<"Use specified GNU C++ ABI version">;

    14 +

    15  def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;

    16  def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;

    17  

    18 @@ -1312,6 +1315,12 @@

    19  def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,

    20    HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">;

    21  

    22 +// SPARC-only options.

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

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

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

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

    27 +

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

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

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

    31 @@ -1954,6 +1963,7 @@

    32  

    33  def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_gcc_optimization_f_Group>;

    34  

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

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

    37  

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

    39 ###

    40 --- tools/clang/lib/Driver/Multilib.cpp	2015-10-12 10:32:57.000000000 -0400

    41 +++ tools/clang/lib/Driver/Multilib.cpp	2016-05-08 23:19:20.569431652 -0400

    42 @@ -171,11 +171,11 @@

    43  }

    44  

    45  static Multilib compose(const Multilib &Base, const Multilib &New) {

    46 -  SmallString<128> GCCSuffix;

    47 +  SmallString<PATH_MAX> GCCSuffix;

    48    llvm::sys::path::append(GCCSuffix, "/", Base.gccSuffix(), New.gccSuffix());

    49 -  SmallString<128> OSSuffix;

    50 +  SmallString<PATH_MAX> OSSuffix;

    51    llvm::sys::path::append(OSSuffix, "/", Base.osSuffix(), New.osSuffix());

    52 -  SmallString<128> IncludeSuffix;

    53 +  SmallString<PATH_MAX> IncludeSuffix;

    54    llvm::sys::path::append(IncludeSuffix, "/", Base.includeSuffix(),

    55                            New.includeSuffix());

    56  

    57 ###

    58 --- tools/clang/lib/Driver/ToolChains.cpp	2016-02-16 10:56:48.000000000 -0900

    59 +++ tools/clang/lib/Driver/ToolChains.cpp	2016-06-30 09:27:01.031173505 -0800

    60 @@ -28,12 +28,15 @@

    61  #include "llvm/ProfileData/InstrProf.h"

    62  #include "llvm/Support/ErrorHandling.h"

    63  #include "llvm/Support/FileSystem.h"

    64 +#include "llvm/Support/Host.h"

    65  #include "llvm/Support/MemoryBuffer.h"

    66  #include "llvm/Support/Path.h"

    67  #include "llvm/Support/Program.h"

    68  #include "llvm/Support/TargetParser.h"

    69  #include "llvm/Support/raw_ostream.h"

    70  #include <cstdlib> // ::getenv

    71 +#include <cstring>

    72 +#include <cctype>

    73  #include <system_error>

    74  

    75  using namespace clang::driver;

    76 @@ -41,6 +44,15 @@

    77  using namespace clang;

    78  using namespace llvm::opt;

    79  

    80 +#if defined(LLVM_ON_UNIX)

    81 +#include <cstring>

    82 +#include <cctype>

    83 +#include <sys/types.h>

    84 +#include <sys/stat.h>

    85 +#include <dirent.h>

    86 +#include <unistd.h>

    87 +#endif

    88 +

    89  MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)

    90      : ToolChain(D, Triple, Args) {

    91    // We expect 'as', 'ld', etc. to be adjacent to our install dir.

    92 @@ -1347,6 +1359,11 @@

    93      // If we have a SysRoot, try that first.

    94      if (!D.SysRoot.empty()) {

    95        Prefixes.push_back(D.SysRoot);

    96 +

    97 +      // Add Solaris-specific GCC locations.

    98 +      if (TargetTriple.getOS() == llvm::Triple::Solaris)

    99 +        Prefixes.push_back("/usr/gcc");

   100 +

   101        Prefixes.push_back(D.SysRoot + "/usr");

   102      }

   103  

   104 @@ -1434,14 +1451,17 @@

   105    static const char *const ARMebHFTriples[] = {

   106        "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};

   107  

   108 -  static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};

   109 +  static const char *const X86_64LibDirs[] = {"/lib64", "/lib/amd64",

   110 +                                               "/lib/64", "/lib"};

   111    static const char *const X86_64Triples[] = {

   112        "x86_64-linux-gnu",       "x86_64-unknown-linux-gnu",

   113        "x86_64-pc-linux-gnu",    "x86_64-redhat-linux6E",

   114        "x86_64-redhat-linux",    "x86_64-suse-linux",

   115        "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",

   116        "x86_64-slackware-linux", "x86_64-linux-android",

   117 -      "x86_64-unknown-linux"};

   118 +      "x86_64-unknown-linux", "x86_64-pc-solaris2.11",

   119 +      "x86_64-pc-solaris2.12", "x86_64-pc-solaris2.13" };

   120 +

   121    static const char *const X32LibDirs[] = {"/libx32"};

   122    static const char *const X86LibDirs[] = {"/lib32", "/lib"};

   123    static const char *const X86Triples[] = {

   124 @@ -1449,7 +1469,8 @@

   125        "i386-linux-gnu",       "i386-redhat-linux6E",   "i686-redhat-linux",

   126        "i586-redhat-linux",    "i386-redhat-linux",     "i586-suse-linux",

   127        "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",

   128 -      "i586-linux-gnu"};

   129 +      "i586-linux-gnu", "i386-pc-solaris2.11", "i386-pc-solaris2.12",

   130 +      "i386-pc-solaris2.13" };

   131  

   132    static const char *const MIPSLibDirs[] = {"/lib"};

   133    static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux",

   134 @@ -1483,30 +1504,28 @@

   135  

   136    static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};

   137    static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",

   138 -                                               "sparcv8-linux-gnu"};

   139 -  static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};

   140 +                                               "sparcv8-linux-gnu",

   141 +                                               "sparc-sun-solaris2.11",

   142 +                                               "sparc-sun-solaris2.12",

   143 +                                               "sparc-sun-solaris2.13" };

   144 +

   145 +  static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib/sparcv9",

   146 +                                                "/lib/64", "/lib" };

   147 +

   148    static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",

   149 -                                               "sparcv9-linux-gnu"};

   150 +                                               "sparcv9-linux-gnu",

   151 +                                               "sparcv9-sun-solaris2.11",

   152 +                                               "sparcv9-sun-solaris2.12",

   153 +                                               "sparcv9-sun-solaris2.13"  };

   154  

   155    static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};

   156    static const char *const SystemZTriples[] = {

   157        "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",

   158        "s390x-suse-linux", "s390x-redhat-linux"};

   159  

   160 -  // Solaris.

   161 -  static const char *const SolarisSPARCLibDirs[] = {"/gcc"};

   162 -  static const char *const SolarisSPARCTriples[] = {"sparc-sun-solaris2.11",

   163 -                                                    "i386-pc-solaris2.11"};

   164 -

   165    using std::begin;

   166    using std::end;

   167  

   168 -  if (TargetTriple.getOS() == llvm::Triple::Solaris) {

   169 -    LibDirs.append(begin(SolarisSPARCLibDirs), end(SolarisSPARCLibDirs));

   170 -    TripleAliases.append(begin(SolarisSPARCTriples), end(SolarisSPARCTriples));

   171 -    return;

   172 -  }

   173 -

   174    switch (TargetTriple.getArch()) {

   175    case llvm::Triple::aarch64:

   176      LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));

   177 @@ -3302,69 +3321,783 @@

   178  }

   179  

   180  /// Solaris - Solaris tool chain which can call as(1) and ld(1) directly.

   181 +bool Solaris::SupportsClangLibCPlusPlus = false;

   182  

   183  Solaris::Solaris(const Driver &D, const llvm::Triple &Triple,

   184 -                 const ArgList &Args)

   185 -    : Generic_GCC(D, Triple, Args) {

   186 +                 const llvm::opt::ArgList &Args)

   187 +  : Generic_ELF(D, Triple, Args),

   188 +  UseGnuAs(true),

   189 +  UseGnuLd(false),

   190 +  UseGoldLd(false),

   191 +  UseSunLd(true),

   192 +  UseMediatedGCCToolChainPath(false),

   193 +  UseSpecifiedGCCToolChainPath(false),

   194 +  IsValid(false),

   195 +  GCCInstallDir("/usr/gcc/"),

   196 +  GCCMajorMinor(""),

   197 +  GCCMajorMinorMicro(""),

   198 +  GCCInternalLibDir(""),

   199 +  GCCInternalMultiLibDir(""),

   200 +  GCCIncludeDirs(),

   201 +  Assembler("/usr/gnu/bin/as"),

   202 +  Linker("/usr/bin/ld"),

   203 +  mtune(""),

   204 +  march(""),

   205 +  mcpu(""),

   206 +  ExtraOpts() {

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

   208 +      GCCInstallDir = A->getValue();

   209 +      if (!llvm::sys::fs::exists(GCCInstallDir))

   210 +        D.Diag(diag::err_drv_no_such_file) << GCCInstallDir;

   211 +      else {

   212 +        findSpecifiedGCCToolchain(GCCInstallDir.c_str(), Triple, Args);

   213 +

   214 +        if (!UseSpecifiedGCCToolChainPath) {

   215 +          D.Diag(diag::err_drv_unsupported_rtlib_for_platform)

   216 +            << GCCInstallDir << Triple.getTriple();

   217 +        } else {

   218 +          findGCCIncludeDirs(Triple, Args);

   219 +          findGCCInternalLibDir(Triple, Args);

   220 +        }

   221 +      }

   222 +    } else {

   223 +      findGCCMajorMinor();

   224 +      findGCCMajorMinorMicro(Triple);

   225 +      findGCCIncludeDirs(Triple, Args);

   226 +      findGCCInternalLibDir(Triple, Args);

   227 +    }

   228  

   229 -  GCCInstallation.init(Triple, Args);

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

   231 +      Linker = A->getValue();

   232 +      if (Linker == "bfd")

   233 +        Linker = "/usr/gnu/bin/ld";

   234 +      else if (Linker == "gold")

   235 +        Linker = "/usr/gnu/bin/ld.gold";

   236 +

   237 +      if ((Linker == "/usr/gnu/bin/ld") || (Linker == "/usr/gnu/bin/ld.bfd") ||

   238 +          (Linker == "/usr/bin/gld") || (Linker == "/usr/bin/gld.bfd")) {

   239 +        UseGnuLd = true;

   240 +        UseGoldLd = false;

   241 +        UseSunLd = false;

   242 +      } else if ((Linker == "/usr/gnu/bin/ld.gold") ||

   243 +                 (Linker == "/usr/bin/gld.gold") ||

   244 +                 (Linker == "/usr/bin/ld.gold")) {

   245 +        UseGnuLd = false;

   246 +        UseSunLd = false;

   247 +        UseGoldLd = true;

   248 +      }

   249 +    }

   250  

   251 -  path_list &Paths = getFilePaths();

   252 -  if (GCCInstallation.isValid())

   253 -    addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);

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

   255 +      Assembler = A->getValue();

   256 +      if (Assembler == "llvm")

   257 +        UseGnuAs = false;

   258 +      else if ((Assembler == "/usr/gnu/bin/as") ||

   259 +               (Assembler == "/usr/bin/gas"))

   260 +        UseGnuAs = true;

   261 +      else if (Assembler == "gas") {

   262 +        Assembler = "/usr/gnu/bin/as";

   263 +        UseGnuAs = true;

   264 +      } else if ((Assembler == "/usr/bin/as") || (Assembler == "sun") ||

   265 +                 (Assembler == "solaris"))

   266 +        D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);

   267 +    }

   268 +

   269 +    getProgramPaths().push_back(GCCInstallDir);

   270  

   271 -  addPathIfExists(D, getDriver().getInstalledDir(), Paths);

   272    if (getDriver().getInstalledDir() != getDriver().Dir)

   273 -    addPathIfExists(D, getDriver().Dir, Paths);

   274 +      getProgramPaths().push_back(getDriver().Dir);

   275  

   276 -  addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);

   277 +    llvm::Triple::ArchType Arch = Triple.getArch();

   278  

   279 -  std::string LibPath = "/usr/lib/";

   280 -  switch (Triple.getArch()) {

   281 +    switch (Arch) {

   282    case llvm::Triple::x86:

   283 +      getFilePaths().push_back(getDriver().Dir + "/../lib");

   284 +      getFilePaths().push_back("/usr/lib");

   285 +      march = mtune = "i686";

   286 +      break;

   287    case llvm::Triple::sparc:

   288 +      getFilePaths().push_back(getDriver().Dir + "/../lib");

   289 +      getFilePaths().push_back("/usr/lib");

   290 +      mcpu = "ultrasparc";

   291 +      mtune = "ultrasparc";

   292 +      march = "v8plusa";

   293      break;

   294    case llvm::Triple::x86_64:

   295 -    LibPath += "amd64/";

   296 +      getFilePaths().push_back(getDriver().Dir + "/../lib/amd64");

   297 +      getFilePaths().push_back("/usr/lib/amd64");

   298 +      march = mtune = "opteron";

   299      break;

   300    case llvm::Triple::sparcv9:

   301 -    LibPath += "sparcv9/";

   302 +      getFilePaths().push_back(getDriver().Dir + "/../lib/sparcv9");

   303 +      getFilePaths().push_back("/usr/lib/sparcv9");

   304 +      mcpu = "ultrasparc";

   305 +      mtune = "ultrasparc";

   306 +      march = "v9a";

   307      break;

   308    default:

   309 -    llvm_unreachable("Unsupported architecture");

   310 +      getFilePaths().push_back(getDriver().Dir + "/../lib");

   311 +      getFilePaths().push_back("/usr/lib");

   312 +      break;

   313    }

   314  

   315 -  addPathIfExists(D, getDriver().SysRoot + LibPath, Paths);

   316 +    validate();

   317 +

   318 +    if (Args.hasArg(options::OPT_v))

   319 +      this->print(llvm::errs());

   320  }

   321  

   322 -Tool *Solaris::buildAssembler() const {

   323 -  return new tools::solaris::Assembler(*this);

   324 +std::string Solaris::computeSysRoot() const {

   325 +  if (!getDriver().SysRoot.empty())

   326 +    return getDriver().SysRoot;

   327 +

   328 +  return std::string("/");

   329  }

   330  

   331 -Tool *Solaris::buildLinker() const { return new tools::solaris::Linker(*this); }

   332 +bool

   333 +Solaris::addLibStdCXXIncludePaths(Twine Base, Twine Suffix,

   334 +                                  StringRef GCCTriple,

   335 +                                  StringRef GCCMultiarchTriple,

   336 +                                  StringRef TargetMultiarchTriple,

   337 +                                  Twine IncludeSuffix,

   338 +                                  const llvm::opt::ArgList &DriverArgs,

   339 +                                  llvm::opt::ArgStringList &CC1Args) const {

   340 +  if (!llvm::sys::fs::exists(Base + Suffix))

   341 +    return false;

   342  

   343 -void Solaris::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,

   344 -                                           ArgStringList &CC1Args) const {

   345 +  addSystemInclude(DriverArgs, CC1Args, Base);

   346 +  addSystemInclude(DriverArgs, CC1Args, Base + Suffix);

   347 +

   348 +  if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||

   349 +      llvm::sys::fs::exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {

   350 +    addSystemInclude(DriverArgs,

   351 +                     CC1Args, Base + Suffix + "/" + GCCTriple + IncludeSuffix);

   352 +  } else {

   353 +    addSystemInclude(DriverArgs, CC1Args,

   354 +                     Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);

   355 +    addSystemInclude(DriverArgs, CC1Args,

   356 +                     Base + "/" + TargetMultiarchTriple + Suffix);

   357 +  }

   358 +

   359 +  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");

   360 +  addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");

   361 +  return true;

   362 +}

   363 +

   364 +void

   365 +Solaris::AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,

   366 +                                      llvm::opt::ArgStringList &CC1Args) const {

   367    if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||

   368        DriverArgs.hasArg(options::OPT_nostdincxx))

   369      return;

   370  

   371 -  // Include the support directory for things like xlocale and fudged system

   372 -  // headers.

   373 -  addSystemInclude(DriverArgs, CC1Args, "/usr/include/c++/v1/support/solaris");

   374 +  const Driver &D = getDriver();

   375  

   376 -  if (GCCInstallation.isValid()) {

   377 -    GCCVersion Version = GCCInstallation.getVersion();

   378 -    addSystemInclude(DriverArgs, CC1Args,

   379 -                     getDriver().SysRoot + "/usr/gcc/" +

   380 -                     Version.MajorStr + "." +

   381 -                     Version.MinorStr +

   382 -                     "/include/c++/" + Version.Text);

   383 -    addSystemInclude(DriverArgs, CC1Args,

   384 -                     getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +

   385 -                     "." + Version.MinorStr + "/include/c++/" +

   386 -                     Version.Text + "/" +

   387 -                     GCCInstallation.getTriple().str());

   388 +  // Check for Clang libc++

   389 +  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {

   390 +    if (!Solaris::SupportsClangLibCPlusPlus) {

   391 +      D.Diag(diag::err_drv_invalid_stdlib_name) << "libc++";

   392 +      return;

   393 +    }

   394 +

   395 +    StringRef IncludePath = "/usr/include/libc++/v1";

   396 +    if (!llvm::sys::fs::exists(IncludePath)) {

   397 +      D.Diag(diag::err_drv_no_such_file) << IncludePath;

   398 +      return;

   399 +    }

   400 +

   401 +    addSystemInclude(DriverArgs, CC1Args, IncludePath);

   402 +    return;

   403 +  }

   404 +

   405 +  for (std::vector<std::string>::const_iterator B =

   406 +       getGCCIncludeDirs().begin(), E = getGCCIncludeDirs().end();

   407 +       B != E; ++B) {

   408 +    llvm::Twine IncludePath((*B));

   409 +    addSystemInclude(DriverArgs, CC1Args, IncludePath);

   410 +  }

   411 +}

   412 +

   413 +void

   414 +Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

   415 +                                   ArgStringList &CC1Args) const {

   416 +  const Driver &D = getDriver();

   417 +

   418 +  if (DriverArgs.hasArg(options::OPT_nostdinc))

   419 +    return;

   420 +

   421 +  std::string SysRoot = computeSysRoot();

   422 +

   423 +  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

   424 +    SmallString<PATH_MAX> P(D.ResourceDir);

   425 +    llvm::sys::path::append(P, "/include");

   426 +    addSystemInclude(DriverArgs, CC1Args, P.str());

   427 +  }

   428 +

   429 +  if (DriverArgs.hasArg(options::OPT_nostdlibinc))

   430 +    return;

   431 +

   432 +  StringRef CIncludeDirs(C_INCLUDE_DIRS);

   433 +  if (CIncludeDirs != "") {

   434 +    SmallVector<StringRef, 5> dirs;

   435 +    CIncludeDirs.split(dirs, ":");

   436 +    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();

   437 +         I != E; ++I) {

   438 +      StringRef Prefix =

   439 +        llvm::sys::path::is_absolute(*I) ? StringRef(SysRoot) : "";

   440 +      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);

   441 +    }

   442 +  }

   443 +

   444 +  addExternCSystemInclude(DriverArgs, CC1Args, "/usr/include");

   445 +}

   446 +

   447 +void

   448 +Solaris::addClangTargetOptions(const ArgList &DriverArgs,

   449 +                               ArgStringList &CC1Args) const {

   450 +  const llvm::Triple& TT = getTriple();

   451 +  llvm::Triple::ArchType Arch = TT.getArch();

   452 +

   453 +  if (Arg *A = DriverArgs.getLastArg(options::OPT_fuse_init_array))

   454 +    DriverArgs.ClaimAllArgs(options::OPT_fuse_init_array);

   455 +

   456 +  // Always use .init_array/.fini_array on Solaris. The Solaris

   457 +  // linker can't do .ctors/.dtors or .init/.fini for that matter.

   458 +  CC1Args.push_back("-fuse-init-array");

   459 +

   460 +  if (Arg *A = DriverArgs.getLastArg(options::OPT_fabi_version_EQ)) {

   461 +    StringRef V = A->getValue();

   462 +    if (!V.empty()) {

   463 +      std::string fabi_version = "-fabi-version=";

   464 +      fabi_version += V.str();

   465 +      CC1Args.push_back(DriverArgs.MakeArgString(fabi_version.c_str()));

   466 +    } else {

   467 +      std::string fabi_version = "-fabi-version=4";

   468 +      CC1Args.push_back(DriverArgs.MakeArgString(fabi_version.c_str()));

   469 +    }

   470 +  } else {

   471 +    CC1Args.push_back(DriverArgs.MakeArgString("-fabi-version=4"));

   472 +  }

   473 +

   474 +  DriverArgs.ClaimAllArgs(options::OPT_fabi_version_EQ);

   475 +

   476 +  if (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) {

   477 +    CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   478 +    CC1Args.push_back(DriverArgs.MakeArgString("+hwcap"));

   479 +  }

   480 +

   481 +  bool SeenVIS = false;

   482 +  bool SeenVIS2 = false;

   483 +  bool SeenVIS3 = false;

   484 +

   485 +  bool DoneVIS = false;

   486 +  bool DoneVIS2 = false;

   487 +  bool DoneVIS3 = false;

   488 +

   489 +  bool DoneMTune = false;

   490 +

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

   492 +    StringRef V = A->getValue();

   493 +    if (!V.empty())

   494 +      mtune = V.str();

   495 +    else

   496 +      mtune = "ultrasparc";

   497 +

   498 +    if (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) {

   499 +      if ((mtune == "ultrasparc") || (mtune == "ultrasparc2") ||

   500 +          (mtune == "vis")) {

   501 +        SeenVIS = true;

   502 +      } else if ((mtune == "ultrasparc3") || (mtune == "vis2")) {

   503 +        SeenVIS = true;

   504 +        SeenVIS2 = true;

   505 +      } else {

   506 +        SeenVIS = true;

   507 +        SeenVIS2 = true;

   508 +        SeenVIS3 = true;

   509 +      }

   510 +

   511 +      if (!DoneMTune) {

   512 +        if (SeenVIS3 && !DoneVIS3) {

   513 +          CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   514 +          CC1Args.push_back(DriverArgs.MakeArgString("+vis3"));

   515 +          DoneVIS3 = true;

   516 +          DoneVIS2 = true;

   517 +          DoneVIS = true;

   518 +        }

   519 +

   520 +        if (SeenVIS2 && !DoneVIS2) {

   521 +          CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   522 +          CC1Args.push_back(DriverArgs.MakeArgString("+vis2"));

   523 +          DoneVIS2 = true;

   524 +          DoneVIS = true;

   525 +        }

   526 +

   527 +        if (SeenVIS && !DoneVIS) {

   528 +          CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   529 +          CC1Args.push_back(DriverArgs.MakeArgString("+vis"));

   530 +          DoneVIS = true;

   531 +        }

   532 +

   533 +        DoneMTune = true;

   534 +      }

   535 +    }

   536 +  }

   537 +

   538 +  if (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) {

   539 +    if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis)) {

   540 +      SeenVIS = !DoneVIS;

   541 +      if (!DoneVIS) {

   542 +        CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   543 +        CC1Args.push_back(DriverArgs.MakeArgString("+vis"));

   544 +        DoneVIS = true;

   545 +      }

   546 +    }

   547 +

   548 +    if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis2)) {

   549 +      SeenVIS2 = !DoneVIS2;

   550 +      if (!DoneVIS2) {

   551 +        CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   552 +        CC1Args.push_back(DriverArgs.MakeArgString("+vis2"));

   553 +        DoneVIS2 = true;

   554 +        DoneVIS = true;

   555 +      }

   556 +    }

   557 +

   558 +    if (Arg *A = DriverArgs.getLastArg(options::OPT_mvis3)) {

   559 +      SeenVIS3 = !DoneVIS3;

   560 +      if (!DoneVIS3) {

   561 +        CC1Args.push_back(DriverArgs.MakeArgString("-target-feature"));

   562 +        CC1Args.push_back(DriverArgs.MakeArgString("+vis3"));

   563 +        DoneVIS3 = true;

   564 +        DoneVIS2 = true;

   565 +        DoneVIS = true;

   566 +      }

   567 +    }

   568 +  }

   569 +}

   570 +

   571 +void

   572 +Solaris::findGCCMajorMinor() const {

   573 +  // FIXME: Add 5.X after testing the ABI.

   574 +  static const char* const GCCMM[] = { "4.8", "4.9" };

   575 +

   576 +  const char* P;

   577 +  std::string Path;

   578 +

   579 +  Path.reserve(std::string::size_type(PATH_MAX));

   580 +

   581 +  for (int I = (llvm::array_lengthof(GCCMM) - 1); I >= 0; --I) {

   582 +    if ((P = GCCMM[I]) != NULL) {

   583 +      Path = GCCInstallDir;

   584 +      Path.append(P);

   585 +      Path.append("/");

   586 +

   587 +      if (llvm::sys::fs::exists(Path.c_str())) {

   588 +        GCCMajorMinor = P;

   589 +        break;

   590 +      }

   591 +    }

   592 +  }

   593 +}

   594 +

   595 +void

   596 +Solaris::findGCCMajorMinorMicro(const llvm::Triple& T) const {

   597 +  // FIXME: Add 5.X after testing the ABI.

   598 +  static const char* const GCCMMM[] = { "4.8.2", "4.9.3", "4.9.4" };

   599 +

   600 +  const char* P;

   601 +  std::string Path;

   602 +  std::string TripleString = llvm::sys::getDefaultTargetTriple();

   603 +  llvm::Triple::ArchType Arch = T.getArch();

   604 +

   605 +  // GCC4 on Solaris is multilib 32/64.

   606 +  // GCC5 (not supported here yet) on Solaris is multilib 64/32.

   607 +  if (GCCMajorMinor[0] == '4') {

   608 +    if (TripleString.find("x86_64") != std::string::npos)

   609 +      TripleString.replace(0U, 6U, std::string("i386"));

   610 +    else if (TripleString.find("sparcv9") != std::string::npos)

   611 +      TripleString.replace(0U, 7U, std::string("sparc"));

   612 +  }

   613 +

   614 +  Path.reserve(std::string::size_type(PATH_MAX));

   615 +

   616 +  for (int I = (llvm::array_lengthof(GCCMMM) - 1); I >= 0; --I) {

   617 +    if ((P = GCCMMM[I]) != NULL) {

   618 +      if ((P[0] == GCCMajorMinor[0]) && (P[2] == GCCMajorMinor[2])) {

   619 +        Path = GCCInstallDir;

   620 +        Path.append("/");

   621 +        Path.append(GCCMajorMinor);

   622 +        Path.append("/lib/gcc/");

   623 +        Path.append(TripleString);

   624 +        Path.append("/");

   625 +        Path.append(P);

   626 +

   627 +        if (llvm::sys::fs::exists(Path.c_str())) {

   628 +          std::string Test;

   629 +          // Check if this is a real GCC installation and not just

   630 +          // an empty directory tree

   631 +          switch (Arch) {

   632 +          case llvm::Triple::x86:

   633 +          case llvm::Triple::sparc:

   634 +            Test = Path + "/crtbegin.o";

   635 +            break;

   636 +          case llvm::Triple::x86_64:

   637 +            Test = Path + "/amd64/crtbegin.o";

   638 +            break;

   639 +          case llvm::Triple::sparcv9:

   640 +            Test = Path + "/sparcv9/crtbegin.o";

   641 +            break;

   642 +          default:

   643 +            break;

   644 +          }

   645 +

   646 +          if (llvm::sys::fs::exists(Test.c_str())) {

   647 +            GCCMajorMinorMicro = P;

   648 +            break;

   649 +          }

   650 +        }

   651 +      }

   652 +    }

   653 +  }

   654 +}

   655 +

   656 +void

   657 +Solaris::findSpecifiedGCCToolchain(const char *StartingPath,

   658 +                                   const llvm::Triple &Triple,

   659 +                                   const llvm::opt::ArgList &Args) const {

   660 +  DIR *TopLD = 0;

   661 +  DIR *LibLD = 0;

   662 +  DIR *GccLD = 0;

   663 +  DIR *TripleLD = 0;

   664 +  struct dirent *TopDE = 0;

   665 +  struct dirent *LibDE = 0;

   666 +  struct dirent *GccDE = 0;

   667 +  struct dirent *TripleDE = 0;

   668 +  std::string LibDir;

   669 +  std::string GccDir;

   670 +  std::string TripleDir;

   671 +  std::string TripleVersionDir;

   672 +  const char *DName;

   673 +

   674 +  assert(StartingPath && "Invalid GCC Toolchain starting search path!");

   675 +

   676 +  GCCMajorMinor = "";

   677 +  GCCMajorMinorMicro = "";

   678 +  UseSpecifiedGCCToolChainPath = false;

   679 +

   680 +  LibDir.reserve(std::string::size_type(PATH_MAX));

   681 +  GccDir.reserve(std::string::size_type(PATH_MAX));

   682 +  TripleDir.reserve(std::string::size_type(PATH_MAX));

   683 +  TripleVersionDir.reserve(std::string::size_type(PATH_MAX));

   684 +

   685 +  if (llvm::sys::fs::exists(StartingPath) &&

   686 +      llvm::sys::fs::is_directory(StartingPath)) {

   687 +    TopLD = opendir(StartingPath);

   688 +    assert(TopLD && "Cannot obtain a valid toplevel DIR handle!");

   689 +

   690 +    while ((TopDE = readdir(TopLD)) != NULL) {

   691 +      if (TopDE->d_name[0] == '.')

   692 +        continue;

   693 +

   694 +      DName = static_cast<const char*>(&TopDE->d_name[0]);

   695 +      if (std::strcmp(DName, "lib") == 0) {

   696 +        LibDir = StartingPath;

   697 +        LibDir.append("/");

   698 +        LibDir.append(DName);

   699 +

   700 +        if (!llvm::sys::fs::is_directory(LibDir.c_str()))

   701 +          continue;

   702 +

   703 +        LibLD = opendir(LibDir.c_str());

   704 +        assert(LibLD && "Could not obtain a valid lib DIR handle!");

   705 +

   706 +        while ((LibDE = readdir(LibLD)) != NULL) {

   707 +          if (LibDE->d_name[0] == '.')

   708 +            continue;

   709 +

   710 +          DName = static_cast<const char*>(&LibDE->d_name[0]);

   711 +          if (std::strcmp(DName, "gcc") == 0) {

   712 +            GccDir = LibDir;

   713 +            GccDir.append("/");

   714 +            GccDir.append(DName);

   715 +

   716 +            if (!llvm::sys::fs::is_directory(GccDir.c_str()))

   717 +              continue;

   718 +

   719 +            GccLD = opendir(GccDir.c_str());

   720 +            assert(GccLD && "Could not obtain a valid gcc DIR handle!");

   721 +

   722 +            while ((GccDE = readdir(GccLD)) != NULL) {

   723 +              if (GccDE->d_name[0] == '.')

   724 +                continue;

   725 +

   726 +              DName = static_cast<const char*>(&GccDE->d_name[0]);

   727 +              TripleDir = GccDir;

   728 +              TripleDir.append("/");

   729 +              TripleDir.append(DName);

   730 +

   731 +              if (!llvm::sys::fs::is_directory(TripleDir.c_str()))

   732 +                continue;

   733 +

   734 +              if ((std::strncmp(DName, "sparc", 5) == 0) ||

   735 +                  (std::strncmp(DName, "i386", 4) == 0) ||

   736 +                  (std::strncmp(DName, "sparcv9", 7) == 0) ||

   737 +                  (std::strncmp(DName, "x86_64", 6) == 0)) {

   738 +                TripleLD = opendir(TripleDir.c_str());

   739 +                assert(TripleLD &&

   740 +                       "Could not obtain a valid Triple DIR handle!");

   741 +

   742 +                while ((TripleDE = readdir(TripleLD)) != NULL) {

   743 +                  if (TripleDE->d_name[0] == '.')

   744 +                    continue;

   745 +

   746 +                  DName = static_cast<const char*>(&TripleDE->d_name[0]);

   747 +                  TripleVersionDir = TripleDir;

   748 +                  TripleVersionDir.append("/");

   749 +                  TripleVersionDir.append(DName);

   750 +

   751 +                  if (!llvm::sys::fs::is_directory(TripleVersionDir.c_str()))

   752 +                    continue;

   753 +

   754 +                  if ((std::isdigit(DName[0])) && (DName[1] == '.') &&

   755 +                      (std::isdigit(DName[2])) && (DName[3] == '.') &&

   756 +                      (std::isdigit(DName[4])) && (DName[5] == '\0')) {

   757 +                    GCCMajorMinorMicro = DName;

   758 +                    GCCMajorMinor = GCCMajorMinorMicro.substr(0, 3);

   759 +                    UseSpecifiedGCCToolChainPath = true;

   760 +                    goto done;

   761 +                  }

   762 +                }

   763 +              }

   764 +            }

   765 +          }

   766 +        }

   767 +      }

   768 +    }

   769 +  }

   770 +

   771 +done:

   772 +  if (TripleLD) {

   773 +    rewinddir(TripleLD);

   774 +    closedir(TripleLD);

   775 +  }

   776 +

   777 +  if (GccLD) {

   778 +    rewinddir(GccLD);

   779 +    closedir(GccLD);

   780 +  }

   781 +

   782 +  if (LibLD) {

   783 +    rewinddir(LibLD);

   784 +    closedir(LibLD);

   785 +  }

   786 +

   787 +  if (TopLD) {

   788 +    rewinddir(TopLD);

   789 +    closedir(TopLD);

   790 +  }

   791 +}

   792 +

   793 +void

   794 +Solaris::findGCCIncludeDirs(const llvm::Triple &Triple,

   795 +                            const llvm::opt::ArgList &Args) const {

   796 +  std::string GCCInstallPath;

   797 +  if (UseSpecifiedGCCToolChainPath)

   798 +    GCCInstallPath = GCCInstallDir;

   799 +  else

   800 +    GCCInstallPath = GCCInstallDir + GCCMajorMinor;

   801 +

   802 +  std::string GCCIncludeDir =

   803 +    GCCInstallPath + "/include/c++/" + GCCMajorMinorMicro;

   804 +  GCCIncludeDirs.push_back(GCCIncludeDir);

   805 +

   806 +  llvm::Triple::ArchType Arch = Triple.getArch();

   807 +  GCCIncludeDir += "/";

   808 +

   809 +  switch (Arch) {

   810 +  case llvm::Triple::x86:

   811 +    GCCIncludeDir += Triple.getTriple();

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

   813 +      GCCIncludeDir += "/amd64";

   814 +    break;

   815 +  case llvm::Triple::sparc:

   816 +    GCCIncludeDir += Triple.getTriple();

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

   818 +      GCCIncludeDir += "/sparcv9";

   819 +    break;

   820 +  case llvm::Triple::x86_64:

   821 +    GCCIncludeDir += "i386-pc-";

   822 +    GCCIncludeDir += Triple.getOSName();

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

   824 +      GCCIncludeDir += "/amd64";

   825 +    break;

   826 +  case llvm::Triple::sparcv9:

   827 +    GCCIncludeDir += "sparc-sun-";

   828 +    GCCIncludeDir += Triple.getOSName();

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

   830 +      GCCIncludeDir += "/sparcv9";

   831 +    break;

   832 +  default:

   833 +    getDriver().Diag(diag::err_target_unsupported_arch)

   834 +      << Triple.getArchName() << Triple.getTriple();

   835 +    break;

   836 +  }

   837 +

   838 +  GCCIncludeDirs.push_back(GCCIncludeDir);

   839 +

   840 +  GCCIncludeDir = GCCInstallPath + "/include/c++/" +

   841 +    GCCMajorMinorMicro + "/backward";

   842 +

   843 +  GCCIncludeDirs.push_back(GCCIncludeDir);

   844 +}

   845 +

   846 +void

   847 +Solaris::findGCCInternalLibDir(const llvm::Triple &Triple,

   848 +                               const llvm::opt::ArgList &Args) const {

   849 +  std::string GCCInstallPath;

   850 +  if (UseSpecifiedGCCToolChainPath)

   851 +    GCCInstallPath = GCCInstallDir;

   852 +  else

   853 +    GCCInstallPath = GCCInstallDir + GCCMajorMinor;

   854 +

   855 +  GCCInternalLibDir = GCCInstallPath + "/lib/gcc/";

   856 +

   857 +  llvm::Triple::ArchType Arch = Triple.getArch();

   858 +

   859 +  switch (Arch) {

   860 +  case llvm::Triple::x86:

   861 +    GCCInternalLibDir += Triple.getTriple();

   862 +    GCCInternalLibDir += "/";

   863 +    GCCInternalLibDir += GCCMajorMinorMicro;

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

   865 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   866 +      GCCInternalLibDir += "/amd64";

   867 +    } else if (Arg *A = Args.getLastArg(options::OPT_m32)) {

   868 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   869 +      GCCInternalMultiLibDir += "/amd64";

   870 +    } else {

   871 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   872 +      GCCInternalMultiLibDir += "/amd64";

   873 +    }

   874 +

   875 +    break;

   876 +  case llvm::Triple::sparc:

   877 +    GCCInternalLibDir += Triple.getTriple();

   878 +    GCCInternalLibDir += "/";

   879 +    GCCInternalLibDir += GCCMajorMinorMicro;

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

   881 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   882 +      GCCInternalLibDir += "/sparcv9";

   883 +    } else if (Arg *A = Args.getLastArg(options::OPT_m32)) {

   884 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   885 +      GCCInternalMultiLibDir += "/sparcv9";

   886 +    } else {

   887 +      GCCInternalMultiLibDir = GCCInternalLibDir;

   888 +      GCCInternalMultiLibDir += "/sparcv9";

   889 +    }

   890 +    break;

   891 +  case llvm::Triple::x86_64:

   892 +    GCCInternalLibDir += "i386-pc-";

   893 +    GCCInternalLibDir += Triple.getOSName();

   894 +    GCCInternalLibDir += "/";

   895 +    GCCInternalLibDir += GCCMajorMinorMicro;

   896 +    GCCInternalMultiLibDir = GCCInternalLibDir;

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

   898 +      GCCInternalLibDir += "/amd64";

   899 +    else if (Arg *A = Args.getLastArg(options::OPT_m32))

   900 +      GCCInternalMultiLibDir += "/amd64";

   901 +    else

   902 +      GCCInternalLibDir += "/amd64";

   903 +    break;

   904 +  case llvm::Triple::sparcv9:

   905 +    GCCInternalLibDir += "sparc-sun-";

   906 +    GCCInternalLibDir += Triple.getOSName();

   907 +    GCCInternalLibDir += "/";

   908 +    GCCInternalLibDir += GCCMajorMinorMicro;

   909 +    GCCInternalMultiLibDir = GCCInternalLibDir;

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

   911 +      GCCInternalLibDir += "/sparcv9";

   912 +    else if (Arg *A = Args.getLastArg(options::OPT_m32))

   913 +      GCCInternalMultiLibDir += "/sparcv9";

   914 +    else

   915 +      GCCInternalLibDir += "/sparcv9";

   916 +    break;

   917 +  default:

   918 +    getDriver().Diag(diag::err_target_unsupported_arch)

   919 +      << Triple.getArchName() << Triple.getTriple();

   920 +    break;

   921 +  }

   922 +}

   923 +

   924 +

   925 +void

   926 +Solaris::print(raw_ostream &OS) const {

   927 +  OS << "UseGnuAs: " << (UseGnuAs ? "true" : "false") << "\n";

   928 +  OS << "UseGnuLd: " << (UseGnuLd ? "true" : "false") << "\n";

   929 +  OS << "UseGoldLd: " << (UseGoldLd ? "true" : "false") << "\n";

   930 +  OS << "UseSunLd: " << (UseSunLd ? "true" : "false") << "\n";

   931 +  OS << "UseMediatedGCCToolChainPath: "

   932 +    << (UseMediatedGCCToolChainPath ? "true" : "false") << "\n";

   933 +  OS << "UseSpecifiedGCCToolChainPath: "

   934 +    << (UseSpecifiedGCCToolChainPath ? "true" : "false") << "\n";

   935 +  OS << "GCCInstallDir: " << GCCInstallDir.c_str() << "\n";

   936 +  OS << "GCCMajorMinor: " << GCCMajorMinor.c_str() << "\n";

   937 +  OS << "GCCMajorMinorMicro: " << GCCMajorMinorMicro.c_str() << "\n";

   938 +  OS << "GCCInternalLibDir: " << GCCInternalLibDir.c_str() << "\n";

   939 +  OS << "GCCInternalMultiLibDir: " << GCCInternalMultiLibDir.c_str() << "\n";

   940 +  OS << "GCCIncludeDirs: ";

   941 +

   942 +  if (GCCIncludeDirs.size()) {

   943 +    std::string IncludePath;

   944 +    for (std::vector<std::string>::const_iterator B = GCCIncludeDirs.begin(),

   945 +         E = GCCIncludeDirs.end(); B != E; ++B) {

   946 +      IncludePath = "-I";

   947 +      IncludePath += (*B);

   948 +      OS << IncludePath.c_str() << " ";

   949 +    }

   950 +

   951 +    OS << "\n";

   952 +  }

   953 +

   954 +  OS << "Assembler: " << Assembler.c_str() << "\n";

   955 +  OS << "Linker: " << Linker.c_str() << "\n";

   956 +  OS << "mtune: " << mtune.c_str() << "\n";

   957 +  OS << "march: " << march.c_str() << "\n";

   958 +  OS << "mcpu: " << mcpu.c_str() << "\n";

   959 +

   960 +  if (ExtraOpts.size()) {

   961 +    OS << "ExtraOpts: ";

   962 +    for (std::vector<std::string>::const_iterator B = ExtraOpts.begin(),

   963 +         E = ExtraOpts.end(); B != E; ++B) {

   964 +      OS << (*B).c_str() << " ";

   965 +    }

   966 +

   967 +    OS << "\n";

   968 +  }

   969 +

   970 +  OS << "Valid: " << (IsValid ? "true" : "false") << "\n";

   971 +}

   972 +

   973 +Tool *Solaris::buildAssembler() const {

   974 +  return new tools::solaris::Assembler(*this);

   975 +}

   976 +

   977 +Tool *Solaris::buildLinker() const {

   978 +  return new tools::solaris::Linker(*this);

   979 +}

   980 +

   981 +void Solaris::validate() {

   982 +  IsValid = llvm::sys::fs::exists(GCCInstallDir.c_str());

   983 +  if (!IsValid) return;

   984 +  IsValid = llvm::sys::fs::exists(GCCInternalLibDir.c_str());

   985 +  if (!IsValid) return;

   986 +  IsValid = llvm::sys::fs::exists(GCCInternalMultiLibDir.c_str());

   987 +  if (!IsValid) return;

   988 +

   989 +  for (std::vector<std::string>::const_iterator B = GCCIncludeDirs.begin(),

   990 +       E = GCCIncludeDirs.end(); B != E; ++B) {

   991 +    IsValid = llvm::sys::fs::exists((*B).c_str());

   992 +    if (!IsValid) return;

   993    }

   994  }

   995  

   996 @@ -3404,6 +4137,27 @@

   997    UbuntuVivid,

   998    UbuntuWily,

   999    UbuntuXenial,

  1000 +  Solaris_11,

  1001 +  Solaris_11_1,

  1002 +  Solaris_11_2,

  1003 +  Solaris_11_3,

  1004 +  Solaris_11_4,

  1005 +  Solaris_11_5,

  1006 +  Solaris_11_6,

  1007 +  Solaris_11_7,

  1008 +  Solaris_11_8,

  1009 +  Solaris_11_9,

  1010 +  Solaris_12,

  1011 +  Solaris_12_1,

  1012 +  Solaris_12_2,

  1013 +  Solaris_12_3,

  1014 +  Solaris_12_4,

  1015 +  Solaris_12_5,

  1016 +  Solaris_12_6,

  1017 +  Solaris_12_7,

  1018 +  Solaris_12_8,

  1019 +  Solaris_12_9,

  1020 +  Solaris_13,

  1021    UnknownDistro

  1022  };

  1023  

  1024 @@ -3421,6 +4175,10 @@

  1025    return Distro >= UbuntuHardy && Distro <= UbuntuXenial;

  1026  }

  1027  

  1028 +static bool IsSolaris(enum Distro Distro) {

  1029 +  return Distro >= Solaris_11 && Distro <= Solaris_13;

  1030 +}

  1031 +

  1032  static Distro DetectDistro(const Driver &D, llvm::Triple::ArchType Arch) {

  1033    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =

  1034        llvm::MemoryBuffer::getFile("/etc/lsb-release");

  1035 @@ -3488,6 +4246,59 @@

  1036      return UnknownDistro;

  1037    }

  1038  

  1039 +  File = llvm::MemoryBuffer::getFile("/etc/release");

  1040 +  if (File) {

  1041 +    StringRef Data = File.get()->getBuffer();

  1042 +    SmallVector<StringRef, 8> Lines;

  1043 +    Data.split(Lines, "\n");

  1044 +    for (unsigned I = 0, S = Lines.size(); I != S; ++I) {

  1045 +      if (Lines[I].find("Oracle Solaris") != std::string::npos) {

  1046 +        if (Lines[I].find("Solaris 11.0") != std::string::npos)

  1047 +          return Solaris_11;

  1048 +        else if (Lines[I].find("Solaris 11.1") != std::string::npos)

  1049 +          return Solaris_11_1;

  1050 +        else if (Lines[I].find("Solaris 11.2") != std::string::npos)

  1051 +          return Solaris_11_2;

  1052 +        else if (Lines[I].find("Solaris 11.3") != std::string::npos)

  1053 +          return Solaris_11_3;

  1054 +        else if (Lines[I].find("Solaris 11.4") != std::string::npos)

  1055 +          return Solaris_11_4;

  1056 +        else if (Lines[I].find("Solaris 11.5") != std::string::npos)

  1057 +          return Solaris_11_5;

  1058 +        else if (Lines[I].find("Solaris 11.6") != std::string::npos)

  1059 +          return Solaris_11_6;

  1060 +        else if (Lines[I].find("Solaris 11.7") != std::string::npos)

  1061 +          return Solaris_11_7;

  1062 +        else if (Lines[I].find("Solaris 11.8") != std::string::npos)

  1063 +          return Solaris_11_8;

  1064 +        else if (Lines[I].find("Solaris 11.9") != std::string::npos)

  1065 +          return Solaris_11_9;

  1066 +        else if (Lines[I].find("Solaris 12.0") != std::string::npos)

  1067 +          return Solaris_12;

  1068 +        else if (Lines[I].find("Solaris 12.1") != std::string::npos)

  1069 +          return Solaris_12_1;

  1070 +        else if (Lines[I].find("Solaris 12.2") != std::string::npos)

  1071 +          return Solaris_12_2;

  1072 +        else if (Lines[I].find("Solaris 12.3") != std::string::npos)

  1073 +          return Solaris_12_3;

  1074 +        else if (Lines[I].find("Solaris 12.4") != std::string::npos)

  1075 +          return Solaris_12_4;

  1076 +        else if (Lines[I].find("Solaris 12.5") != std::string::npos)

  1077 +          return Solaris_12_5;

  1078 +        else if (Lines[I].find("Solaris 12.6") != std::string::npos)

  1079 +          return Solaris_12_6;

  1080 +        else if (Lines[I].find("Solaris 12.7") != std::string::npos)

  1081 +          return Solaris_12_7;

  1082 +        else if (Lines[I].find("Solaris 12.8") != std::string::npos)

  1083 +          return Solaris_12_8;

  1084 +        else if (Lines[I].find("Solaris 12.9") != std::string::npos)

  1085 +          return Solaris_12_9;

  1086 +      }

  1087 +    }

  1088 +

  1089 +    return UnknownDistro;

  1090 +  }

  1091 +

  1092    if (D.getVFS().exists("/etc/SuSE-release"))

  1093      return OpenSUSE;

  1094  

  1095 ###

  1096 --- tools/clang/lib/Driver/ToolChains.h	2016-02-16 14:56:48.000000000 -0500

  1097 +++ tools/clang/lib/Driver/ToolChains.h	2016-05-08 23:19:20.571431701 -0400

  1098 @@ -615,24 +615,111 @@

  1099    Tool *buildLinker() const override;

  1100  };

  1101  

  1102 -class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {

  1103 +class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_ELF {

  1104  public:

  1105    Solaris(const Driver &D, const llvm::Triple &Triple,

  1106            const llvm::opt::ArgList &Args);

  1107  

  1108 -  bool IsIntegratedAssemblerDefault() const override { return true; }

  1109 +  bool IsIntegratedAssemblerDefault() const override { return !UseGnuAs; }

  1110  

  1111 -  void AddClangCXXStdlibIncludeArgs(

  1112 -      const llvm::opt::ArgList &DriverArgs,

  1113 -      llvm::opt::ArgStringList &CC1Args) const override;

  1114 +  std::string computeSysRoot() const;

  1115  

  1116 -  unsigned GetDefaultDwarfVersion() const override { return 2; }

  1117 +  bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,

  1118 +                                StringRef GCCTriple,

  1119 +                                StringRef GCCMultiarchTriple,

  1120 +                                StringRef TargetMultiarchTriple,

  1121 +                                Twine IncludeSuffix,

  1122 +                                const llvm::opt::ArgList &DriverArgs,

  1123 +                                llvm::opt::ArgStringList &CC1Args) const;

  1124 +

  1125 +  void addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,

  1126 +                                const llvm::opt::ArgList &DriverArgs,

  1127 +                                llvm::opt::ArgStringList &CC1Args) const;

  1128 +

  1129 +  void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,

  1130 +                                    llvm::opt::ArgStringList &CC1Args) const override;

  1131 +

  1132 +  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,

  1133 +                                 llvm::opt::ArgStringList &CC1Args) const override;

  1134 +

  1135 +  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,