Use LLVM headers for shared codegen command-line options

I.e., llvm/CodeGen/CommandFlags.h which in turn includes
llvm/MC/MCTargetOptionsCommandFlags.h.

This gets rid of a few duplicates on our side and includes about 35
(depending on LLVM version) new command-line options. LLVM provides a
helper function to set up the TargetOptions according to (most of) these
options.
Newer LLVM versions may add new options and we'll automatically inherit
them, including setting up the TargetOptions accordingly.

I did my best (TM) to remove a few unused/undesirable options and hide all
remaining new ones except for `-fp-contract`. The lists will need to be
tweaked from time to time.

Author: kinke

CMakeLists.txt

@@ -333,6 +333,7 @@ file(GLOB IR_HDR ir/*.h)
 set(DRV_SRC
     driver/cache.cpp
     driver/cl_options.cpp
+    driver/cl_options-llvm.cpp
     driver/codegenerator.cpp
     driver/configfile.cpp
     driver/dcomputecodegenerator.cpp
@@ -349,6 +350,7 @@ set(DRV_HDR
     driver/cache.h
     driver/cache_pruning.h
     driver/cl_options.h
+    driver/cl_options-llvm.h
     driver/codegenerator.h
     driver/configfile.h
     driver/dcomputecodegenerator.h

driver/cache.cpp

@@ -300,14 +300,18 @@ void outputIR2ObjRelevantCmdlineArgs(llvm::raw_ostream &hash_os) {
   // the possibility of different default settings on different platforms (while
   // sharing the cache).
   outputOptimizationSettings(hash_os);
-  hash_os << opts::mCPU;
-  for (auto &attr : opts::mAttrs) {
-    hash_os << attr;
-  }
-  hash_os << opts::mFloatABI;
-  hash_os << opts::mRelocModel;
-  hash_os << opts::mCodeModel;
-  hash_os << opts::disableFpElim;
+  hash_os << opts::getCPUStr();
+  hash_os << opts::getFeaturesStr();
+  hash_os << opts::floatABI;
+#if LDC_LLVM_VER >= 309
+  const auto relocModel = opts::getRelocModel();
+  if (relocModel.hasValue())
+    hash_os << relocModel.getValue();
+#else
+  hash_os << opts::getRelocModel();
+#endif
+  hash_os << opts::getCodeModel();
+  hash_os << opts::disableFPElim();
 }
 
 // Output to `hash_os` all environment flags that influence object code output

driver/cl_options-llvm.cpp

@@ -0,0 +1,82 @@
+//===-- cl_options-llvm.cpp -----------------------------------------------===//
+//
+//                         LDC – the LLVM D compiler
+//
+// This file is distributed under the BSD-style LDC license. See the LICENSE
+// file for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "driver/cl_options-llvm.h"
+
+#if LDC_LLVM_VER < 307
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Support/Host.h"
+#endif
+
+// Pull in command-line options and helper functions from special LLVM header
+// shared by multiple LLVM tools.
+#include "llvm/CodeGen/CommandFlags.h"
+
+// Now expose the helper functions (with static linkage) via external wrappers
+// in the opts namespace, including some additional helper functions.
+namespace opts {
+
+std::string getArchStr() { return ::MArch; }
+
+#if LDC_LLVM_VER >= 309
+Optional<Reloc::Model> getRelocModel() { return ::getRelocModel(); }
+#else
+Reloc::Model getRelocModel() { return ::RelocModel; }
+#endif
+
+CodeModel::Model getCodeModel() { return ::CMModel; }
+
+bool disableFPElim() { return ::DisableFPElim; }
+
+bool printTargetFeaturesHelp() {
+  if (MCPU == "help")
+    return true;
+  return std::any_of(MAttrs.begin(), MAttrs.end(),
+                     [](const std::string &a) { return a == "help"; });
+}
+
+TargetOptions InitTargetOptionsFromCodeGenFlags() {
+  return ::InitTargetOptionsFromCodeGenFlags();
+}
+
+#if LDC_LLVM_VER >= 307
+std::string getCPUStr() { return ::getCPUStr(); }
+std::string getFeaturesStr() { return ::getFeaturesStr(); }
+#else
+std::string getCPUStr() {
+  // If user asked for the 'native' CPU, autodetect here. If autodection fails,
+  // this will set the CPU to an empty string which tells the target to
+  // pick a basic default.
+  if (MCPU == "native")
+    return sys::getHostCPUName();
+
+  return MCPU;
+}
+
+std::string getFeaturesStr() {
+  SubtargetFeatures Features;
+
+  // If user asked for the 'native' CPU, we need to autodetect features.
+  // This is necessary for x86 where the CPU might not support all the
+  // features the autodetected CPU name lists in the target. For example,
+  // not all Sandybridge processors support AVX.
+  if (MCPU == "native") {
+    StringMap<bool> HostFeatures;
+    if (sys::getHostCPUFeatures(HostFeatures))
+      for (auto &F : HostFeatures)
+        Features.AddFeature(F.first(), F.second);
+  }
+
+  for (unsigned i = 0; i != MAttrs.size(); ++i)
+    Features.AddFeature(MAttrs[i]);
+
+  return Features.getString();
+}
+#endif // LDC_LLVM_VER < 307
+}

driver/cl_options-llvm.h

@@ -0,0 +1,35 @@
+//===-- driver/cl_options-llvm.h - LLVM command line options ----*- C++ -*-===//
+//
+//                         LDC – the LLVM D compiler
+//
+// This file is distributed under the BSD-style LDC license. See the LICENSE
+// file for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LDC_DRIVER_CL_OPTIONS_LLVM_H
+#define LDC_DRIVER_CL_OPTIONS_LLVM_H
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Target/TargetOptions.h"
+
+namespace opts {
+
+std::string getArchStr();
+#if LDC_LLVM_VER >= 309
+llvm::Optional<llvm::Reloc::Model> getRelocModel();
+#else
+llvm::Reloc::Model getRelocModel();
+#endif
+llvm::CodeModel::Model getCodeModel();
+bool disableFPElim();
+bool printTargetFeaturesHelp();
+
+llvm::TargetOptions InitTargetOptionsFromCodeGenFlags();
+std::string getCPUStr();
+std::string getFeaturesStr();
+}
+
+#endif

driver/cl_options.cpp

@@ -132,10 +132,6 @@ static cl::opt<ubyte, true> debugInfo(
         clEnumValN(3, "gline-tables-only", "Add line tables only")),
     cl::location(global.params.symdebug), cl::init(0));
 
-static cl::opt<unsigned, true>
-    dwarfVersion("dwarf-version", cl::desc("Dwarf version"), cl::ZeroOrMore,
-                 cl::location(global.params.dwarfVersion), cl::Hidden);
-
 cl::opt<bool> noAsm("noasm", cl::desc("Disallow use of inline assembler"),
                     cl::ZeroOrMore);
 
@@ -294,21 +290,10 @@ cl::opt<std::string>
                         "'-deps' alone prints module dependencies "
                         "(imports/file/version/debug/lib)"));
 
-cl::opt<std::string> mArch("march", cl::ZeroOrMore,
-                           cl::desc("Architecture to generate code for:"));
-
 cl::opt<bool> m32bits("m32", cl::desc("32 bit target"), cl::ZeroOrMore);
 
 cl::opt<bool> m64bits("m64", cl::desc("64 bit target"), cl::ZeroOrMore);
 
-cl::opt<std::string>
-    mCPU("mcpu", cl::ZeroOrMore, cl::value_desc("cpu-name"), cl::init(""),
-         cl::desc("Target a specific cpu type (-mcpu=help for details)"));
-
-cl::list<std::string>
-    mAttrs("mattr", cl::CommaSeparated, cl::value_desc("a1,+a2,-a3,..."),
-           cl::desc("Target specific attributes (-mattr=help for details)"));
-
 cl::opt<std::string> mTargetTriple("mtriple", cl::ZeroOrMore,
                                    cl::desc("Override target triple"));
 
@@ -325,49 +310,7 @@ static cl::list<std::string, StringsAdapter> modFileAliasStrings(
     cl::value_desc("<package.module>=<filespec>"),
     cl::location(modFileAliasStringsStore));
 
-cl::opt<llvm::Reloc::Model> mRelocModel(
-    "relocation-model", cl::desc("Relocation model"), cl::ZeroOrMore,
-#if LDC_LLVM_VER < 309
-    cl::init(llvm::Reloc::Default),
-#endif
-    clEnumValues(
-#if LDC_LLVM_VER < 309
-        clEnumValN(llvm::Reloc::Default, "default",
-                   "Target default relocation model"),
-#endif
-        clEnumValN(llvm::Reloc::Static, "static", "Non-relocatable code"),
-        clEnumValN(llvm::Reloc::PIC_, "pic",
-                   "Fully relocatable, position independent code"),
-        clEnumValN(llvm::Reloc::DynamicNoPIC, "dynamic-no-pic",
-                   "Relocatable external references, non-relocatable code")));
-
-cl::opt<llvm::CodeModel::Model> mCodeModel(
-    "code-model", cl::desc("Code model"), cl::ZeroOrMore,
-    cl::init(llvm::CodeModel::Default),
-    clEnumValues(
-        clEnumValN(llvm::CodeModel::Default, "default",
-                   "Target default code model"),
-        clEnumValN(llvm::CodeModel::Small, "small", "Small code model"),
-        clEnumValN(llvm::CodeModel::Kernel, "kernel", "Kernel code model"),
-        clEnumValN(llvm::CodeModel::Medium, "medium", "Medium code model"),
-        clEnumValN(llvm::CodeModel::Large, "large", "Large code model")));
-
-cl::opt<FloatABI::Type> mFloatABI(
-    "float-abi", cl::desc("ABI/operations to use for floating-point types:"),
-    cl::ZeroOrMore, cl::init(FloatABI::Default),
-    clEnumValues(
-        clEnumValN(FloatABI::Default, "default",
-                   "Target default floating-point ABI"),
-        clEnumValN(FloatABI::Soft, "soft",
-                   "Software floating-point ABI and operations"),
-        clEnumValN(FloatABI::SoftFP, "softfp",
-                   "Soft-float ABI, but hardware floating-point instructions"),
-        clEnumValN(FloatABI::Hard, "hard",
-                   "Hardware floating-point ABI and instructions")));
-
-cl::opt<bool>
-    disableFpElim("disable-fp-elim", cl::ZeroOrMore,
-                  cl::desc("Disable frame pointer elimination optimization"));
+FloatABI::Type floatABI; // Storage for the dynamically created float-abi option.
 
 static cl::opt<bool, true, FlagParser<bool>>
     asserts("asserts", cl::ZeroOrMore, cl::desc("(*) Enable assertions"),
@@ -432,12 +375,10 @@ cl::opt<bool> disableLinkerStripDead(
 // Math options
 bool fFastMath; // Storage for the dynamically created ffast-math option.
 llvm::FastMathFlags defaultFMF;
-void setDefaultMathOptions(llvm::TargetMachine &target) {
+void setDefaultMathOptions(llvm::TargetOptions &targetOptions) {
   if (fFastMath) {
     defaultFMF.setUnsafeAlgebra();
-
-    llvm::TargetOptions &TO = target.Options;
-    TO.UnsafeFPMath = true;
+    targetOptions.UnsafeFPMath = true;
   }
 }
 
@@ -555,13 +496,27 @@ void createClashingOptions() {
   // is a clash in the command line options.
   renameAndHide("color", "llvm-color");
   renameAndHide("ffast-math", "llvm-ffast-math");
+  renameAndHide("float-abi", "llvm-float-abi");
 
   // Step 2. Add the LDC options.
   new cl::opt<bool, true, FlagParser<bool>>(
       "color", cl::ZeroOrMore, cl::location(global.params.color),
       cl::desc("(*) Force colored console output"));
   new cl::opt<bool, true>("ffast-math", cl::ZeroOrMore, cl::location(fFastMath),
                           cl::desc("Set @fastmath for all functions."));
+  new cl::opt<FloatABI::Type, true>(
+      "float-abi", cl::desc("ABI/operations to use for floating-point types:"),
+      cl::ZeroOrMore, cl::location(floatABI), cl::init(FloatABI::Default),
+      clEnumValues(
+          clEnumValN(FloatABI::Default, "default",
+                     "Target default floating-point ABI"),
+          clEnumValN(FloatABI::Soft, "soft",
+                     "Software floating-point ABI and operations"),
+          clEnumValN(
+              FloatABI::SoftFP, "softfp",
+              "Soft-float ABI, but hardware floating-point instructions"),
+          clEnumValN(FloatABI::Hard, "hard",
+                     "Hardware floating-point ABI and instructions")));
 }
 
 /// Hides command line options exposed from within LLVM that are unlikely
@@ -595,6 +550,15 @@ void hideLLVMOptions() {
       "verify-region-info", "verify-scev", "verify-scev-maps",
       "x86-early-ifcvt", "x86-use-vzeroupper", "x86-recip-refinement-steps",
 
+      "thread-model", "exception-model", "enable-fp-mad",
+      "enable-unsafe-fp-math", "enable-no-infs-fp-math",
+      "enable-no-nans-fp-math", "enable-no-trapping-fp-math",
+      "denormal-fp-math", "recip", "nozero-initialized-in-bss", "tailcallopt",
+      "stack-symbol-ordering", "stack-alignment", "use-ctors", "emulated-tls",
+      "unique-section-names", "jump-table-type", "meabi", "debugger-tune",
+      "asm-instrumentation", "mc-relax-all", "incremental-linker-compatible",
+      "asm-show-inst",
+
       // We enable -fdata-sections/-ffunction-sections by default where it makes
       // sense for reducing code size, so hide them to avoid confusion.
       //
@@ -603,7 +567,19 @@ void hideLLVMOptions() {
       // on the target triple (and thus we do not know it until after the
       // command
       // line has been parsed).
-      "fdata-sections", "ffunction-sections"};
+      "fdata-sections", "ffunction-sections", "data-sections",
+      "function-sections"};
+
+  // pulled in from shared LLVM headers, but unused or not desired in LDC
+  static const char *const removedOptions[] = {"disable-tail-calls",
+                                               "fatal-warnings",
+                                               "filetype",
+                                               "no-warn",
+                                               "stackrealign",
+                                               "start-after",
+                                               "stop-after",
+                                               "trap-func",
+                                               "W"};
 
 #if LDC_LLVM_VER >= 307
   llvm::StringMap<cl::Option *> &map = cl::getRegisteredOptions();
@@ -620,6 +596,13 @@ void hideLLVMOptions() {
       it->second->setHiddenFlag(cl::Hidden);
     }
   }
+
+  for (const auto name : removedOptions) {
+    auto it = map.find(name);
+    if (it != map.end()) {
+      map.erase(it);
+    }
+  }
 }
 
 } // namespace opts

driver/cl_options.h

@@ -15,6 +15,7 @@
 #ifndef LDC_DRIVER_CL_OPTIONS_H
 #define LDC_DRIVER_CL_OPTIONS_H
 
+#include "driver/cl_options-llvm.h"
 #include "driver/targetmachine.h"
 #include "gen/cl_helpers.h"
 #include "llvm/ADT/SmallVector.h"
@@ -69,26 +70,20 @@ extern cl::opt<std::string> cacheDir;
 extern cl::list<std::string> linkerSwitches;
 extern cl::list<std::string> ccSwitches;
 
-extern cl::opt<std::string> mArch;
 extern cl::opt<bool> m32bits;
 extern cl::opt<bool> m64bits;
-extern cl::opt<std::string> mCPU;
-extern cl::list<std::string> mAttrs;
 extern cl::opt<std::string> mTargetTriple;
 #if LDC_LLVM_VER >= 307
 extern cl::opt<std::string> mABI;
 #endif
-extern cl::opt<llvm::Reloc::Model> mRelocModel;
-extern cl::opt<llvm::CodeModel::Model> mCodeModel;
-extern cl::opt<bool> disableFpElim;
-extern cl::opt<FloatABI::Type> mFloatABI;
+extern FloatABI::Type floatABI;
 extern cl::opt<bool> linkonceTemplates;
 extern cl::opt<bool> disableLinkerStripDead;
 
 // Math options
 extern bool fFastMath;
 extern llvm::FastMathFlags defaultFMF;
-void setDefaultMathOptions(llvm::TargetMachine &target);
+void setDefaultMathOptions(llvm::TargetOptions &targetOptions);
 
 extern cl::opt<BOUNDSCHECK> boundsCheck;
 extern bool nonSafeBoundsChecks;

driver/linker.cpp

@@ -165,8 +165,9 @@ void addLTOGoldPluginFlags(std::vector<std::string> &args) {
   if (opts::isUsingThinLTO())
     addLinkerFlag(args, "-plugin-opt=thinlto");
 
-  if (!opts::mCPU.empty())
-    addLinkerFlag(args, llvm::Twine("-plugin-opt=mcpu=") + opts::mCPU);
+  const auto cpu = gTargetMachine->getTargetCPU();
+  if (!cpu.empty())
+    addLinkerFlag(args, llvm::Twine("-plugin-opt=mcpu=") + cpu);
 
   // Use the O-level passed to LDC as the O-level for LTO, but restrict it to
   // the [0, 3] range that can be passed to the linker plugin.