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

# 23854357 clang should check for GNU ld

# 22778650 clang should support OpenMP because it can

# 24314745 clang should support PIE executables in Solaris

# 24378340 clang -fopenmp must include the path to the omp.h header file

# 24378393 clang -fopenmp must define _OPENMP to 201307

# 3.9.X for upstream.

--- tools/clang/include/clang/Driver/Options.td	2016-01-06 13:27:42.000000000 -0800

+++ tools/clang/include/clang/Driver/Options.td	2016-07-30 10:18:25.039779680 -0700

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

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

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

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

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

+

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

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

@@ -959,11 +962,17 @@

 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;

 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;

-def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;

-def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;

-def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;

-def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>, Flags<[NoArgumentUnused]>;

-def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;

+def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>,

+              Flags<[CC1Option]>, HelpText<"Enable OpenMP">;

+def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>,

+                 Flags<[CC1Option]>, HelpText<"Disable OpenMP">;

+def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>,

+                 Flags<[CC1Option]>,

+                 HelpText<"Use specified OpenMP Implementation">;

+def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>,

+                      Flags<[CC1Option]>, HelpText<"Use OpenMP TLS">;

+def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>,

+                        Flags<[CC1Option]>, HelpText<"Do not use OpenMP TLS">;

 def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>;

 def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>;

 def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">;

@@ -1312,6 +1321,12 @@

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

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

+// SPARC-only options.

+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>;

@@ -1954,6 +1969,7 @@

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

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

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

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

###

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

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

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

 }

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

-  SmallString<128> GCCSuffix;

+  SmallString<PATH_MAX> GCCSuffix;

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

-  SmallString<128> OSSuffix;

+  SmallString<PATH_MAX> OSSuffix;

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

-  SmallString<128> IncludeSuffix;

+  SmallString<PATH_MAX> IncludeSuffix;

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

                           New.includeSuffix());

###

--- tools/clang/lib/Driver/ToolChains.cpp	2016-02-16 11:56:48.000000000 -0800

+++ tools/clang/lib/Driver/ToolChains.cpp	2016-08-04 06:09:44.734198665 -0700

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

 #include "llvm/ProfileData/InstrProf.h"

 #include "llvm/Support/ErrorHandling.h"

 #include "llvm/Support/FileSystem.h"

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

 #include "llvm/Support/MemoryBuffer.h"

 #include "llvm/Support/Path.h"

 #include "llvm/Support/Program.h"

 #include "llvm/Support/TargetParser.h"

 #include "llvm/Support/raw_ostream.h"

 #include <cstdlib> // ::getenv

+#include <cstring>

+#include <cctype>

 #include <system_error>

 using namespace clang::driver;

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

 using namespace clang;

 using namespace llvm::opt;

+#if defined(LLVM_ON_UNIX)

+#include <cstring>

+#include <cctype>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <dirent.h>

+#include <unistd.h>

+#endif

+

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

     : ToolChain(D, Triple, Args) {

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

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

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

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

       Prefixes.push_back(D.SysRoot);

+

+      // Add Solaris-specific GCC locations.

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

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

+

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

     }

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

   static const char *const ARMebHFTriples[] = {

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

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

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

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

   static const char *const X86_64Triples[] = {

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

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

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

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

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

-      "x86_64-unknown-linux"};

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

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

+

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

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

   static const char *const X86Triples[] = {

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

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

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

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

-      "i586-linux-gnu"};

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

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

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

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

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

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

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

-                                               "sparcv8-linux-gnu"};

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

+                                               "sparcv8-linux-gnu",

+                                               "sparc-sun-solaris2.11",

+                                               "sparc-sun-solaris2.12",

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

+

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

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

+

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

-                                               "sparcv9-linux-gnu"};

+                                               "sparcv9-linux-gnu",

+                                               "sparcv9-sun-solaris2.11",

+                                               "sparcv9-sun-solaris2.12",

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

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

   static const char *const SystemZTriples[] = {

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

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

-  // Solaris.

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

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

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

-

   using std::begin;

   using std::end;

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

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

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

-    return;

-  }

-

   switch (TargetTriple.getArch()) {

   case llvm::Triple::aarch64:

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

 }

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

+bool Solaris::SupportsClangLibCPlusPlus = false;

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

-                 const ArgList &Args)

-    : Generic_GCC(D, Triple, Args) {

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

+  : Generic_ELF(D, Triple, Args),

+  UseGnuAs(true),

+  UseGnuLd(false),

+  UseGoldLd(false),

+  UseSunLd(true),

+  UseMediatedGCCToolChainPath(false),

+  UseSpecifiedGCCToolChainPath(false),

+  IsValid(false),

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

+  GCCMajorMinorMicro(""),

+  GCCInternalLibDir(""),

+  GCCInternalMultiLibDir(""),

+  GCCIncludeDirs(),

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

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

+  mtune(""),

+  march(""),

+  mcpu(""),

+  ExtraOpts() {

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

+      GCCInstallDir = A->getValue();

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

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

+      else {

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

+

+        if (!UseSpecifiedGCCToolChainPath) {

+          D.Diag(diag::err_drv_unsupported_rtlib_for_platform)

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

+        } else {

+          findGCCIncludeDirs(Triple, Args);

+          findGCCInternalLibDir(Triple, Args);

+        }

+      }

+    } else {

+      findGCCMajorMinorMicro(Triple);

+      findGCCIncludeDirs(Triple, Args);

+      findGCCInternalLibDir(Triple, Args);

+    }

+

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

+      Linker = A->getValue();

+      if (Linker == "bfd")

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

+      else if (Linker == "gold")

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

+

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

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

+        UseGnuLd = true;

+        UseGoldLd = false;

+        UseSunLd = false;

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

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

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

+        UseGnuLd = false;

+        UseSunLd = false;

+        UseGoldLd = true;

+      }

+    }

-  GCCInstallation.init(Triple, Args);

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

+      Assembler = A->getValue();

+      if (Assembler == "llvm")

+        UseGnuAs = false;

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

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

+        UseGnuAs = true;

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

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

+        UseGnuAs = true;

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

+                 (Assembler == "solaris"))

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

+    }

-  path_list &Paths = getFilePaths();

-  if (GCCInstallation.isValid())

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

+    getProgramPaths().push_back(GCCInstallDir);

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

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

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

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

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

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

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

-  switch (Triple.getArch()) {

+    switch (Arch) {

   case llvm::Triple::x86:

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

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

+      march = mtune = "i686";

+      break;

   case llvm::Triple::sparc:

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

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

+      mcpu = "ultrasparc";

+      mtune = "ultrasparc";

+      march = "v8plusa";

     break;

   case llvm::Triple::x86_64:

-    LibPath += "amd64/";

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

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

+      march = mtune = "opteron";

     break;

   case llvm::Triple::sparcv9:

-    LibPath += "sparcv9/";

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

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

+      mcpu = "ultrasparc";

+      mtune = "ultrasparc";

+      march = "v9a";

     break;

   default:

-    llvm_unreachable("Unsupported architecture");

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

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

+      break;

   }

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

+    validate();

+

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

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

 }

-Tool *Solaris::buildAssembler() const {

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

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

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

+    return getDriver().SysRoot;

+

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

 }

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

+bool

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

+                                  StringRef GCCTriple,

+                                  StringRef GCCMultiarchTriple,

+                                  StringRef TargetMultiarchTriple,

+                                  Twine IncludeSuffix,

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

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

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

+    return false;

+

+  addSystemInclude(DriverArgs, CC1Args, Base);

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

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

-                                           ArgStringList &CC1Args) const {

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

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

+    addSystemInclude(DriverArgs,

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

+  } else {

+    addSystemInclude(DriverArgs, CC1Args,

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

+    addSystemInclude(DriverArgs, CC1Args,

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

+  }

+

+  if (DriverArgs.hasArg(options::OPT_fopenmp) ||

+      DriverArgs.hasArg(options::OPT_fopenmp_EQ)) {

+    addSystemInclude(DriverArgs, CC1Args, "/usr/include/iomp5");

+  }

+

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

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

+  return true;

+}

+

+void

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

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

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

       DriverArgs.hasArg(options::OPT_nostdincxx))

     return;

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

-  // headers.

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

+  const Driver &D = getDriver();

-  if (GCCInstallation.isValid()) {

-    GCCVersion Version = GCCInstallation.getVersion();

-    addSystemInclude(DriverArgs, CC1Args,

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

-                     Version.MajorStr + "." +

-                     Version.MinorStr +

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

-    addSystemInclude(DriverArgs, CC1Args,

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

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

-                     Version.Text + "/" +

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

+  // Check for Clang libc++

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

+    if (!Solaris::SupportsClangLibCPlusPlus) {

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

+      return;

+    }

+

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

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

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

+      return;

+    }

+

+    addSystemInclude(DriverArgs, CC1Args, IncludePath);

+    return;

+  }

+

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

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

+       B != E; ++B) {

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

+    addSystemInclude(DriverArgs, CC1Args, IncludePath);

+  }

+}

+

+void

+Solaris::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

+                                   ArgStringList &CC1Args) const {

+  const Driver &D = getDriver();

+

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

+    return;

+

+  std::string SysRoot = computeSysRoot();

+

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

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

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

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

+  }

+

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

+    return;

+

+  StringRef CIncludeDirs(C_INCLUDE_DIRS);

+  if (CIncludeDirs != "") {

+    SmallVector<StringRef, 5> dirs;

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

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

+         I != E; ++I) {

+      StringRef Prefix =

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

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

+    }

+  }

+

+  if (DriverArgs.hasArg(options::OPT_fopenmp) ||

+      DriverArgs.hasArg(options::OPT_fopenmp_EQ))

+    addSystemInclude(DriverArgs, CC1Args, "/usr/include/iomp5");

+

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

+}

+

+void

+Solaris::addClangTargetOptions(const ArgList &DriverArgs,

+                               ArgStringList &CC1Args) const {

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

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

+

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

+    DriverArgs.ClaimAllArgs(options::OPT_fuse_init_array);

+

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

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

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

+

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

+    StringRef V = A->getValue();

+    if (!V.empty()) {

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

+      fabi_version += V.str();

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

+    } else {

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

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

+    }

+  } else {

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

+  }

+

+  DriverArgs.ClaimAllArgs(options::OPT_fabi_version_EQ);

+

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

+    CC1Args.push_back(DriverArgs.MakeArgString("-fopenmp"));

+

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

+    CC1Args.push_back(DriverArgs.MakeArgString("-fno-openmp"));

+

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

+    std::string V = A->getValue();

+    if (V != "libiomp5") {

+      const Driver &D = getDriver();

+      D.Diag(diag::err_drv_unsupported_opt) << V.c_str();

+    }

+