Update prebuilt Clang to r353983e.HEADq10.0

clang 9.0.5 (based on r353983e) from build 5696680.

Bug: http://b/135931688
Bug: http://b/136008926
Test: N/A
Change-Id: I922d17410047d2e2df4625615352c588ee71b203

18 files changed, 6955 insertions, 0 deletions

diff --git a/clang-r353983e/include/clang/Driver/Action.h b/clang-r353983e/include/clang/Driver/Action.h
new file mode 100644
index 00000000..c1ff0b1a
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Action.h
@@ -0,0 +1,619 @@
+//===- Action.h - Abstract compilation steps --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_ACTION_H
+#define LLVM_CLANG_DRIVER_ACTION_H
+
+#include "clang/Basic/LLVM.h"
+#include "clang/Driver/Types.h"
+#include "clang/Driver/Util.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include <string>
+
+namespace llvm {
+namespace opt {
+
+class Arg;
+
+} // namespace opt
+} // namespace llvm
+
+namespace clang {
+namespace driver {
+
+class ToolChain;
+
+/// Action - Represent an abstract compilation step to perform.
+///
+/// An action represents an edge in the compilation graph; typically
+/// it is a job to transform an input using some tool.
+///
+/// The current driver is hard wired to expect actions which produce a
+/// single primary output, at least in terms of controlling the
+/// compilation. Actions can produce auxiliary files, but can only
+/// produce a single output to feed into subsequent actions.
+///
+/// Actions are usually owned by a Compilation, which creates new
+/// actions via MakeAction().
+class Action {
+public:
+  using size_type = ActionList::size_type;
+  using input_iterator = ActionList::iterator;
+  using input_const_iterator = ActionList::const_iterator;
+  using input_range = llvm::iterator_range<input_iterator>;
+  using input_const_range = llvm::iterator_range<input_const_iterator>;
+
+  enum ActionClass {
+    InputClass = 0,
+    BindArchClass,
+    OffloadClass,
+    PreprocessJobClass,
+    PrecompileJobClass,
+    HeaderModulePrecompileJobClass,
+    AnalyzeJobClass,
+    MigrateJobClass,
+    CompileJobClass,
+    BackendJobClass,
+    AssembleJobClass,
+    LinkJobClass,
+    LipoJobClass,
+    DsymutilJobClass,
+    VerifyDebugInfoJobClass,
+    VerifyPCHJobClass,
+    OffloadBundlingJobClass,
+    OffloadUnbundlingJobClass,
+
+    JobClassFirst = PreprocessJobClass,
+    JobClassLast = OffloadUnbundlingJobClass
+  };
+
+  // The offloading kind determines if this action is binded to a particular
+  // programming model. Each entry reserves one bit. We also have a special kind
+  // to designate the host offloading tool chain.
+  enum OffloadKind {
+    OFK_None = 0x00,
+
+    // The host offloading tool chain.
+    OFK_Host = 0x01,
+
+    // The device offloading tool chains - one bit for each programming model.
+    OFK_Cuda = 0x02,
+    OFK_OpenMP = 0x04,
+    OFK_HIP = 0x08,
+  };
+
+  static const char *getClassName(ActionClass AC);
+
+private:
+  ActionClass Kind;
+
+  /// The output type of this action.
+  types::ID Type;
+
+  ActionList Inputs;
+
+  /// Flag that is set to true if this action can be collapsed with others
+  /// actions that depend on it. This is true by default and set to false when
+  /// the action is used by two different tool chains, which is enabled by the
+  /// offloading support implementation.
+  bool CanBeCollapsedWithNextDependentAction = true;
+
+protected:
+  ///
+  /// Offload information.
+  ///
+
+  /// The host offloading kind - a combination of kinds encoded in a mask.
+  /// Multiple programming models may be supported simultaneously by the same
+  /// host.
+  unsigned ActiveOffloadKindMask = 0u;
+
+  /// Offloading kind of the device.
+  OffloadKind OffloadingDeviceKind = OFK_None;
+
+  /// The Offloading architecture associated with this action.
+  const char *OffloadingArch = nullptr;
+
+  Action(ActionClass Kind, types::ID Type) : Action(Kind, ActionList(), Type) {}
+  Action(ActionClass Kind, Action *Input, types::ID Type)
+      : Action(Kind, ActionList({Input}), Type) {}
+  Action(ActionClass Kind, Action *Input)
+      : Action(Kind, ActionList({Input}), Input->getType()) {}
+  Action(ActionClass Kind, const ActionList &Inputs, types::ID Type)
+      : Kind(Kind), Type(Type), Inputs(Inputs) {}
+
+public:
+  virtual ~Action();
+
+  const char *getClassName() const { return Action::getClassName(getKind()); }
+
+  ActionClass getKind() const { return Kind; }
+  types::ID getType() const { return Type; }
+
+  ActionList &getInputs() { return Inputs; }
+  const ActionList &getInputs() const { return Inputs; }
+
+  size_type size() const { return Inputs.size(); }
+
+  input_iterator input_begin() { return Inputs.begin(); }
+  input_iterator input_end() { return Inputs.end(); }
+  input_range inputs() { return input_range(input_begin(), input_end()); }
+  input_const_iterator input_begin() const { return Inputs.begin(); }
+  input_const_iterator input_end() const { return Inputs.end(); }
+  input_const_range inputs() const {
+    return input_const_range(input_begin(), input_end());
+  }
+
+  /// Mark this action as not legal to collapse.
+  void setCannotBeCollapsedWithNextDependentAction() {
+    CanBeCollapsedWithNextDependentAction = false;
+  }
+
+  /// Return true if this function can be collapsed with others.
+  bool isCollapsingWithNextDependentActionLegal() const {
+    return CanBeCollapsedWithNextDependentAction;
+  }
+
+  /// Return a string containing the offload kind of the action.
+  std::string getOffloadingKindPrefix() const;
+
+  /// Return a string that can be used as prefix in order to generate unique
+  /// files for each offloading kind. By default, no prefix is used for
+  /// non-device kinds, except if \a CreatePrefixForHost is set.
+  static std::string
+  GetOffloadingFileNamePrefix(OffloadKind Kind,
+                              StringRef NormalizedTriple,
+                              bool CreatePrefixForHost = false);
+
+  /// Return a string containing a offload kind name.
+  static StringRef GetOffloadKindName(OffloadKind Kind);
+
+  /// Set the device offload info of this action and propagate it to its
+  /// dependences.
+  void propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch);
+
+  /// Append the host offload info of this action and propagate it to its
+  /// dependences.
+  void propagateHostOffloadInfo(unsigned OKinds, const char *OArch);
+
+  /// Set the offload info of this action to be the same as the provided action,
+  /// and propagate it to its dependences.
+  void propagateOffloadInfo(const Action *A);
+
+  unsigned getOffloadingHostActiveKinds() const {
+    return ActiveOffloadKindMask;
+  }
+
+  OffloadKind getOffloadingDeviceKind() const { return OffloadingDeviceKind; }
+  const char *getOffloadingArch() const { return OffloadingArch; }
+
+  /// Check if this action have any offload kinds. Note that host offload kinds
+  /// are only set if the action is a dependence to a host offload action.
+  bool isHostOffloading(OffloadKind OKind) const {
+    return ActiveOffloadKindMask & OKind;
+  }
+  bool isDeviceOffloading(OffloadKind OKind) const {
+    return OffloadingDeviceKind == OKind;
+  }
+  bool isOffloading(OffloadKind OKind) const {
+    return isHostOffloading(OKind) || isDeviceOffloading(OKind);
+  }
+};
+
+class InputAction : public Action {
+  const llvm::opt::Arg &Input;
+
+  virtual void anchor();
+
+public:
+  InputAction(const llvm::opt::Arg &Input, types::ID Type);
+
+  const llvm::opt::Arg &getInputArg() const { return Input; }
+
+  static bool classof(const Action *A) {
+    return A->getKind() == InputClass;
+  }
+};
+
+class BindArchAction : public Action {
+  virtual void anchor();
+
+  /// The architecture to bind, or 0 if the default architecture
+  /// should be bound.
+  StringRef ArchName;
+
+public:
+  BindArchAction(Action *Input, StringRef ArchName);
+
+  StringRef getArchName() const { return ArchName; }
+
+  static bool classof(const Action *A) {
+    return A->getKind() == BindArchClass;
+  }
+};
+
+/// An offload action combines host or/and device actions according to the
+/// programming model implementation needs and propagates the offloading kind to
+/// its dependences.
+class OffloadAction final : public Action {
+  virtual void anchor();
+
+public:
+  /// Type used to communicate device actions. It associates bound architecture,
+  /// toolchain, and offload kind to each action.
+  class DeviceDependences final {
+  public:
+    using ToolChainList = SmallVector<const ToolChain *, 3>;
+    using BoundArchList = SmallVector<const char *, 3>;
+    using OffloadKindList = SmallVector<OffloadKind, 3>;
+
+  private:
+    // Lists that keep the information for each dependency. All the lists are
+    // meant to be updated in sync. We are adopting separate lists instead of a
+    // list of structs, because that simplifies forwarding the actions list to
+    // initialize the inputs of the base Action class.
+
+    /// The dependence actions.
+    ActionList DeviceActions;
+
+    /// The offloading toolchains that should be used with the action.
+    ToolChainList DeviceToolChains;
+
+    /// The architectures that should be used with this action.
+    BoundArchList DeviceBoundArchs;
+
+    /// The offload kind of each dependence.
+    OffloadKindList DeviceOffloadKinds;
+
+  public:
+    /// Add a action along with the associated toolchain, bound arch, and
+    /// offload kind.
+    void add(Action &A, const ToolChain &TC, const char *BoundArch,
+             OffloadKind OKind);
+
+    /// Get each of the individual arrays.
+    const ActionList &getActions() const { return DeviceActions; }
+    const ToolChainList &getToolChains() const { return DeviceToolChains; }
+    const BoundArchList &getBoundArchs() const { return DeviceBoundArchs; }
+    const OffloadKindList &getOffloadKinds() const {
+      return DeviceOffloadKinds;
+    }
+  };
+
+  /// Type used to communicate host actions. It associates bound architecture,
+  /// toolchain, and offload kinds to the host action.
+  class HostDependence final {
+    /// The dependence action.
+    Action &HostAction;
+
+    /// The offloading toolchain that should be used with the action.
+    const ToolChain &HostToolChain;
+
+    /// The architectures that should be used with this action.
+    const char *HostBoundArch = nullptr;
+
+    /// The offload kind of each dependence.
+    unsigned HostOffloadKinds = 0u;
+
+  public:
+    HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
+                   const unsigned OffloadKinds)
+        : HostAction(A), HostToolChain(TC), HostBoundArch(BoundArch),
+          HostOffloadKinds(OffloadKinds) {}
+
+    /// Constructor version that obtains the offload kinds from the device
+    /// dependencies.
+    HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
+                   const DeviceDependences &DDeps);
+    Action *getAction() const { return &HostAction; }
+    const ToolChain *getToolChain() const { return &HostToolChain; }
+    const char *getBoundArch() const { return HostBoundArch; }
+    unsigned getOffloadKinds() const { return HostOffloadKinds; }
+  };
+
+  using OffloadActionWorkTy =
+      llvm::function_ref<void(Action *, const ToolChain *, const char *)>;
+
+private:
+  /// The host offloading toolchain that should be used with the action.
+  const ToolChain *HostTC = nullptr;
+
+  /// The tool chains associated with the list of actions.
+  DeviceDependences::ToolChainList DevToolChains;
+
+public:
+  OffloadAction(const HostDependence &HDep);
+  OffloadAction(const DeviceDependences &DDeps, types::ID Ty);
+  OffloadAction(const HostDependence &HDep, const DeviceDependences &DDeps);
+
+  /// Execute the work specified in \a Work on the host dependence.
+  void doOnHostDependence(const OffloadActionWorkTy &Work) const;
+
+  /// Execute the work specified in \a Work on each device dependence.
+  void doOnEachDeviceDependence(const OffloadActionWorkTy &Work) const;
+
+  /// Execute the work specified in \a Work on each dependence.
+  void doOnEachDependence(const OffloadActionWorkTy &Work) const;
+
+  /// Execute the work specified in \a Work on each host or device dependence if
+  /// \a IsHostDependenceto is true or false, respectively.
+  void doOnEachDependence(bool IsHostDependence,
+                          const OffloadActionWorkTy &Work) const;
+
+  /// Return true if the action has a host dependence.
+  bool hasHostDependence() const;
+
+  /// Return the host dependence of this action. This function is only expected
+  /// to be called if the host dependence exists.
+  Action *getHostDependence() const;
+
+  /// Return true if the action has a single device dependence. If \a
+  /// DoNotConsiderHostActions is set, ignore the host dependence, if any, while
+  /// accounting for the number of dependences.
+  bool hasSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
+
+  /// Return the single device dependence of this action. This function is only
+  /// expected to be called if a single device dependence exists. If \a
+  /// DoNotConsiderHostActions is set, a host dependence is allowed.
+  Action *
+  getSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
+
+  static bool classof(const Action *A) { return A->getKind() == OffloadClass; }
+};
+
+class JobAction : public Action {
+  virtual void anchor();
+
+protected:
+  JobAction(ActionClass Kind, Action *Input, types::ID Type);
+  JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type);
+
+public:
+  static bool classof(const Action *A) {
+    return (A->getKind() >= JobClassFirst &&
+            A->getKind() <= JobClassLast);
+  }
+};
+
+class PreprocessJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  PreprocessJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == PreprocessJobClass;
+  }
+};
+
+class PrecompileJobAction : public JobAction {
+  void anchor() override;
+
+protected:
+  PrecompileJobAction(ActionClass Kind, Action *Input, types::ID OutputType);
+
+public:
+  PrecompileJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == PrecompileJobClass ||
+           A->getKind() == HeaderModulePrecompileJobClass;
+  }
+};
+
+class HeaderModulePrecompileJobAction : public PrecompileJobAction {
+  void anchor() override;
+
+  const char *ModuleName;
+
+public:
+  HeaderModulePrecompileJobAction(Action *Input, types::ID OutputType,
+                                  const char *ModuleName);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == HeaderModulePrecompileJobClass;
+  }
+
+  void addModuleHeaderInput(Action *Input) {
+    getInputs().push_back(Input);
+  }
+
+  const char *getModuleName() const { return ModuleName; }
+};
+
+class AnalyzeJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  AnalyzeJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == AnalyzeJobClass;
+  }
+};
+
+class MigrateJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  MigrateJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == MigrateJobClass;
+  }
+};
+
+class CompileJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  CompileJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == CompileJobClass;
+  }
+};
+
+class BackendJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  BackendJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == BackendJobClass;
+  }
+};
+
+class AssembleJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  AssembleJobAction(Action *Input, types::ID OutputType);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == AssembleJobClass;
+  }
+};
+
+class LinkJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  LinkJobAction(ActionList &Inputs, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == LinkJobClass;
+  }
+};
+
+class LipoJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  LipoJobAction(ActionList &Inputs, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == LipoJobClass;
+  }
+};
+
+class DsymutilJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  DsymutilJobAction(ActionList &Inputs, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == DsymutilJobClass;
+  }
+};
+
+class VerifyJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == VerifyDebugInfoJobClass ||
+           A->getKind() == VerifyPCHJobClass;
+  }
+};
+
+class VerifyDebugInfoJobAction : public VerifyJobAction {
+  void anchor() override;
+
+public:
+  VerifyDebugInfoJobAction(Action *Input, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == VerifyDebugInfoJobClass;
+  }
+};
+
+class VerifyPCHJobAction : public VerifyJobAction {
+  void anchor() override;
+
+public:
+  VerifyPCHJobAction(Action *Input, types::ID Type);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == VerifyPCHJobClass;
+  }
+};
+
+class OffloadBundlingJobAction : public JobAction {
+  void anchor() override;
+
+public:
+  // Offloading bundling doesn't change the type of output.
+  OffloadBundlingJobAction(ActionList &Inputs);
+
+  static bool classof(const Action *A) {
+    return A->getKind() == OffloadBundlingJobClass;
+  }
+};
+
+class OffloadUnbundlingJobAction final : public JobAction {
+  void anchor() override;
+
+public:
+  /// Type that provides information about the actions that depend on this
+  /// unbundling action.
+  struct DependentActionInfo final {
+    /// The tool chain of the dependent action.
+    const ToolChain *DependentToolChain = nullptr;
+
+    /// The bound architecture of the dependent action.
+    StringRef DependentBoundArch;
+
+    /// The offload kind of the dependent action.
+    const OffloadKind DependentOffloadKind = OFK_None;
+
+    DependentActionInfo(const ToolChain *DependentToolChain,
+                        StringRef DependentBoundArch,
+                        const OffloadKind DependentOffloadKind)
+        : DependentToolChain(DependentToolChain),
+          DependentBoundArch(DependentBoundArch),
+          DependentOffloadKind(DependentOffloadKind) {}
+  };
+
+private:
+  /// Container that keeps information about each dependence of this unbundling
+  /// action.
+  SmallVector<DependentActionInfo, 6> DependentActionInfoArray;
+
+public:
+  // Offloading unbundling doesn't change the type of output.
+  OffloadUnbundlingJobAction(Action *Input);
+
+  /// Register information about a dependent action.
+  void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch,
+                                   OffloadKind Kind) {
+    DependentActionInfoArray.push_back({TC, BoundArch, Kind});
+  }
+
+  /// Return the information about all depending actions.
+  ArrayRef<DependentActionInfo> getDependentActionsInfo() const {
+    return DependentActionInfoArray;
+  }
+
+  static bool classof(const Action *A) {
+    return A->getKind() == OffloadUnbundlingJobClass;
+  }
+};
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_ACTION_H
diff --git a/clang-r353983e/include/clang/Driver/Compilation.h b/clang-r353983e/include/clang/Driver/Compilation.h
new file mode 100644
index 00000000..33ae133e
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Compilation.h
@@ -0,0 +1,311 @@
+//===- Compilation.h - Compilation Task Data Structure ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_COMPILATION_H
+#define LLVM_CLANG_DRIVER_COMPILATION_H
+
+#include "clang/Basic/LLVM.h"
+#include "clang/Driver/Action.h"
+#include "clang/Driver/Job.h"
+#include "clang/Driver/Util.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/Option.h"
+#include <cassert>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+namespace opt {
+
+class DerivedArgList;
+class InputArgList;
+
+} // namespace opt
+} // namespace llvm
+
+namespace clang {
+namespace driver {
+
+class Driver;
+class ToolChain;
+
+/// Compilation - A set of tasks to perform for a single driver
+/// invocation.
+class Compilation {
+  /// The driver we were created by.
+  const Driver &TheDriver;
+
+  /// The default tool chain.
+  const ToolChain &DefaultToolChain;
+
+  /// A mask of all the programming models the host has to support in the
+  /// current compilation.
+  unsigned ActiveOffloadMask = 0;
+
+  /// Array with the toolchains of offloading host and devices in the order they
+  /// were requested by the user. We are preserving that order in case the code
+  /// generation needs to derive a programming-model-specific semantic out of
+  /// it.
+  std::multimap<Action::OffloadKind, const ToolChain *>
+      OrderedOffloadingToolchains;
+
+  /// The original (untranslated) input argument list.
+  llvm::opt::InputArgList *Args;
+
+  /// The driver translated arguments. Note that toolchains may perform their
+  /// own argument translation.
+  llvm::opt::DerivedArgList *TranslatedArgs;
+
+  /// The list of actions we've created via MakeAction.  This is not accessible
+  /// to consumers; it's here just to manage ownership.
+  std::vector<std::unique_ptr<Action>> AllActions;
+
+  /// The list of actions.  This is maintained and modified by consumers, via
+  /// getActions().
+  ActionList Actions;
+
+  /// The root list of jobs.
+  JobList Jobs;
+
+  /// Cache of translated arguments for a particular tool chain, bound
+  /// architecture, and device offload kind.
+  struct TCArgsKey final {
+    const ToolChain *TC = nullptr;
+    StringRef BoundArch;
+    Action::OffloadKind DeviceOffloadKind = Action::OFK_None;
+
+    TCArgsKey(const ToolChain *TC, StringRef BoundArch,
+              Action::OffloadKind DeviceOffloadKind)
+        : TC(TC), BoundArch(BoundArch), DeviceOffloadKind(DeviceOffloadKind) {}
+
+    bool operator<(const TCArgsKey &K) const {
+      if (TC < K.TC)
+        return true;
+      else if (TC == K.TC && BoundArch < K.BoundArch)
+        return true;
+      else if (TC == K.TC && BoundArch == K.BoundArch &&
+               DeviceOffloadKind < K.DeviceOffloadKind)
+        return true;
+      return false;
+    }
+  };
+  std::map<TCArgsKey, llvm::opt::DerivedArgList *> TCArgs;
+
+  /// Temporary files which should be removed on exit.
+  llvm::opt::ArgStringList TempFiles;
+
+  /// Result files which should be removed on failure.
+  ArgStringMap ResultFiles;
+
+  /// Result files which are generated correctly on failure, and which should
+  /// only be removed if we crash.
+  ArgStringMap FailureResultFiles;
+
+  /// Optional redirection for stdin, stdout, stderr.
+  std::vector<Optional<StringRef>> Redirects;
+
+  /// Whether we're compiling for diagnostic purposes.
+  bool ForDiagnostics = false;
+
+  /// Whether an error during the parsing of the input args.
+  bool ContainsError;
+
+  /// Whether to keep temporary files regardless of -save-temps.
+  bool ForceKeepTempFiles = false;
+
+public:
+  Compilation(const Driver &D, const ToolChain &DefaultToolChain,
+              llvm::opt::InputArgList *Args,
+              llvm::opt::DerivedArgList *TranslatedArgs, bool ContainsError);
+  ~Compilation();
+
+  const Driver &getDriver() const { return TheDriver; }
+
+  const ToolChain &getDefaultToolChain() const { return DefaultToolChain; }
+
+  unsigned isOffloadingHostKind(Action::OffloadKind Kind) const {
+    return ActiveOffloadMask & Kind;
+  }
+
+  /// Iterator that visits device toolchains of a given kind.
+  using const_offload_toolchains_iterator =
+      const std::multimap<Action::OffloadKind,
+                          const ToolChain *>::const_iterator;
+  using const_offload_toolchains_range =
+      std::pair<const_offload_toolchains_iterator,
+                const_offload_toolchains_iterator>;
+
+  template <Action::OffloadKind Kind>
+  const_offload_toolchains_range getOffloadToolChains() const {
+    return OrderedOffloadingToolchains.equal_range(Kind);
+  }
+
+  /// Return true if an offloading tool chain of a given kind exists.
+  template <Action::OffloadKind Kind> bool hasOffloadToolChain() const {
+    return OrderedOffloadingToolchains.find(Kind) !=
+           OrderedOffloadingToolchains.end();
+  }
+
+  /// Return an offload toolchain of the provided kind. Only one is expected to
+  /// exist.
+  template <Action::OffloadKind Kind>
+  const ToolChain *getSingleOffloadToolChain() const {
+    auto TCs = getOffloadToolChains<Kind>();
+
+    assert(TCs.first != TCs.second &&
+           "No tool chains of the selected kind exist!");
+    assert(std::next(TCs.first) == TCs.second &&
+           "More than one tool chain of the this kind exist.");
+    return TCs.first->second;
+  }
+
+  void addOffloadDeviceToolChain(const ToolChain *DeviceToolChain,
+                                 Action::OffloadKind OffloadKind) {
+    assert(OffloadKind != Action::OFK_Host && OffloadKind != Action::OFK_None &&
+           "This is not a device tool chain!");
+
+    // Update the host offload kind to also contain this kind.
+    ActiveOffloadMask |= OffloadKind;
+    OrderedOffloadingToolchains.insert(
+        std::make_pair(OffloadKind, DeviceToolChain));
+  }
+
+  const llvm::opt::InputArgList &getInputArgs() const { return *Args; }
+
+  const llvm::opt::DerivedArgList &getArgs() const { return *TranslatedArgs; }
+
+  llvm::opt::DerivedArgList &getArgs() { return *TranslatedArgs; }
+
+  ActionList &getActions() { return Actions; }
+  const ActionList &getActions() const { return Actions; }
+
+  /// Creates a new Action owned by this Compilation.
+  ///
+  /// The new Action is *not* added to the list returned by getActions().
+  template <typename T, typename... Args> T *MakeAction(Args &&... Arg) {
+    T *RawPtr = new T(std::forward<Args>(Arg)...);
+    AllActions.push_back(std::unique_ptr<Action>(RawPtr));
+    return RawPtr;
+  }
+
+  JobList &getJobs() { return Jobs; }
+  const JobList &getJobs() const { return Jobs; }
+
+  void addCommand(std::unique_ptr<Command> C) { Jobs.addJob(std::move(C)); }
+
+  const llvm::opt::ArgStringList &getTempFiles() const { return TempFiles; }
+
+  const ArgStringMap &getResultFiles() const { return ResultFiles; }
+
+  const ArgStringMap &getFailureResultFiles() const {
+    return FailureResultFiles;
+  }
+
+  /// Returns the sysroot path.
+  StringRef getSysRoot() const;
+
+  /// getArgsForToolChain - Return the derived argument list for the
+  /// tool chain \p TC (or the default tool chain, if TC is not specified).
+  /// If a device offloading kind is specified, a translation specific for that
+  /// kind is performed, if any.
+  ///
+  /// \param BoundArch - The bound architecture name, or 0.
+  /// \param DeviceOffloadKind - The offload device kind that should be used in
+  /// the translation, if any.
+  const llvm::opt::DerivedArgList &
+  getArgsForToolChain(const ToolChain *TC, StringRef BoundArch,
+                      Action::OffloadKind DeviceOffloadKind);
+
+  /// addTempFile - Add a file to remove on exit, and returns its
+  /// argument.
+  const char *addTempFile(const char *Name) {
+    TempFiles.push_back(Name);
+    return Name;
+  }
+
+  /// addResultFile - Add a file to remove on failure, and returns its
+  /// argument.
+  const char *addResultFile(const char *Name, const JobAction *JA) {
+    ResultFiles[JA] = Name;
+    return Name;
+  }
+
+  /// addFailureResultFile - Add a file to remove if we crash, and returns its
+  /// argument.
+  const char *addFailureResultFile(const char *Name, const JobAction *JA) {
+    FailureResultFiles[JA] = Name;
+    return Name;
+  }
+
+  /// CleanupFile - Delete a given file.
+  ///
+  /// \param IssueErrors - Report failures as errors.
+  /// \return Whether the file was removed successfully.
+  bool CleanupFile(const char *File, bool IssueErrors = false) const;
+
+  /// CleanupFileList - Remove the files in the given list.
+  ///
+  /// \param IssueErrors - Report failures as errors.
+  /// \return Whether all files were removed successfully.
+  bool CleanupFileList(const llvm::opt::ArgStringList &Files,
+                       bool IssueErrors = false) const;
+
+  /// CleanupFileMap - Remove the files in the given map.
+  ///
+  /// \param JA - If specified, only delete the files associated with this
+  /// JobAction.  Otherwise, delete all files in the map.
+  /// \param IssueErrors - Report failures as errors.
+  /// \return Whether all files were removed successfully.
+  bool CleanupFileMap(const ArgStringMap &Files,
+                      const JobAction *JA,
+                      bool IssueErrors = false) const;
+
+  /// ExecuteCommand - Execute an actual command.
+  ///
+  /// \param FailingCommand - For non-zero results, this will be set to the
+  /// Command which failed, if any.
+  /// \return The result code of the subprocess.
+  int ExecuteCommand(const Command &C, const Command *&FailingCommand) const;
+
+  /// ExecuteJob - Execute a single job.
+  ///
+  /// \param FailingCommands - For non-zero results, this will be a vector of
+  /// failing commands and their associated result code.
+  void ExecuteJobs(
+      const JobList &Jobs,
+      SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) const;
+
+  /// initCompilationForDiagnostics - Remove stale state and suppress output
+  /// so compilation can be reexecuted to generate additional diagnostic
+  /// information (e.g., preprocessed source(s)).
+  void initCompilationForDiagnostics();
+
+  /// Return true if we're compiling for diagnostics.
+  bool isForDiagnostics() const { return ForDiagnostics; }
+
+  /// Return whether an error during the parsing of the input args.
+  bool containsError() const { return ContainsError; }
+
+  /// Redirect - Redirect output of this compilation. Can only be done once.
+  ///
+  /// \param Redirects - array of optional paths. The array should have a size
+  /// of three. The inferior process's stdin(0), stdout(1), and stderr(2) will
+  /// be redirected to the corresponding paths, if provided (not llvm::None).
+  void Redirect(ArrayRef<Optional<StringRef>> Redirects);
+};
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_COMPILATION_H
diff --git a/clang-r353983e/include/clang/Driver/DarwinSDKInfo.h b/clang-r353983e/include/clang/Driver/DarwinSDKInfo.h
new file mode 100644
index 00000000..f7075a8d
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/DarwinSDKInfo.h
@@ -0,0 +1,41 @@
+//===--- DarwinSDKInfo.h - SDK Information parser for darwin ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_DARWIN_SDK_INFO_H
+#define LLVM_CLANG_DRIVER_DARWIN_SDK_INFO_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/VersionTuple.h"
+#include "llvm/Support/VirtualFileSystem.h"
+
+namespace clang {
+namespace driver {
+
+/// The information about the darwin SDK that was used during this compilation.
+class DarwinSDKInfo {
+public:
+  DarwinSDKInfo(llvm::VersionTuple Version) : Version(Version) {}
+
+  const llvm::VersionTuple &getVersion() const { return Version; }
+
+private:
+  llvm::VersionTuple Version;
+};
+
+/// Parse the SDK information from the SDKSettings.json file.
+///
+/// \returns an error if the SDKSettings.json file is invalid, None if the
+/// SDK has no SDKSettings.json, or a valid \c DarwinSDKInfo otherwise.
+Expected<Optional<DarwinSDKInfo>> parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS,
+                                                     StringRef SDKRootPath);
+
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_DRIVER_DARWIN_SDK_INFO_H
diff --git a/clang-r353983e/include/clang/Driver/Distro.h b/clang-r353983e/include/clang/Driver/Distro.h
new file mode 100644
index 00000000..d9a31f16
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Distro.h
@@ -0,0 +1,136 @@
+//===--- Distro.h - Linux distribution detection support --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_DISTRO_H
+#define LLVM_CLANG_DRIVER_DISTRO_H
+
+#include "llvm/Support/VirtualFileSystem.h"
+
+namespace clang {
+namespace driver {
+
+/// Distro - Helper class for detecting and classifying Linux distributions.
+///
+/// This class encapsulates the clang Linux distribution detection mechanism
+/// as well as helper functions that match the specific (versioned) results
+/// into wider distribution classes.
+class Distro {
+public:
+  enum DistroType {
+    // NB: Releases of a particular Linux distro should be kept together
+    // in this enum, because some tests are done by integer comparison against
+    // the first and last known member in the family, e.g. IsRedHat().
+    AlpineLinux,
+    ArchLinux,
+    DebianLenny,
+    DebianSqueeze,
+    DebianWheezy,
+    DebianJessie,
+    DebianStretch,
+    DebianBuster,
+    Exherbo,
+    RHEL5,
+    RHEL6,
+    RHEL7,
+    Fedora,
+    Gentoo,
+    OpenSUSE,
+    UbuntuHardy,
+    UbuntuIntrepid,
+    UbuntuJaunty,
+    UbuntuKarmic,
+    UbuntuLucid,
+    UbuntuMaverick,
+    UbuntuNatty,
+    UbuntuOneiric,
+    UbuntuPrecise,
+    UbuntuQuantal,
+    UbuntuRaring,
+    UbuntuSaucy,
+    UbuntuTrusty,
+    UbuntuUtopic,
+    UbuntuVivid,
+    UbuntuWily,
+    UbuntuXenial,
+    UbuntuYakkety,
+    UbuntuZesty,
+    UbuntuArtful,
+    UbuntuBionic,
+    UbuntuCosmic,
+    UbuntuDisco,
+    UnknownDistro
+  };
+
+private:
+  /// The distribution, possibly with specific version.
+  DistroType DistroVal;
+
+public:
+  /// @name Constructors
+  /// @{
+
+  /// Default constructor leaves the distribution unknown.
+  Distro() : DistroVal() {}
+
+  /// Constructs a Distro type for specific distribution.
+  Distro(DistroType D) : DistroVal(D) {}
+
+  /// Detects the distribution using specified VFS.
+  explicit Distro(llvm::vfs::FileSystem &VFS);
+
+  bool operator==(const Distro &Other) const {
+    return DistroVal == Other.DistroVal;
+  }
+
+  bool operator!=(const Distro &Other) const {
+    return DistroVal != Other.DistroVal;
+  }
+
+  bool operator>=(const Distro &Other) const {
+    return DistroVal >= Other.DistroVal;
+  }
+
+  bool operator<=(const Distro &Other) const {
+    return DistroVal <= Other.DistroVal;
+  }
+
+  /// @}
+  /// @name Convenience Predicates
+  /// @{
+
+  bool IsRedhat() const {
+    return DistroVal == Fedora || (DistroVal >= RHEL5 && DistroVal <= RHEL7);
+  }
+
+  bool IsOpenSUSE() const {
+    return DistroVal == OpenSUSE;
+  }
+
+  bool IsDebian() const {
+    return DistroVal >= DebianLenny && DistroVal <= DebianBuster;
+  }
+
+  bool IsUbuntu() const {
+    return DistroVal >= UbuntuHardy && DistroVal <= UbuntuDisco;
+  }
+
+  bool IsAlpineLinux() const {
+    return DistroVal == AlpineLinux;
+  }
+
+  bool IsGentoo() const {
+    return DistroVal == Gentoo;
+  }
+
+  /// @}
+};
+
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/Driver.h b/clang-r353983e/include/clang/Driver/Driver.h
new file mode 100644
index 00000000..03e6458a
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Driver.h
@@ -0,0 +1,604 @@
+//===--- Driver.h - Clang GCC Compatible Driver -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_DRIVER_H
+#define LLVM_CLANG_DRIVER_DRIVER_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Driver/Action.h"
+#include "clang/Driver/Phases.h"
+#include "clang/Driver/ToolChain.h"
+#include "clang/Driver/Types.h"
+#include "clang/Driver/Util.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/StringSaver.h"
+
+#include <list>
+#include <map>
+#include <string>
+
+namespace llvm {
+class Triple;
+namespace vfs {
+class FileSystem;
+}
+} // namespace llvm
+
+namespace clang {
+
+namespace driver {
+
+  class Command;
+  class Compilation;
+  class InputInfo;
+  class JobList;
+  class JobAction;
+  class SanitizerArgs;
+  class ToolChain;
+
+/// Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options.
+enum LTOKind {
+  LTOK_None,
+  LTOK_Full,
+  LTOK_Thin,
+  LTOK_Unknown
+};
+
+/// Driver - Encapsulate logic for constructing compilation processes
+/// from a set of gcc-driver-like command line arguments.
+class Driver {
+  std::unique_ptr<llvm::opt::OptTable> Opts;
+
+  DiagnosticsEngine &Diags;
+
+  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS;
+
+  enum DriverMode {
+    GCCMode,
+    GXXMode,
+    CPPMode,
+    CLMode
+  } Mode;
+
+  enum SaveTempsMode {
+    SaveTempsNone,
+    SaveTempsCwd,
+    SaveTempsObj
+  } SaveTemps;
+
+  enum BitcodeEmbedMode {
+    EmbedNone,
+    EmbedMarker,
+    EmbedBitcode
+  } BitcodeEmbed;
+
+  /// LTO mode selected via -f(no-)?lto(=.*)? options.
+  LTOKind LTOMode;
+
+public:
+  enum OpenMPRuntimeKind {
+    /// An unknown OpenMP runtime. We can't generate effective OpenMP code
+    /// without knowing what runtime to target.
+    OMPRT_Unknown,
+
+    /// The LLVM OpenMP runtime. When completed and integrated, this will become
+    /// the default for Clang.
+    OMPRT_OMP,
+
+    /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
+    /// this runtime but can swallow the pragmas, and find and link against the
+    /// runtime library itself.
+    OMPRT_GOMP,
+
+    /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
+    /// OpenMP runtime. We support this mode for users with existing
+    /// dependencies on this runtime library name.
+    OMPRT_IOMP5
+  };
+
+  // Diag - Forwarding function for diagnostics.
+  DiagnosticBuilder Diag(unsigned DiagID) const {
+    return Diags.Report(DiagID);
+  }
+
+  // FIXME: Privatize once interface is stable.
+public:
+  /// The name the driver was invoked as.
+  std::string Name;
+
+  /// The path the driver executable was in, as invoked from the
+  /// command line.
+  std::string Dir;
+
+  /// The original path to the clang executable.
+  std::string ClangExecutable;
+
+  /// Target and driver mode components extracted from clang executable name.
+  ParsedClangName ClangNameParts;
+
+  /// The path to the installed clang directory, if any.
+  std::string InstalledDir;
+
+  /// The path to the compiler resource directory.
+  std::string ResourceDir;
+
+  /// System directory for config files.
+  std::string SystemConfigDir;
+
+  /// User directory for config files.
+  std::string UserConfigDir;
+
+  /// A prefix directory used to emulate a limited subset of GCC's '-Bprefix'
+  /// functionality.
+  /// FIXME: This type of customization should be removed in favor of the
+  /// universal driver when it is ready.
+  typedef SmallVector<std::string, 4> prefix_list;
+  prefix_list PrefixDirs;
+
+  /// sysroot, if present
+  std::string SysRoot;
+
+  /// Dynamic loader prefix, if present
+  std::string DyldPrefix;
+
+  /// Driver title to use with help.
+  std::string DriverTitle;
+
+  /// Information about the host which can be overridden by the user.
+  std::string HostBits, HostMachine, HostSystem, HostRelease;
+
+  /// The file to log CC_PRINT_OPTIONS output to, if enabled.
+  const char *CCPrintOptionsFilename;
+
+  /// The file to log CC_PRINT_HEADERS output to, if enabled.
+  const char *CCPrintHeadersFilename;
+
+  /// The file to log CC_LOG_DIAGNOSTICS output to, if enabled.
+  const char *CCLogDiagnosticsFilename;
+
+  /// A list of inputs and their types for the given arguments.
+  typedef SmallVector<std::pair<types::ID, const llvm::opt::Arg *>, 16>
+      InputList;
+
+  /// Whether the driver should follow g++ like behavior.
+  bool CCCIsCXX() const { return Mode == GXXMode; }
+
+  /// Whether the driver is just the preprocessor.
+  bool CCCIsCPP() const { return Mode == CPPMode; }
+
+  /// Whether the driver should follow gcc like behavior.
+  bool CCCIsCC() const { return Mode == GCCMode; }
+
+  /// Whether the driver should follow cl.exe like behavior.
+  bool IsCLMode() const { return Mode == CLMode; }
+
+  /// Only print tool bindings, don't build any jobs.
+  unsigned CCCPrintBindings : 1;
+
+  /// Set CC_PRINT_OPTIONS mode, which is like -v but logs the commands to
+  /// CCPrintOptionsFilename or to stderr.
+  unsigned CCPrintOptions : 1;
+
+  /// Set CC_PRINT_HEADERS mode, which causes the frontend to log header include
+  /// information to CCPrintHeadersFilename or to stderr.
+  unsigned CCPrintHeaders : 1;
+
+  /// Set CC_LOG_DIAGNOSTICS mode, which causes the frontend to log diagnostics
+  /// to CCLogDiagnosticsFilename or to stderr, in a stable machine readable
+  /// format.
+  unsigned CCLogDiagnostics : 1;
+
+  /// Whether the driver is generating diagnostics for debugging purposes.
+  unsigned CCGenDiagnostics : 1;
+
+private:
+  /// Raw target triple.
+  std::string TargetTriple;
+
+  /// Name to use when invoking gcc/g++.
+  std::string CCCGenericGCCName;
+
+  /// Name of configuration file if used.
+  std::string ConfigFile;
+
+  /// Allocator for string saver.
+  llvm::BumpPtrAllocator Alloc;
+
+  /// Object that stores strings read from configuration file.
+  llvm::StringSaver Saver;
+
+  /// Arguments originated from configuration file.
+  std::unique_ptr<llvm::opt::InputArgList> CfgOptions;
+
+  /// Arguments originated from command line.
+  std::unique_ptr<llvm::opt::InputArgList> CLOptions;
+
+  /// Whether to check that input files exist when constructing compilation
+  /// jobs.
+  unsigned CheckInputsExist : 1;
+
+public:
+  /// Force clang to emit reproducer for driver invocation. This is enabled
+  /// indirectly by setting FORCE_CLANG_DIAGNOSTICS_CRASH environment variable
+  /// or when using the -gen-reproducer driver flag.
+  unsigned GenReproducer : 1;
+
+private:
+  /// Certain options suppress the 'no input files' warning.
+  unsigned SuppressMissingInputWarning : 1;
+
+  std::list<std::string> TempFiles;
+  std::list<std::string> ResultFiles;
+
+  /// Cache of all the ToolChains in use by the driver.
+  ///
+  /// This maps from the string representation of a triple to a ToolChain
+  /// created targeting that triple. The driver owns all the ToolChain objects
+  /// stored in it, and will clean them up when torn down.
+  mutable llvm::StringMap<std::unique_ptr<ToolChain>> ToolChains;
+
+private:
+  /// TranslateInputArgs - Create a new derived argument list from the input
+  /// arguments, after applying the standard argument translations.
+  llvm::opt::DerivedArgList *
+  TranslateInputArgs(const llvm::opt::InputArgList &Args) const;
+
+  // getFinalPhase - Determine which compilation mode we are in and record
+  // which option we used to determine the final phase.
+  phases::ID getFinalPhase(const llvm::opt::DerivedArgList &DAL,
+                           llvm::opt::Arg **FinalPhaseArg = nullptr) const;
+
+  // Before executing jobs, sets up response files for commands that need them.
+  void setUpResponseFiles(Compilation &C, Command &Cmd);
+
+  void generatePrefixedToolNames(StringRef Tool, const ToolChain &TC,
+                                 SmallVectorImpl<std::string> &Names) const;
+
+  /// Find the appropriate .crash diagonostic file for the child crash
+  /// under this driver and copy it out to a temporary destination with the
+  /// other reproducer related files (.sh, .cache, etc). If not found, suggest a
+  /// directory for the user to look at.
+  ///
+  /// \param ReproCrashFilename The file path to copy the .crash to.
+  /// \param CrashDiagDir       The suggested directory for the user to look at
+  ///                           in case the search or copy fails.
+  ///
+  /// \returns If the .crash is found and successfully copied return true,
+  /// otherwise false and return the suggested directory in \p CrashDiagDir.
+  bool getCrashDiagnosticFile(StringRef ReproCrashFilename,
+                              SmallString<128> &CrashDiagDir);
+
+public:
+
+  /// Takes the path to a binary that's either in bin/ or lib/ and returns
+  /// the path to clang's resource directory.
+  static std::string GetResourcesPath(StringRef BinaryPath,
+                                      StringRef CustomResourceDir = "");
+
+  Driver(StringRef ClangExecutable, StringRef TargetTriple,
+         DiagnosticsEngine &Diags,
+         IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr);
+
+  /// @name Accessors
+  /// @{
+
+  /// Name to use when invoking gcc/g++.
+  const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; }
+
+  const std::string &getConfigFile() const { return ConfigFile; }
+
+  const llvm::opt::OptTable &getOpts() const { return *Opts; }
+
+  const DiagnosticsEngine &getDiags() const { return Diags; }
+
+  llvm::vfs::FileSystem &getVFS() const { return *VFS; }
+
+  bool getCheckInputsExist() const { return CheckInputsExist; }
+
+  void setCheckInputsExist(bool Value) { CheckInputsExist = Value; }
+
+  void setTargetAndMode(const ParsedClangName &TM) { ClangNameParts = TM; }
+
+  const std::string &getTitle() { return DriverTitle; }
+  void setTitle(std::string Value) { DriverTitle = std::move(Value); }
+
+  std::string getTargetTriple() const { return TargetTriple; }
+
+  /// Get the path to the main clang executable.
+  const char *getClangProgramPath() const {
+    return ClangExecutable.c_str();
+  }
+
+  /// Get the path to where the clang executable was installed.
+  const char *getInstalledDir() const {
+    if (!InstalledDir.empty())
+      return InstalledDir.c_str();
+    return Dir.c_str();
+  }
+  void setInstalledDir(StringRef Value) {
+    InstalledDir = Value;
+  }
+
+  bool isSaveTempsEnabled() const { return SaveTemps != SaveTempsNone; }
+  bool isSaveTempsObj() const { return SaveTemps == SaveTempsObj; }
+
+  bool embedBitcodeEnabled() const { return BitcodeEmbed != EmbedNone; }
+  bool embedBitcodeInObject() const { return (BitcodeEmbed == EmbedBitcode); }
+  bool embedBitcodeMarkerOnly() const { return (BitcodeEmbed == EmbedMarker); }
+
+  /// Compute the desired OpenMP runtime from the flags provided.
+  OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const;
+
+  /// @}
+  /// @name Primary Functionality
+  /// @{
+
+  /// CreateOffloadingDeviceToolChains - create all the toolchains required to
+  /// support offloading devices given the programming models specified in the
+  /// current compilation. Also, update the host tool chain kind accordingly.
+  void CreateOffloadingDeviceToolChains(Compilation &C, InputList &Inputs);
+
+  /// BuildCompilation - Construct a compilation object for a command
+  /// line argument vector.
+  ///
+  /// \return A compilation, or 0 if none was built for the given
+  /// argument vector. A null return value does not necessarily
+  /// indicate an error condition, the diagnostics should be queried
+  /// to determine if an error occurred.
+  Compilation *BuildCompilation(ArrayRef<const char *> Args);
+
+  /// @name Driver Steps
+  /// @{
+
+  /// ParseDriverMode - Look for and handle the driver mode option in Args.
+  void ParseDriverMode(StringRef ProgramName, ArrayRef<const char *> Args);
+
+  /// ParseArgStrings - Parse the given list of strings into an
+  /// ArgList.
+  llvm::opt::InputArgList ParseArgStrings(ArrayRef<const char *> Args,
+                                          bool IsClCompatMode,
+                                          bool &ContainsError);
+
+  /// BuildInputs - Construct the list of inputs and their types from
+  /// the given arguments.
+  ///
+  /// \param TC - The default host tool chain.
+  /// \param Args - The input arguments.
+  /// \param Inputs - The list to store the resulting compilation
+  /// inputs onto.
+  void BuildInputs(const ToolChain &TC, llvm::opt::DerivedArgList &Args,
+                   InputList &Inputs) const;
+
+  /// BuildActions - Construct the list of actions to perform for the
+  /// given arguments, which are only done for a single architecture.
+  ///
+  /// \param C - The compilation that is being built.
+  /// \param Args - The input arguments.
+  /// \param Actions - The list to store the resulting actions onto.
+  void BuildActions(Compilation &C, llvm::opt::DerivedArgList &Args,
+                    const InputList &Inputs, ActionList &Actions) const;
+
+  /// BuildUniversalActions - Construct the list of actions to perform
+  /// for the given arguments, which may require a universal build.
+  ///
+  /// \param C - The compilation that is being built.
+  /// \param TC - The default host tool chain.
+  void BuildUniversalActions(Compilation &C, const ToolChain &TC,
+                             const InputList &BAInputs) const;
+
+  /// BuildJobs - Bind actions to concrete tools and translate
+  /// arguments to form the list of jobs to run.
+  ///
+  /// \param C - The compilation that is being built.
+  void BuildJobs(Compilation &C) const;
+
+  /// ExecuteCompilation - Execute the compilation according to the command line
+  /// arguments and return an appropriate exit code.
+  ///
+  /// This routine handles additional processing that must be done in addition
+  /// to just running the subprocesses, for example reporting errors, setting
+  /// up response files, removing temporary files, etc.
+  int ExecuteCompilation(Compilation &C,
+     SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands);
+
+  /// Contains the files in the compilation diagnostic report generated by
+  /// generateCompilationDiagnostics.
+  struct CompilationDiagnosticReport {
+    llvm::SmallVector<std::string, 4> TemporaryFiles;
+  };
+
+  /// generateCompilationDiagnostics - Generate diagnostics information
+  /// including preprocessed source file(s).
+  ///
+  void generateCompilationDiagnostics(
+      Compilation &C, const Command &FailingCommand,
+      StringRef AdditionalInformation = "",
+      CompilationDiagnosticReport *GeneratedReport = nullptr);
+
+  /// @}
+  /// @name Helper Methods
+  /// @{
+
+  /// PrintActions - Print the list of actions.
+  void PrintActions(const Compilation &C) const;
+
+  /// PrintHelp - Print the help text.
+  ///
+  /// \param ShowHidden - Show hidden options.
+  void PrintHelp(bool ShowHidden) const;
+
+  /// PrintVersion - Print the driver version.
+  void PrintVersion(const Compilation &C, raw_ostream &OS) const;
+
+  /// GetFilePath - Lookup \p Name in the list of file search paths.
+  ///
+  /// \param TC - The tool chain for additional information on
+  /// directories to search.
+  //
+  // FIXME: This should be in CompilationInfo.
+  std::string GetFilePath(StringRef Name, const ToolChain &TC) const;
+
+  /// GetProgramPath - Lookup \p Name in the list of program search paths.
+  ///
+  /// \param TC - The provided tool chain for additional information on
+  /// directories to search.
+  //
+  // FIXME: This should be in CompilationInfo.
+  std::string GetProgramPath(StringRef Name, const ToolChain &TC) const;
+
+  /// HandleAutocompletions - Handle --autocomplete by searching and printing
+  /// possible flags, descriptions, and its arguments.
+  void HandleAutocompletions(StringRef PassedFlags) const;
+
+  /// HandleImmediateArgs - Handle any arguments which should be
+  /// treated before building actions or binding tools.
+  ///
+  /// \return Whether any compilation should be built for this
+  /// invocation.
+  bool HandleImmediateArgs(const Compilation &C);
+
+  /// ConstructAction - Construct the appropriate action to do for
+  /// \p Phase on the \p Input, taking in to account arguments
+  /// like -fsyntax-only or --analyze.
+  Action *ConstructPhaseAction(
+      Compilation &C, const llvm::opt::ArgList &Args, phases::ID Phase,
+      Action *Input,
+      Action::OffloadKind TargetDeviceOffloadKind = Action::OFK_None) const;
+
+  /// BuildJobsForAction - Construct the jobs to perform for the action \p A and
+  /// return an InputInfo for the result of running \p A.  Will only construct
+  /// jobs for a given (Action, ToolChain, BoundArch, DeviceKind) tuple once.
+  InputInfo
+  BuildJobsForAction(Compilation &C, const Action *A, const ToolChain *TC,
+                     StringRef BoundArch, bool AtTopLevel, bool MultipleArchs,
+                     const char *LinkingOutput,
+                     std::map<std::pair<const Action *, std::string>, InputInfo>
+                         &CachedResults,
+                     Action::OffloadKind TargetDeviceOffloadKind) const;
+
+  /// Returns the default name for linked images (e.g., "a.out").
+  const char *getDefaultImageName() const;
+
+  /// GetNamedOutputPath - Return the name to use for the output of
+  /// the action \p JA. The result is appended to the compilation's
+  /// list of temporary or result files, as appropriate.
+  ///
+  /// \param C - The compilation.
+  /// \param JA - The action of interest.
+  /// \param BaseInput - The original input file that this action was
+  /// triggered by.
+  /// \param BoundArch - The bound architecture.
+  /// \param AtTopLevel - Whether this is a "top-level" action.
+  /// \param MultipleArchs - Whether multiple -arch options were supplied.
+  /// \param NormalizedTriple - The normalized triple of the relevant target.
+  const char *GetNamedOutputPath(Compilation &C, const JobAction &JA,
+                                 const char *BaseInput, StringRef BoundArch,
+                                 bool AtTopLevel, bool MultipleArchs,
+                                 StringRef NormalizedTriple) const;
+
+  /// GetTemporaryPath - Return the pathname of a temporary file to use
+  /// as part of compilation; the file will have the given prefix and suffix.
+  ///
+  /// GCC goes to extra lengths here to be a bit more robust.
+  std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const;
+
+  /// GetTemporaryDirectory - Return the pathname of a temporary directory to
+  /// use as part of compilation; the directory will have the given prefix.
+  std::string GetTemporaryDirectory(StringRef Prefix) const;
+
+  /// Return the pathname of the pch file in clang-cl mode.
+  std::string GetClPchPath(Compilation &C, StringRef BaseName) const;
+
+  /// ShouldUseClangCompiler - Should the clang compiler be used to
+  /// handle this action.
+  bool ShouldUseClangCompiler(const JobAction &JA) const;
+
+  /// Returns true if we are performing any kind of LTO.
+  bool isUsingLTO() const { return LTOMode != LTOK_None; }
+
+  /// Get the specific kind of LTO being performed.
+  LTOKind getLTOMode() const { return LTOMode; }
+
+private:
+
+  /// Tries to load options from configuration file.
+  ///
+  /// \returns true if error occurred.
+  bool loadConfigFile();
+
+  /// Read options from the specified file.
+  ///
+  /// \param [in] FileName File to read.
+  /// \returns true, if error occurred while reading.
+  bool readConfigFile(StringRef FileName);
+
+  /// Set the driver mode (cl, gcc, etc) from an option string of the form
+  /// --driver-mode=<mode>.
+  void setDriverModeFromOption(StringRef Opt);
+
+  /// Parse the \p Args list for LTO options and record the type of LTO
+  /// compilation based on which -f(no-)?lto(=.*)? option occurs last.
+  void setLTOMode(const llvm::opt::ArgList &Args);
+
+  /// Retrieves a ToolChain for a particular \p Target triple.
+  ///
+  /// Will cache ToolChains for the life of the driver object, and create them
+  /// on-demand.
+  const ToolChain &getToolChain(const llvm::opt::ArgList &Args,
+                                const llvm::Triple &Target) const;
+
+  /// @}
+
+  /// Get bitmasks for which option flags to include and exclude based on
+  /// the driver mode.
+  std::pair<unsigned, unsigned> getIncludeExcludeOptionFlagMasks(bool IsClCompatMode) const;
+
+  /// Helper used in BuildJobsForAction.  Doesn't use the cache when building
+  /// jobs specifically for the given action, but will use the cache when
+  /// building jobs for the Action's inputs.
+  InputInfo BuildJobsForActionNoCache(
+      Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
+      bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
+      std::map<std::pair<const Action *, std::string>, InputInfo>
+          &CachedResults,
+      Action::OffloadKind TargetDeviceOffloadKind) const;
+
+public:
+  /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
+  /// return the grouped values as integers. Numbers which are not
+  /// provided are set to 0.
+  ///
+  /// \return True if the entire string was parsed (9.2), or all
+  /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
+  /// groups were parsed but extra characters remain at the end.
+  static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor,
+                                unsigned &Micro, bool &HadExtra);
+
+  /// Parse digits from a string \p Str and fulfill \p Digits with
+  /// the parsed numbers. This method assumes that the max number of
+  /// digits to look for is equal to Digits.size().
+  ///
+  /// \return True if the entire string was parsed and there are
+  /// no extra characters remaining at the end.
+  static bool GetReleaseVersion(StringRef Str,
+                                MutableArrayRef<unsigned> Digits);
+  /// Compute the default -fmodule-cache-path.
+  static void getDefaultModuleCachePath(SmallVectorImpl<char> &Result);
+};
+
+/// \return True if the last defined optimization level is -Ofast.
+/// And False otherwise.
+bool isOptimizationLevelFast(const llvm::opt::ArgList &Args);
+
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/DriverDiagnostic.h b/clang-r353983e/include/clang/Driver/DriverDiagnostic.h
new file mode 100644
index 00000000..ec2f8b40
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/DriverDiagnostic.h
@@ -0,0 +1,14 @@
+//===--- DiagnosticDriver.h - Diagnostics for libdriver ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_DRIVERDIAGNOSTIC_H
+#define LLVM_CLANG_DRIVER_DRIVERDIAGNOSTIC_H
+
+#include "clang/Basic/DiagnosticDriver.h"
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/Job.h b/clang-r353983e/include/clang/Driver/Job.h
new file mode 100644
index 00000000..41d97228
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Job.h
@@ -0,0 +1,204 @@
+//===- Job.h - Commands to Execute ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_JOB_H
+#define LLVM_CLANG_DRIVER_JOB_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/Option/Option.h"
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace clang {
+namespace driver {
+
+class Action;
+class InputInfo;
+class Tool;
+
+struct CrashReportInfo {
+  StringRef Filename;
+  StringRef VFSPath;
+
+  CrashReportInfo(StringRef Filename, StringRef VFSPath)
+      : Filename(Filename), VFSPath(VFSPath) {}
+};
+
+/// Command - An executable path/name and argument vector to
+/// execute.
+class Command {
+  /// Source - The action which caused the creation of this job.
+  const Action &Source;
+
+  /// Tool - The tool which caused the creation of this job.
+  const Tool &Creator;
+
+  /// The executable to run.
+  const char *Executable;
+
+  /// The list of program arguments (not including the implicit first
+  /// argument, which will be the executable).
+  llvm::opt::ArgStringList Arguments;
+
+  /// The list of program arguments which are inputs.
+  llvm::opt::ArgStringList InputFilenames;
+
+  /// Whether to print the input filenames when executing.
+  bool PrintInputFilenames = false;
+
+  /// Response file name, if this command is set to use one, or nullptr
+  /// otherwise
+  const char *ResponseFile = nullptr;
+
+  /// The input file list in case we need to emit a file list instead of a
+  /// proper response file
+  llvm::opt::ArgStringList InputFileList;
+
+  /// String storage if we need to create a new argument to specify a response
+  /// file
+  std::string ResponseFileFlag;
+
+  /// See Command::setEnvironment
+  std::vector<const char *> Environment;
+
+  /// When a response file is needed, we try to put most arguments in an
+  /// exclusive file, while others remains as regular command line arguments.
+  /// This functions fills a vector with the regular command line arguments,
+  /// argv, excluding the ones passed in a response file.
+  void buildArgvForResponseFile(llvm::SmallVectorImpl<const char *> &Out) const;
+
+  /// Encodes an array of C strings into a single string separated by whitespace.
+  /// This function will also put in quotes arguments that have whitespaces and
+  /// will escape the regular backslashes (used in Windows paths) and quotes.
+  /// The results are the contents of a response file, written into a raw_ostream.
+  void writeResponseFile(raw_ostream &OS) const;
+
+public:
+  Command(const Action &Source, const Tool &Creator, const char *Executable,
+          const llvm::opt::ArgStringList &Arguments,
+          ArrayRef<InputInfo> Inputs);
+  // FIXME: This really shouldn't be copyable, but is currently copied in some
+  // error handling in Driver::generateCompilationDiagnostics.
+  Command(const Command &) = default;
+  virtual ~Command() = default;
+
+  virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
+                     CrashReportInfo *CrashInfo = nullptr) const;
+
+  virtual int Execute(ArrayRef<Optional<StringRef>> Redirects,
+                      std::string *ErrMsg, bool *ExecutionFailed) const;
+
+  /// getSource - Return the Action which caused the creation of this job.
+  const Action &getSource() const { return Source; }
+
+  /// getCreator - Return the Tool which caused the creation of this job.
+  const Tool &getCreator() const { return Creator; }
+
+  /// Set to pass arguments via a response file when launching the command
+  void setResponseFile(const char *FileName);
+
+  /// Set an input file list, necessary if we need to use a response file but
+  /// the tool being called only supports input files lists.
+  void setInputFileList(llvm::opt::ArgStringList List) {
+    InputFileList = std::move(List);
+  }
+
+  /// Sets the environment to be used by the new process.
+  /// \param NewEnvironment An array of environment variables.
+  /// \remark If the environment remains unset, then the environment
+  ///         from the parent process will be used.
+  void setEnvironment(llvm::ArrayRef<const char *> NewEnvironment);
+
+  const char *getExecutable() const { return Executable; }
+
+  const llvm::opt::ArgStringList &getArguments() const { return Arguments; }
+
+  /// Print a command argument, and optionally quote it.
+  static void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
+
+  /// Set whether to print the input filenames when executing.
+  void setPrintInputFilenames(bool P) { PrintInputFilenames = P; }
+};
+
+/// Like Command, but with a fallback which is executed in case
+/// the primary command crashes.
+class FallbackCommand : public Command {
+public:
+  FallbackCommand(const Action &Source_, const Tool &Creator_,
+                  const char *Executable_,
+                  const llvm::opt::ArgStringList &Arguments_,
+                  ArrayRef<InputInfo> Inputs,
+                  std::unique_ptr<Command> Fallback_);
+
+  void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
+             CrashReportInfo *CrashInfo = nullptr) const override;
+
+  int Execute(ArrayRef<Optional<StringRef>> Redirects, std::string *ErrMsg,
+              bool *ExecutionFailed) const override;
+
+private:
+  std::unique_ptr<Command> Fallback;
+};
+
+/// Like Command, but always pretends that the wrapped command succeeded.
+class ForceSuccessCommand : public Command {
+public:
+  ForceSuccessCommand(const Action &Source_, const Tool &Creator_,
+                      const char *Executable_,
+                      const llvm::opt::ArgStringList &Arguments_,
+                      ArrayRef<InputInfo> Inputs);
+
+  void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
+             CrashReportInfo *CrashInfo = nullptr) const override;
+
+  int Execute(ArrayRef<Optional<StringRef>> Redirects, std::string *ErrMsg,
+              bool *ExecutionFailed) const override;
+};
+
+/// JobList - A sequence of jobs to perform.
+class JobList {
+public:
+  using list_type = SmallVector<std::unique_ptr<Command>, 4>;
+  using size_type = list_type::size_type;
+  using iterator = llvm::pointee_iterator<list_type::iterator>;
+  using const_iterator = llvm::pointee_iterator<list_type::const_iterator>;
+
+private:
+  list_type Jobs;
+
+public:
+  void Print(llvm::raw_ostream &OS, const char *Terminator,
+             bool Quote, CrashReportInfo *CrashInfo = nullptr) const;
+
+  /// Add a job to the list (taking ownership).
+  void addJob(std::unique_ptr<Command> J) { Jobs.push_back(std::move(J)); }
+
+  /// Clear the job list.
+  void clear();
+
+  const list_type &getJobs() const { return Jobs; }
+
+  bool empty() const { return Jobs.empty(); }
+  size_type size() const { return Jobs.size(); }
+  iterator begin() { return Jobs.begin(); }
+  const_iterator begin() const { return Jobs.begin(); }
+  iterator end() { return Jobs.end(); }
+  const_iterator end() const { return Jobs.end(); }
+};
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_JOB_H
diff --git a/clang-r353983e/include/clang/Driver/Multilib.h b/clang-r353983e/include/clang/Driver/Multilib.h
new file mode 100644
index 00000000..353aefde
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Multilib.h
@@ -0,0 +1,196 @@
+//===- Multilib.h -----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_MULTILIB_H
+#define LLVM_CLANG_DRIVER_MULTILIB_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
+#include <cassert>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace clang {
+namespace driver {
+
+/// This corresponds to a single GCC Multilib, or a segment of one controlled
+/// by a command line flag
+class Multilib {
+public:
+  using flags_list = std::vector<std::string>;
+
+private:
+  std::string GCCSuffix;
+  std::string OSSuffix;
+  std::string IncludeSuffix;
+  flags_list Flags;
+
+public:
+  Multilib(StringRef GCCSuffix = {}, StringRef OSSuffix = {},
+           StringRef IncludeSuffix = {});
+
+  /// Get the detected GCC installation path suffix for the multi-arch
+  /// target variant. Always starts with a '/', unless empty
+  const std::string &gccSuffix() const {
+    assert(GCCSuffix.empty() ||
+           (StringRef(GCCSuffix).front() == '/' && GCCSuffix.size() > 1));
+    return GCCSuffix;
+  }
+
+  /// Set the GCC installation path suffix.
+  Multilib &gccSuffix(StringRef S);
+
+  /// Get the detected os path suffix for the multi-arch
+  /// target variant. Always starts with a '/', unless empty
+  const std::string &osSuffix() const {
+    assert(OSSuffix.empty() ||
+           (StringRef(OSSuffix).front() == '/' && OSSuffix.size() > 1));
+    return OSSuffix;
+  }
+
+  /// Set the os path suffix.
+  Multilib &osSuffix(StringRef S);
+
+  /// Get the include directory suffix. Always starts with a '/', unless
+  /// empty
+  const std::string &includeSuffix() const {
+    assert(IncludeSuffix.empty() ||
+           (StringRef(IncludeSuffix).front() == '/' && IncludeSuffix.size() > 1));
+    return IncludeSuffix;
+  }
+
+  /// Set the include directory suffix
+  Multilib &includeSuffix(StringRef S);
+
+  /// Get the flags that indicate or contraindicate this multilib's use
+  /// All elements begin with either '+' or '-'
+  const flags_list &flags() const { return Flags; }
+  flags_list &flags() { return Flags; }
+
+  /// Add a flag to the flags list
+  /// \p Flag must be a flag accepted by the driver with its leading '-' removed,
+  ///     and replaced with either:
+  ///       '-' which contraindicates using this multilib with that flag
+  ///     or:
+  ///       '+' which promotes using this multilib in the presence of that flag
+  ///     otherwise '-print-multi-lib' will not emit them correctly.
+  Multilib &flag(StringRef F) {
+    assert(F.front() == '+' || F.front() == '-');
+    Flags.push_back(F);
+    return *this;
+  }
+
+  LLVM_DUMP_METHOD void dump() const;
+  /// print summary of the Multilib
+  void print(raw_ostream &OS) const;
+
+  /// Check whether any of the 'against' flags contradict the 'for' flags.
+  bool isValid() const;
+
+  /// Check whether the default is selected
+  bool isDefault() const
+  { return GCCSuffix.empty() && OSSuffix.empty() && IncludeSuffix.empty(); }
+
+  bool operator==(const Multilib &Other) const;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const Multilib &M);
+
+class MultilibSet {
+public:
+  using multilib_list = std::vector<Multilib>;
+  using iterator = multilib_list::iterator;
+  using const_iterator = multilib_list::const_iterator;
+  using IncludeDirsFunc =
+      std::function<std::vector<std::string>(const Multilib &M)>;
+  using FilterCallback = llvm::function_ref<bool(const Multilib &)>;
+
+private:
+  multilib_list Multilibs;
+  IncludeDirsFunc IncludeCallback;
+  IncludeDirsFunc FilePathsCallback;
+
+public:
+  MultilibSet() = default;
+
+  /// Add an optional Multilib segment
+  MultilibSet &Maybe(const Multilib &M);
+
+  /// Add a set of mutually incompatible Multilib segments
+  MultilibSet &Either(const Multilib &M1, const Multilib &M2);
+  MultilibSet &Either(const Multilib &M1, const Multilib &M2,
+                      const Multilib &M3);
+  MultilibSet &Either(const Multilib &M1, const Multilib &M2,
+                      const Multilib &M3, const Multilib &M4);
+  MultilibSet &Either(const Multilib &M1, const Multilib &M2,
+                      const Multilib &M3, const Multilib &M4,
+                      const Multilib &M5);
+  MultilibSet &Either(ArrayRef<Multilib> Ms);
+
+  /// Filter out some subset of the Multilibs using a user defined callback
+  MultilibSet &FilterOut(FilterCallback F);
+
+  /// Filter out those Multilibs whose gccSuffix matches the given expression
+  MultilibSet &FilterOut(const char *Regex);
+
+  /// Add a completed Multilib to the set
+  void push_back(const Multilib &M);
+
+  /// Union this set of multilibs with another
+  void combineWith(const MultilibSet &MS);
+
+  /// Remove all of the multilibs from the set
+  void clear() { Multilibs.clear(); }
+
+  iterator begin() { return Multilibs.begin(); }
+  const_iterator begin() const { return Multilibs.begin(); }
+
+  iterator end() { return Multilibs.end(); }
+  const_iterator end() const { return Multilibs.end(); }
+
+  /// Pick the best multilib in the set, \returns false if none are compatible
+  bool select(const Multilib::flags_list &Flags, Multilib &M) const;
+
+  unsigned size() const { return Multilibs.size(); }
+
+  LLVM_DUMP_METHOD void dump() const;
+  void print(raw_ostream &OS) const;
+
+  MultilibSet &setIncludeDirsCallback(IncludeDirsFunc F) {
+    IncludeCallback = std::move(F);
+    return *this;
+  }
+
+  const IncludeDirsFunc &includeDirsCallback() const { return IncludeCallback; }
+
+  MultilibSet &setFilePathsCallback(IncludeDirsFunc F) {
+    FilePathsCallback = std::move(F);
+    return *this;
+  }
+
+  const IncludeDirsFunc &filePathsCallback() const { return FilePathsCallback; }
+
+private:
+  /// Apply the filter to Multilibs and return the subset that remains
+  static multilib_list filterCopy(FilterCallback F, const multilib_list &Ms);
+
+  /// Apply the filter to the multilib_list, removing those that don't match
+  static void filterInPlace(FilterCallback F, multilib_list &Ms);
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const MultilibSet &MS);
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_MULTILIB_H
diff --git a/clang-r353983e/include/clang/Driver/Options.h b/clang-r353983e/include/clang/Driver/Options.h
new file mode 100644
index 00000000..f8963d48
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Options.h
@@ -0,0 +1,54 @@
+//===--- Options.h - Option info & table ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_OPTIONS_H
+#define LLVM_CLANG_DRIVER_OPTIONS_H
+
+#include <memory>
+
+namespace llvm {
+namespace opt {
+class OptTable;
+}
+}
+
+namespace clang {
+namespace driver {
+
+namespace options {
+/// Flags specifically for clang options.  Must not overlap with
+/// llvm::opt::DriverFlag.
+enum ClangFlags {
+  DriverOption = (1 << 4),
+  LinkerInput = (1 << 5),
+  NoArgumentUnused = (1 << 6),
+  Unsupported = (1 << 7),
+  CoreOption = (1 << 8),
+  CLOption = (1 << 9),
+  CC1Option = (1 << 10),
+  CC1AsOption = (1 << 11),
+  NoDriverOption = (1 << 12),
+  Ignored = (1 << 13)
+};
+
+enum ID {
+    OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  OPT_##ID,
+#include "clang/Driver/Options.inc"
+    LastOption
+#undef OPTION
+  };
+}
+
+std::unique_ptr<llvm::opt::OptTable> createDriverOptTable();
+}
+}
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/Options.inc b/clang-r353983e/include/clang/Driver/Options.inc
new file mode 100644
index 00000000..cacabe4a
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Options.inc
@@ -0,0 +1,3609 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Option Parsing Definitions                                                 *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+/////////
+// Prefixes
+
+#ifdef PREFIX
+#define COMMA ,
+PREFIX(prefix_0, {nullptr})
+PREFIX(prefix_1, {"-" COMMA nullptr})
+PREFIX(prefix_4, {"-" COMMA "--" COMMA nullptr})
+PREFIX(prefix_3, {"--" COMMA nullptr})
+PREFIX(prefix_2, {"/" COMMA "-" COMMA nullptr})
+#undef COMMA
+#endif // PREFIX
+
+/////////
+// Groups
+
+#ifdef OPTION
+OPTION(nullptr, "<action group>", Action_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<CompileOnly group>", CompileOnly_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<g group>", DebugInfo_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<W/R group>", Diag_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<I group>", I_Group, Group, IncludePath_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<I/i group>", IncludePath_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<T/e/s/t/u group>", Link_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<M group>", M_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<O group>", O_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<Preprocessor group>", Preprocessor_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<R group>", R_Group, Group, Diag_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<R (with value) group>", R_value_Group, Group, R_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<Static analyzer group>", StaticAnalyzer_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<T group>", T_Group, Group, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<W group>", W_Group, Group, Diag_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<W (with value) group>", W_value_Group, Group, W_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "</M group>", _SLASH_M_Group, Group, cl_compile_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "</volatile group>", _SLASH_volatile_Group, Group, cl_compile_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang-cl options>", cl_Group, Group, INVALID, INVALID, nullptr, 0, 0,
+       "CL.EXE COMPATIBILITY OPTIONS", nullptr, nullptr)
+OPTION(nullptr, "<clang-cl compile-only options>", cl_compile_Group, Group, cl_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang-cl ignored options>", cl_ignored_Group, Group, cl_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang i group>", clang_i_Group, Group, i_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang ignored f group>", clang_ignored_f_Group, Group, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang_ignored_gcc_optimization_f_Group>", clang_ignored_gcc_optimization_f_Group, Group, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang legacy flags>", clang_ignored_legacy_options_Group, Group, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang ignored m group>", clang_ignored_m_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<d group>", d_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<f group>", f_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<f (clang-only) group>", f_clang_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<gN group>", gN_Group, Group, g_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<gTune group>", gTune_Group, Group, g_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<g group>", g_Group, Group, DebugInfo_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<g flags group>", g_flags_Group, Group, DebugInfo_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<gfortran group>", gfortran_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<ggdbN group>", ggdbN_Group, Group, gN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<i group>", i_Group, Group, IncludePath_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang internal options>", internal_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<clang debug/development internal options>", internal_debug_Group, Group, internal_Group, INVALID, nullptr, 0, 0,
+       "DEBUG/DEVELOPMENT OPTIONS", nullptr, nullptr)
+OPTION(nullptr, "<clang driver internal options>", internal_driver_Group, Group, internal_Group, INVALID, nullptr, 0, 0,
+       "DRIVER OPTIONS", nullptr, nullptr)
+OPTION(nullptr, "<m group>", m_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<aarch64 features group>", m_aarch64_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<amdgpu features group>", m_amdgpu_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<arm features group>", m_arm_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<hexagon features group>", m_hexagon_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<hexagon features group>", m_hexagon_Features_HVX_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<m libc group>", m_libc_Group, Group, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<mips features group>", m_mips_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<ppc features group>", m_ppc_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<riscv features group>", m_riscv_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<wasm features group>", m_wasm_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<x86 features group>", m_x86_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<opencl group>", opencl_Group, Group, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<pedantic group>", pedantic_Group, Group, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<reserved libs group>", reserved_lib_Group, Group, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(nullptr, "<u group>", u_Group, Group, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+
+//////////
+// Options
+
+OPTION(prefix_0, "<input>", INPUT, Input, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_0, "<unknown>", UNKNOWN, Unknown, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "###", _HASH_HASH_HASH, Flag, INVALID, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Print (but do not run) the commands to run for this compilation", nullptr, nullptr)
+OPTION(prefix_2, "?", _SLASH_QUESTION, Flag, cl_Group, help, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Display available options", nullptr, nullptr)
+OPTION(prefix_1, "A-", A_DASH, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "add-plugin", add_plugin, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use the named plugin action in addition to the default action", "<name>", nullptr)
+OPTION(prefix_2, "AI", _SLASH_AI, JoinedOrSeparate, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "all-warnings", _all_warnings, Flag, INVALID, Wall, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "all_load", all__load, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "allowable_client", allowable__client, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "analyze-auto", _analyze_auto, Flag, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyze-function=", analyze_function_EQ, Joined, INVALID, analyze_function, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyze-function", analyze_function, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Run analysis on specific function (for C++ include parameters in name)", nullptr, nullptr)
+OPTION(prefix_2, "analyze-", _SLASH_analyze_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-checker-help", analyzer_checker_help, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Display the list of analyzer checkers that are available", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-checker=", analyzer_checker_EQ, Joined, INVALID, analyzer_checker, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-checker", analyzer_checker, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Choose analyzer checkers to enable", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-config-compatibility-mode=", analyzer_config_compatibility_mode_EQ, Joined, INVALID, analyzer_config_compatibility_mode, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-config-compatibility-mode", analyzer_config_compatibility_mode, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't emit errors on invalid analyzer-config inputs", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-config-help", analyzer_config_help, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Display the list of -analyzer-config options", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-config", analyzer_config, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Choose analyzer options to enable", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-constraints=", analyzer_constraints_EQ, Joined, INVALID, analyzer_constraints, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-constraints", analyzer_constraints, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Source Code Analysis - Symbolic Constraint Engines", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-disable-all-checks", analyzer_disable_all_checks, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable all static analyzer checks", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-disable-checker=", analyzer_disable_checker_EQ, Joined, INVALID, analyzer_disable_checker, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-disable-checker", analyzer_disable_checker, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Choose analyzer checkers to disable", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-disable-retry-exhausted", analyzer_disable_retry_exhausted, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-display-progress", analyzer_display_progress, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit verbose output about the analyzer's progress", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-dump-egraph=", analyzer_dump_egraph_EQ, Joined, INVALID, analyzer_dump_egraph, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-dump-egraph", analyzer_dump_egraph, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump exploded graph to the specified file", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-inline-max-stack-depth=", analyzer_inline_max_stack_depth_EQ, Joined, INVALID, analyzer_inline_max_stack_depth, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-inline-max-stack-depth", analyzer_inline_max_stack_depth, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Bound on stack depth while inlining (4 by default)", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-inlining-mode=", analyzer_inlining_mode_EQ, Joined, INVALID, analyzer_inlining_mode, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-inlining-mode", analyzer_inlining_mode, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Specify the function selection heuristic used during inlining", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-list-enabled-checkers", analyzer_list_enabled_checkers, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Display the list of enabled analyzer checkers", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-max-loop", analyzer_max_loop, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "The maximum number of times the analyzer will go through a loop", nullptr, nullptr)
+OPTION(prefix_3, "analyzer-no-default-checks", _analyzer_no_default_checks, Flag, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-opt-analyze-headers", analyzer_opt_analyze_headers, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Force the static analyzer to analyze functions defined in header files", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-opt-analyze-nested-blocks", analyzer_opt_analyze_nested_blocks, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Analyze the definitions of blocks in addition to functions", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-output=", analyzer_output_EQ, Joined, INVALID, analyzer_output, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "analyzer-output", _analyzer_output, JoinedOrSeparate, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-output", analyzer_output, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Source Code Analysis - Output Options", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-purge=", analyzer_purge_EQ, Joined, INVALID, analyzer_purge, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-purge", analyzer_purge, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Source Code Analysis - Dead Symbol Removal Frequency", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-stats", analyzer_stats, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Print internal analyzer statistics.", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-store=", analyzer_store_EQ, Joined, INVALID, analyzer_store, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "analyzer-store", analyzer_store, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Source Code Analysis - Abstract Memory Store Models", nullptr, nullptr)
+OPTION(prefix_1, "analyzer-viz-egraph-graphviz", analyzer_viz_egraph_graphviz, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Display exploded graph using GraphViz", nullptr, nullptr)
+OPTION(prefix_3, "analyze", _analyze, Flag, INVALID, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Run the static analyzer", nullptr, nullptr)
+OPTION(prefix_1, "analyze", analyze, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Run static analysis engine", nullptr, nullptr)
+OPTION(prefix_4, "ansi", ansi, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "arch:", _SLASH_arch, Joined, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Set architecture for code generation", nullptr, nullptr)
+OPTION(prefix_1, "arch_errors_fatal", arch__errors__fatal, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "arch_only", arch__only, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "arch", arch, Separate, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "arcmt-check", arcmt_check, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Check for ARC migration issues that need manual handling", nullptr, nullptr)
+OPTION(prefix_1, "arcmt-migrate-emit-errors", arcmt_migrate_emit_arc_errors, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Emit ARC errors even if the migrator can fix them", nullptr, nullptr)
+OPTION(prefix_1, "arcmt-migrate-report-output", arcmt_migrate_report_output, Separate, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Output path for the plist report", nullptr, nullptr)
+OPTION(prefix_1, "arcmt-migrate", arcmt_migrate, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply modifications and produces temporary files that conform to ARC", nullptr, nullptr)
+OPTION(prefix_1, "arcmt-modify", arcmt_modify, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply modifications to files to conform to ARC", nullptr, nullptr)
+OPTION(prefix_3, "assemble", _assemble, Flag, INVALID, S, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "assert=", _assert_EQ, Joined, INVALID, A, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "assert", _assert, Separate, INVALID, A, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ast-dump-all", ast_dump_all, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and then debug dump them, forcing deserialization", nullptr, nullptr)
+OPTION(prefix_1, "ast-dump-filter", ast_dump_filter, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use with -ast-dump or -ast-print to dump/print only AST declaration nodes having a certain substring in a qualified name. Use -ast-list to list all filterable declaration node names.", "<dump_filter>", nullptr)
+OPTION(prefix_1, "ast-dump-lookups", ast_dump_lookups, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and then debug dump their name lookup tables", nullptr, nullptr)
+OPTION(prefix_1, "ast-dump", ast_dump, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and then debug dump them", nullptr, nullptr)
+OPTION(prefix_1, "ast-list", ast_list, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and print the list of declaration node qualified names", nullptr, nullptr)
+OPTION(prefix_1, "ast-merge", ast_merge, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Merge the given AST file into the translation unit being compiled.", "<ast file>", nullptr)
+OPTION(prefix_1, "ast-print", ast_print, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and then pretty-print them", nullptr, nullptr)
+OPTION(prefix_1, "ast-view", ast_view, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and view them with GraphViz", nullptr, nullptr)
+OPTION(prefix_3, "autocomplete=", autocomplete, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "aux-triple", aux_triple, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Auxiliary target triple.", nullptr, nullptr)
+OPTION(prefix_1, "A", A, JoinedOrSeparate, gfortran_Group, INVALID, nullptr, RenderJoined, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "a", a, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "bigobj", _SLASH_bigobj, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "bind_at_load", bind__at__load, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "bootclasspath=", _bootclasspath_EQ, Joined, INVALID, fbootclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "bootclasspath", _bootclasspath, Separate, INVALID, fbootclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Brepro-", _SLASH_Brepro_, Flag, cl_Group, mincremental_linker_compatible, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Emit an object file which cannot be reproduced over time", nullptr, nullptr)
+OPTION(prefix_2, "Brepro", _SLASH_Brepro, Flag, cl_Group, mno_incremental_linker_compatible, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Emit an object file which can be reproduced over time", nullptr, nullptr)
+OPTION(prefix_2, "Bt+", _SLASH_Bt_plus, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Bt", _SLASH_Bt, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "building-pch-with-obj", building_pch_with_obj, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "This compilation is part of building a PCH with corresponding object file.", nullptr, nullptr)
+OPTION(prefix_1, "bundle_loader", bundle__loader, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "bundle", bundle, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "B", B, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0,
+       "Add <dir> to search path for binaries and object files used implicitly", "<dir>", nullptr)
+OPTION(prefix_1, "b", b, JoinedOrSeparate, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "c-isystem", c_isystem, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add directory to the C SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "cc1as", cc1as, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "cc1", cc1, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ccc-arcmt-check", ccc_arcmt_check, Flag, internal_driver_Group, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "Check for ARC migration issues that need manual handling", nullptr, nullptr)
+OPTION(prefix_1, "ccc-arcmt-migrate", ccc_arcmt_migrate, Separate, internal_driver_Group, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "Apply modifications and produces temporary files that conform to ARC", nullptr, nullptr)
+OPTION(prefix_1, "ccc-arcmt-modify", ccc_arcmt_modify, Flag, internal_driver_Group, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "Apply modifications to files to conform to ARC", nullptr, nullptr)
+OPTION(prefix_1, "ccc-gcc-name", ccc_gcc_name, Separate, internal_driver_Group, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "Name for native GCC compiler", "<gcc-path>", nullptr)
+OPTION(prefix_1, "ccc-install-dir", ccc_install_dir, Separate, internal_debug_Group, INVALID, nullptr, DriverOption | HelpHidden | CoreOption, 0,
+       "Simulate installation in the given directory", nullptr, nullptr)
+OPTION(prefix_1, "ccc-objcmt-migrate", ccc_objcmt_migrate, Separate, internal_driver_Group, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "Apply modifications and produces temporary files to migrate to modern ObjC syntax", nullptr, nullptr)
+OPTION(prefix_1, "ccc-print-bindings", ccc_print_bindings, Flag, internal_debug_Group, INVALID, nullptr, DriverOption | HelpHidden | CoreOption, 0,
+       "Show bindings of tools to actions", nullptr, nullptr)
+OPTION(prefix_1, "ccc-print-phases", ccc_print_phases, Flag, internal_debug_Group, INVALID, nullptr, DriverOption | HelpHidden | CoreOption, 0,
+       "Dump list of actions to perform", nullptr, nullptr)
+OPTION(prefix_1, "ccc-", ccc_, Joined, internal_Group, INVALID, nullptr, Unsupported | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "CC", CC, Flag, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Include comments from within macros in preprocessed output", nullptr, nullptr)
+OPTION(prefix_1, "cfg-add-implicit-dtors", analysis_CFGAddImplicitDtors, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add C++ implicit destructors to CFGs for all analyses", nullptr, nullptr)
+OPTION(prefix_1, "cfguard", cfguard, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Emit tables required for Windows Control Flow Guard.", nullptr, nullptr)
+OPTION(prefix_2, "cgthreads", _SLASH_cgthreads, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "chain-include", chain_include, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include and chain a header file after turning it into PCH", "<file>", nullptr)
+OPTION(prefix_1, "cl-denorms-are-zero", cl_denorms_are_zero, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Allow denormals to be flushed to zero.", nullptr, nullptr)
+OPTION(prefix_1, "cl-ext=", cl_ext_EQ, CommaJoined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "OpenCL only. Enable or disable OpenCL extensions. The argument is a comma-separated sequence of one or more extension names, each prefixed by '+' or '-'.", nullptr, nullptr)
+OPTION(prefix_1, "cl-fast-relaxed-math", cl_fast_relaxed_math, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.", nullptr, nullptr)
+OPTION(prefix_1, "cl-finite-math-only", cl_finite_math_only, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.", nullptr, nullptr)
+OPTION(prefix_1, "cl-fp32-correctly-rounded-divide-sqrt", cl_fp32_correctly_rounded_divide_sqrt, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.", nullptr, nullptr)
+OPTION(prefix_1, "cl-kernel-arg-info", cl_kernel_arg_info, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Generate kernel argument metadata.", nullptr, nullptr)
+OPTION(prefix_1, "cl-mad-enable", cl_mad_enable, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Allow use of less precise MAD computations in the generated binary.", nullptr, nullptr)
+OPTION(prefix_1, "cl-no-signed-zeros", cl_no_signed_zeros, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.", nullptr, nullptr)
+OPTION(prefix_1, "cl-opt-disable", cl_opt_disable, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. This option disables all optimizations. By default optimizations are enabled.", nullptr, nullptr)
+OPTION(prefix_1, "cl-single-precision-constant", cl_single_precision_constant, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Treat double precision floating-point constant as single precision constant.", nullptr, nullptr)
+OPTION(prefix_1, "cl-std=", cl_std_EQ, Joined, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL language standard to compile for.", nullptr, "cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,c++")
+OPTION(prefix_1, "cl-strict-aliasing", cl_strict_aliasing, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. This option is added for compatibility with OpenCL 1.0.", nullptr, nullptr)
+OPTION(prefix_1, "cl-uniform-work-group-size", cl_uniform_work_group_size, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel", nullptr, nullptr)
+OPTION(prefix_1, "cl-unsafe-math-optimizations", cl_unsafe_math_optimizations, Flag, opencl_Group, INVALID, nullptr, CC1Option, 0,
+       "OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.", nullptr, nullptr)
+OPTION(prefix_2, "clang:", _SLASH_clang, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Pass <arg> to the clang driver", "<arg>", nullptr)
+OPTION(prefix_3, "CLASSPATH=", _CLASSPATH_EQ, Joined, INVALID, fclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "classpath=", _classpath_EQ, Joined, INVALID, fclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "CLASSPATH", _CLASSPATH, Separate, INVALID, fclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "classpath", _classpath, Separate, INVALID, fclasspath_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "client_name", client__name, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "clr", _SLASH_clr, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "code-completion-at=", code_completion_at_EQ, Joined, INVALID, code_completion_at, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "code-completion-at", code_completion_at, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump code-completion information at a location", "<file>:<line>:<column>", nullptr)
+OPTION(prefix_1, "code-completion-brief-comments", code_completion_brief_comments, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include brief documentation comments in code-completion results.", nullptr, nullptr)
+OPTION(prefix_1, "code-completion-macros", code_completion_macros, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include macros in code-completion results", nullptr, nullptr)
+OPTION(prefix_1, "code-completion-patterns", code_completion_patterns, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include code patterns in code-completion results", nullptr, nullptr)
+OPTION(prefix_1, "code-completion-with-fixits", code_completion_with_fixits, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include code completion results which require small fix-its.", nullptr, nullptr)
+OPTION(prefix_4, "combine", combine, Flag, INVALID, INVALID, nullptr, DriverOption | Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "comments-in-macros", _comments_in_macros, Flag, INVALID, CC, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "comments", _comments, Flag, INVALID, C, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "compatibility_version", compatibility__version, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "compiler-options-dump", compiler_options_dump, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump the compiler configuration options", nullptr, nullptr)
+OPTION(prefix_3, "compile", _compile, Flag, INVALID, c, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "compress-debug-sections=", compress_debug_sections_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "DWARF debug sections compression type", nullptr, nullptr)
+OPTION(prefix_4, "compress-debug-sections", compress_debug_sections, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "DWARF debug sections compression", nullptr, nullptr)
+OPTION(prefix_3, "config-system-dir=", config_system_dir_EQ, Joined, INVALID, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "System directory for configuration files", nullptr, nullptr)
+OPTION(prefix_3, "config-user-dir=", config_user_dir_EQ, Joined, INVALID, INVALID, nullptr, DriverOption | HelpHidden, 0,
+       "User directory for configuration files", nullptr, nullptr)
+OPTION(prefix_3, "config", config, Separate, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Specifies configuration file", nullptr, nullptr)
+OPTION(prefix_3, "constant-cfstrings", _constant_cfstrings, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "coverage-cfg-checksum", coverage_cfg_checksum, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit CFG checksum for functions in .gcno files.", nullptr, nullptr)
+OPTION(prefix_1, "coverage-data-file=", coverage_data_file_EQ, Joined, INVALID, coverage_data_file, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "coverage-data-file", coverage_data_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit coverage data to this filename.", nullptr, nullptr)
+OPTION(prefix_1, "coverage-exit-block-before-body", coverage_exit_block_before_body, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit the exit block before the body blocks in .gcno files.", nullptr, nullptr)
+OPTION(prefix_1, "coverage-no-function-names-in-data", coverage_no_function_names_in_data, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit function names in .gcda files.", nullptr, nullptr)
+OPTION(prefix_1, "coverage-notes-file=", coverage_notes_file_EQ, Joined, INVALID, coverage_notes_file, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "coverage-notes-file", coverage_notes_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit coverage notes to this filename.", nullptr, nullptr)
+OPTION(prefix_1, "coverage-version=", coverage_version_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Four-byte version string for gcov files.", nullptr, nullptr)
+OPTION(prefix_4, "coverage", coverage, Flag, INVALID, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "cpp-precomp", cpp_precomp, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "cpp", cpp, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "cuda-compile-host-device", cuda_compile_host_device, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Compile CUDA code for both host and device (default).  Has no effect on non-CUDA compilations.", nullptr, nullptr)
+OPTION(prefix_3, "cuda-device-only", cuda_device_only, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Compile CUDA code for device only", nullptr, nullptr)
+OPTION(prefix_3, "cuda-gpu-arch=", cuda_gpu_arch_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "CUDA GPU architecture (e.g. sm_35).  May be specified more than once.", nullptr, nullptr)
+OPTION(prefix_3, "cuda-host-only", cuda_host_only, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Compile CUDA code for host only.  Has no effect on non-CUDA compilations.", nullptr, nullptr)
+OPTION(prefix_3, "cuda-include-ptx=", cuda_include_ptx_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.", nullptr, nullptr)
+OPTION(prefix_3, "cuda-noopt-device-debug", cuda_noopt_device_debug, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Enable device-side debug info generation. Disables ptxas optimizations.", nullptr, nullptr)
+OPTION(prefix_3, "cuda-path-ignore-env", cuda_path_ignore_env, Flag, i_Group, INVALID, nullptr, 0, 0,
+       "Ignore environment variables to detect CUDA installation", nullptr, nullptr)
+OPTION(prefix_3, "cuda-path=", cuda_path_EQ, Joined, i_Group, INVALID, nullptr, 0, 0,
+       "CUDA installation path", nullptr, nullptr)
+OPTION(prefix_1, "current_version", current__version, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "cxx-isystem", cxx_isystem, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to the C++ SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "C", C, Flag, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Include comments in preprocessed output", nullptr, nullptr)
+OPTION(prefix_2, "C", _SLASH_C, Flag, cl_Group, C, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't discard comments when preprocessing", nullptr, nullptr)
+OPTION(prefix_1, "c", c, Flag, Action_Group, INVALID, nullptr, DriverOption, 0,
+       "Only run preprocess, compile, and assemble steps", nullptr, nullptr)
+OPTION(prefix_2, "c", _SLASH_c, Flag, cl_Group, c, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Compile only", nullptr, nullptr)
+OPTION(prefix_2, "d1PP", _SLASH_d1PP, Flag, cl_Group, dD, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Retain macro definitions in /E mode", nullptr, nullptr)
+OPTION(prefix_2, "d1reportAllClassLayout", _SLASH_d1reportAllClassLayout, Flag, cl_Group, fdump_record_layouts, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Dump record layout information", nullptr, nullptr)
+OPTION(prefix_2, "d2FastFail", _SLASH_d2FastFail, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "d2Zi+", _SLASH_d2Zi_PLUS, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dA", dA, Flag, d_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dD", dD, Flag, d_Group, INVALID, nullptr, CC1Option, 0,
+       "Print macro definitions in -E mode in addition to normal output", nullptr, nullptr)
+OPTION(prefix_1, "dead_strip", dead__strip, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "debug-forward-template-params", debug_forward_template_params, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit complete descriptions of template parameters in forward declarations", nullptr, nullptr)
+OPTION(prefix_1, "debug-info-kind=", debug_info_kind_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "debug-info-macro", debug_info_macro, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Emit macro debug information", nullptr, nullptr)
+OPTION(prefix_3, "debug=", _debug_EQ, Joined, INVALID, g_Flag, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "debugger-tuning=", debugger_tuning_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "debug", _debug, Flag, INVALID, g_Flag, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "default-function-attr", default_function_attr, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Apply given attribute to all functions", nullptr, nullptr)
+OPTION(prefix_3, "define-macro=", _define_macro_EQ, Joined, INVALID, D, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "define-macro", _define_macro, Separate, INVALID, D, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "defsym", defsym, Separate, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Define a value for a symbol", nullptr, nullptr)
+OPTION(prefix_3, "dependencies", _dependencies, Flag, INVALID, M, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dependency-dot", dependency_dot, Separate, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Filename to write DOT-formatted header dependencies to", nullptr, nullptr)
+OPTION(prefix_1, "dependency-file", dependency_file, Separate, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Filename (or -) to write dependency output to", nullptr, nullptr)
+OPTION(prefix_3, "dependent-lib=", dependent_lib, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add dependent library", nullptr, nullptr)
+OPTION(prefix_1, "detailed-preprocessing-record", detailed_preprocessing_record, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "include a detailed record of preprocessing actions", nullptr, nullptr)
+OPTION(prefix_1, "diagnostic-log-file", diagnostic_log_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Filename (or -) to log diagnostics to", nullptr, nullptr)
+OPTION(prefix_2, "diagnostics:caret", _SLASH_diagnostics_caret, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable caret and column diagnostics (on by default)", nullptr, nullptr)
+OPTION(prefix_2, "diagnostics:classic", _SLASH_diagnostics_classic, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable column and caret diagnostics", nullptr, nullptr)
+OPTION(prefix_2, "diagnostics:column", _SLASH_diagnostics_column, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable caret diagnostics but keep column info", nullptr, nullptr)
+OPTION(prefix_1, "disable-free", disable_free, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable freeing of memory on exit", nullptr, nullptr)
+OPTION(prefix_1, "disable-lifetime-markers", disable_lifetimemarkers, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable lifetime-markers emission even when optimizations are enabled", nullptr, nullptr)
+OPTION(prefix_1, "disable-llvm-optzns", disable_llvm_optzns, Flag, INVALID, disable_llvm_passes, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "disable-llvm-passes", disable_llvm_passes, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use together with -emit-llvm to get pristine LLVM IR from the frontend by not running any LLVM passes at all", nullptr, nullptr)
+OPTION(prefix_1, "disable-llvm-verifier", disable_llvm_verifier, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't run the LLVM IR verifier pass", nullptr, nullptr)
+OPTION(prefix_1, "disable-O0-optnone", disable_O0_optnone, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable adding the optnone attribute to functions at O0", nullptr, nullptr)
+OPTION(prefix_1, "disable-objc-default-synthesize-properties", disable_objc_default_synthesize_properties, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "disable the default synthesis of Objective-C properties", nullptr, nullptr)
+OPTION(prefix_1, "disable-red-zone", disable_red_zone, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not emit code that uses the red zone.", nullptr, nullptr)
+OPTION(prefix_1, "discard-value-names", discard_value_names, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Discard value names in LLVM IR", nullptr, nullptr)
+OPTION(prefix_1, "dI", dI, Flag, d_Group, INVALID, nullptr, CC1Option, 0,
+       "Print include directives in -E mode in addition to normal output", nullptr, nullptr)
+OPTION(prefix_1, "dM", dM, Flag, d_Group, INVALID, nullptr, CC1Option, 0,
+       "Print macro definitions in -E mode instead of normal output", nullptr, nullptr)
+OPTION(prefix_2, "doc", _SLASH_doc, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "driver-mode=", driver_mode, Joined, internal_driver_Group, INVALID, nullptr, CoreOption | DriverOption | HelpHidden, 0,
+       "Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'", nullptr, nullptr)
+OPTION(prefix_1, "dump-coverage-mapping", dump_coverage_mapping, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump the coverage mapping records, for testing", nullptr, nullptr)
+OPTION(prefix_1, "dump-deserialized-decls", dump_deserialized_pch_decls, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump declarations that are deserialized from PCH, for testing", nullptr, nullptr)
+OPTION(prefix_1, "dump-raw-tokens", dump_raw_tokens, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Lex file in raw mode and dump raw tokens", nullptr, nullptr)
+OPTION(prefix_1, "dump-tokens", dump_tokens, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Run preprocessor, dump internal rep of tokens", nullptr, nullptr)
+OPTION(prefix_1, "dumpmachine", dumpmachine, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dumpspecs", dumpspecs, Flag, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dumpversion", dumpversion, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dwarf-column-info", dwarf_column_info, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Turn on column location information.", nullptr, nullptr)
+OPTION(prefix_1, "dwarf-debug-flags", dwarf_debug_flags, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "The string to embed in the Dwarf debug flags record.", nullptr, nullptr)
+OPTION(prefix_1, "dwarf-debug-producer", dwarf_debug_producer, Separate, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "The string to embed in the Dwarf debug AT_producer record.", nullptr, nullptr)
+OPTION(prefix_1, "dwarf-explicit-import", dwarf_explicit_import, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate explicit import from anonymous namespace to containing scope", nullptr, nullptr)
+OPTION(prefix_1, "dwarf-ext-refs", dwarf_ext_refs, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate debug info with external references to clang modules or precompiled headers", nullptr, nullptr)
+OPTION(prefix_1, "dwarf-version=", dwarf_version_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "dyld-prefix=", _dyld_prefix_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "dyld-prefix", _dyld_prefix, Separate, INVALID, _dyld_prefix_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dylib_file", dylib__file, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dylinker_install_name", dylinker__install__name, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dylinker", dylinker, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dynamiclib", dynamiclib, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "dynamic", dynamic, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "D", D, JoinedOrSeparate, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Define <macro> to <value> (or 1 if <value> omitted)", "<macro>=<value>", nullptr)
+OPTION(prefix_2, "D", _SLASH_D, JoinedOrSeparate, cl_Group, D, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Define macro", "<macro[=value]>", nullptr)
+OPTION(prefix_1, "d", d_Flag, Flag, d_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "d", d_Joined, Joined, d_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "EB", EB, Flag, INVALID, mbig_endian, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "EH", _SLASH_EH, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Exception handling model", nullptr, nullptr)
+OPTION(prefix_1, "EL", EL, Flag, INVALID, mlittle_endian, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "emit-ast", emit_ast, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Emit Clang AST files for source inputs", nullptr, nullptr)
+OPTION(prefix_1, "emit-codegen-only", emit_codegen_only, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate machine code, but discard output", nullptr, nullptr)
+OPTION(prefix_1, "emit-header-module", emit_header_module, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate pre-compiled module file from a set of header files", nullptr, nullptr)
+OPTION(prefix_1, "emit-html", emit_html, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Output input source as HTML", nullptr, nullptr)
+OPTION(prefix_1, "emit-llvm-bc", emit_llvm_bc, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs then convert to LLVM, emit .bc file", nullptr, nullptr)
+OPTION(prefix_1, "emit-llvm-only", emit_llvm_only, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Build ASTs and convert to LLVM, discarding output", nullptr, nullptr)
+OPTION(prefix_1, "emit-llvm-uselists", emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Preserve order of LLVM use-lists when serializing", nullptr, nullptr)
+OPTION(prefix_1, "emit-llvm", emit_llvm, Flag, Action_Group, INVALID, nullptr, CC1Option, 0,
+       "Use the LLVM representation for assembler and object files", nullptr, nullptr)
+OPTION(prefix_1, "emit-module-interface", emit_module_interface, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate pre-compiled module file from a C++ module interface", nullptr, nullptr)
+OPTION(prefix_1, "emit-module", emit_module, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate pre-compiled module file from a module map", nullptr, nullptr)
+OPTION(prefix_1, "emit-obj", emit_obj, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit native object files", nullptr, nullptr)
+OPTION(prefix_1, "emit-pch", emit_pch, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate pre-compiled header file", nullptr, nullptr)
+OPTION(prefix_1, "enable-split-dwarf=", enable_split_dwarf_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set DWARF fission mode to either 'split' or 'single'", nullptr, "split,single")
+OPTION(prefix_1, "enable-split-dwarf", enable_split_dwarf, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use DWARF fission in 'split' mode", nullptr, nullptr)
+OPTION(prefix_1, "enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang", enable_trivial_var_init_zero, Joined, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark", nullptr, nullptr)
+OPTION(prefix_3, "encoding=", _encoding_EQ, Joined, INVALID, fencoding_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "encoding", _encoding, Separate, INVALID, fencoding_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "entry", _entry, Flag, INVALID, e, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Eonly", Eonly, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Just run preprocessor, no output (for timings)", nullptr, nullptr)
+OPTION(prefix_2, "EP", _SLASH_EP, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable linemarker output and preprocess to stdout", nullptr, nullptr)
+OPTION(prefix_1, "error-on-deserialized-decl=", error_on_deserialized_pch_decl_EQ, Joined, INVALID, error_on_deserialized_pch_decl, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "error-on-deserialized-decl", error_on_deserialized_pch_decl, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit error if a specific declaration is deserialized from PCH, for testing", nullptr, nullptr)
+OPTION(prefix_2, "errorReport", _SLASH_errorReport, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "execution-charset:", _SLASH_execution_charset, Joined, cl_compile_Group, fexec_charset_EQ, nullptr, CLOption | DriverOption, 0,
+       "Runtime encoding, supports only UTF-8", nullptr, nullptr)
+OPTION(prefix_1, "exported_symbols_list", exported__symbols__list, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "extdirs=", _extdirs_EQ, Joined, INVALID, fextdirs_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "extdirs", _extdirs, Separate, INVALID, fextdirs_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "extra-warnings", _extra_warnings, Flag, INVALID, W_Joined, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "E", E, Flag, Action_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Only run the preprocessor", nullptr, nullptr)
+OPTION(prefix_2, "E", _SLASH_E, Flag, cl_Group, E, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Preprocess to stdout", nullptr, nullptr)
+OPTION(prefix_1, "e", e, JoinedOrSeparate, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "faccess-control", faccess_control, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "faddress-space-map-mangling=", faddress_space_map_mangling_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the mode for address space map based mangling; OpenCL testing purposes only", "<yes|no|target>", nullptr)
+OPTION(prefix_1, "faddrsig", faddrsig, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Emit an address-significance table", nullptr, nullptr)
+OPTION(prefix_1, "faggressive-function-elimination", aggressive_function_elimination_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-commons", align_commons_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-functions=", falign_functions_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-functions", falign_functions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-jumps=", falign_jumps_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-jumps", align_jumps_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-labels=", falign_labels_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-labels", align_labels_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-loops=", falign_loops_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "falign-loops", align_loops_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "faligned-alloc-unavailable", aligned_alloc_unavailable, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Aligned allocation/deallocation functions are unavailable", nullptr, nullptr)
+OPTION(prefix_1, "faligned-allocation", faligned_allocation, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable C++17 aligned allocation functions", nullptr, nullptr)
+OPTION(prefix_1, "faligned-new=", faligned_new_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "faligned-new", anonymous_20, Flag, INVALID, faligned_allocation, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fall-intrinsics", all_intrinsics_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "fallback", _SLASH_fallback, Flag, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Fall back to cl.exe if clang-cl fails to compile", nullptr, nullptr)
+OPTION(prefix_1, "fallow-editor-placeholders", fallow_editor_placeholders, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Treat editor placeholders as valid source code", nullptr, nullptr)
+OPTION(prefix_1, "fallow-half-arguments-and-returns", fallow_half_arguments_and_returns, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow function arguments and returns of type half", nullptr, nullptr)
+OPTION(prefix_1, "fallow-pch-with-compiler-errors", fallow_pch_with_errors, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Accept a PCH file that was created with compiler errors", nullptr, nullptr)
+OPTION(prefix_1, "fallow-unsupported", fallow_unsupported, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "faltivec", faltivec, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fansi-escape-codes", fansi_escape_codes, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Use ANSI escape codes for diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fapple-kext", fapple_kext, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use Apple's kernel extensions ABI", nullptr, nullptr)
+OPTION(prefix_1, "fapple-pragma-pack", fapple_pragma_pack, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable Apple gcc-compatible #pragma pack handling", nullptr, nullptr)
+OPTION(prefix_1, "fapplication-extension", fapplication_extension, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Restrict code to those available for App Extensions", nullptr, nullptr)
+OPTION(prefix_1, "fapply-global-visibility-to-externs", fapply_global_visibility_to_externs, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply global symbol visibility to external declarations without an explicit visibility", nullptr, nullptr)
+OPTION(prefix_1, "fasm-blocks", fasm_blocks, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fasm", fasm, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fassociative-math", fassociative_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fassume-sane-operator-new", fassume_sane_operator_new, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fastcp", fastcp, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fastf", fastf, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fast", fast, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fasynchronous-unwind-tables", fasynchronous_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fauto-profile-accurate", fauto_profile_accurate, Flag, f_Group, fprofile_sample_accurate, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fauto-profile=", fauto_profile_EQ, Joined, INVALID, fprofile_sample_use_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fauto-profile", fauto_profile, Flag, f_Group, fprofile_sample_use, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fautolink", fautolink, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fautomatic", automatic_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "favor", _SLASH_favor, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "FA", _SLASH_FA, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Output assembly code file during compilation", nullptr, nullptr)
+OPTION(prefix_2, "FA", _SLASH_FA_joined, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Fa", _SLASH_Fa, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Output assembly code to this file during compilation (with /FA)", "<file or directory>", nullptr)
+OPTION(prefix_1, "fbackslash", backslash_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fbacktrace", backtrace_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fblas-matmul-limit=", fblas_matmul_limit_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fblocks-runtime-optional", fblocks_runtime_optional, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Weakly link in the blocks runtime", nullptr, nullptr)
+OPTION(prefix_1, "fblocks", fblocks, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Enable the 'blocks' language feature", nullptr, nullptr)
+OPTION(prefix_1, "fbootclasspath=", fbootclasspath_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fborland-extensions", fborland_extensions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Accept non-standard constructs supported by the Borland compiler", nullptr, nullptr)
+OPTION(prefix_1, "fbounds-check", bounds_check_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fbracket-depth=", fbracket_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fbracket-depth", fbracket_depth, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Maximum nesting level for parentheses, brackets, and braces", nullptr, nullptr)
+OPTION(prefix_1, "fbranch-count-reg", branch_count_reg_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fbuild-session-file=", fbuild_session_file, Joined, i_Group, INVALID, nullptr, 0, 0,
+       "Use the last modification time of <file> as the build session timestamp", "<file>", nullptr)
+OPTION(prefix_1, "fbuild-session-timestamp=", fbuild_session_timestamp, Joined, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Time when the current build session started", "<time since Epoch in seconds>", nullptr)
+OPTION(prefix_1, "fbuiltin-module-map", fbuiltin_module_map, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Load the clang builtins module map file.", nullptr, nullptr)
+OPTION(prefix_1, "fbuiltin", fbuiltin, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fc++-static-destructors", fcxx_static_destructors, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable C++ static destructor registration (the default)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x10", fcall_saved_x10, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x10 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x11", fcall_saved_x11, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x11 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x12", fcall_saved_x12, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x12 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x13", fcall_saved_x13, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x13 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x14", fcall_saved_x14, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x14 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x15", fcall_saved_x15, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x15 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x18", fcall_saved_x18, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x18 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x8", fcall_saved_x8, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x8 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcall-saved-x9", fcall_saved_x9, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Make the x9 register call-saved (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "fcaller-saves", caller_saves_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcaret-diagnostics-max-lines", fcaret_diagnostics_max_lines, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of source lines to show in a caret diagnostic", "<N>", nullptr)
+OPTION(prefix_1, "fcaret-diagnostics", fcaret_diagnostics, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcf-protection=", fcf_protection_EQ, Joined, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Instrument control-flow architecture protection. Options: return, branch, full, none.", nullptr, "return,branch,full,none")
+OPTION(prefix_1, "fcf-protection", fcf_protection, Flag, f_Group, fcf_protection_EQ, "full\0", CoreOption | CC1Option, 0,
+       "Enable cf-protection in 'full' mode", nullptr, nullptr)
+OPTION(prefix_1, "fcf-runtime-abi=", fcf_runtime_abi_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fchar8_t", fchar8__t, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable C++ builtin type char8_t", nullptr, nullptr)
+OPTION(prefix_1, "fcheck-array-temporaries", check_array_temporaries_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcheck-new", fcheck_new_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcheck=", fcheck_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fclang-abi-compat=", fclang_abi_compat_EQ, Joined, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Attempt to match the ABI of Clang <version>", "<version>", "<major>.<minor>,latest")
+OPTION(prefix_1, "fclasspath=", fclasspath_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcoarray=", fcoarray_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcolor-diagnostics", fcolor_diagnostics, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Use colors in diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fcomment-block-commands=", fcomment_block_commands, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Treat each comma separated argument in <arg> as a documentation comment block command", "<arg>", nullptr)
+OPTION(prefix_1, "fcommon", fcommon, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcompile-resource=", fcompile_resource_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcomplete-member-pointers", fcomplete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Require member pointer base types to be complete if they would be significant under the Microsoft ABI", nullptr, nullptr)
+OPTION(prefix_1, "fconcepts-ts", fconcepts_ts, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable C++ Extensions for Concepts.", nullptr, nullptr)
+OPTION(prefix_1, "fconst-strings", fconst_strings, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use a const qualified type for string literals in C and ObjC", nullptr, nullptr)
+OPTION(prefix_1, "fconstant-cfstrings", fconstant_cfstrings, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fconstant-string-class=", fconstant_string_class_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fconstant-string-class", fconstant_string_class, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Specify the class to use for constant Objective-C string objects.", "<class name>", nullptr)
+OPTION(prefix_1, "fconstexpr-backtrace-limit=", fconstexpr_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fconstexpr-backtrace-limit", fconstexpr_backtrace_limit, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit).", "<N>", nullptr)
+OPTION(prefix_1, "fconstexpr-depth=", fconstexpr_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fconstexpr-depth", fconstexpr_depth, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Maximum depth of recursive constexpr function calls", nullptr, nullptr)
+OPTION(prefix_1, "fconstexpr-steps=", fconstexpr_steps_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fconstexpr-steps", fconstexpr_steps, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Maximum number of steps in constexpr function evaluation", nullptr, nullptr)
+OPTION(prefix_1, "fconvert=", fconvert_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcoroutines-ts", fcoroutines_ts, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Enable support for the C++ Coroutines TS", nullptr, nullptr)
+OPTION(prefix_1, "fcoverage-mapping", fcoverage_mapping, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Generate coverage mapping to enable code coverage analysis", nullptr, nullptr)
+OPTION(prefix_1, "fcrash-diagnostics-dir=", fcrash_diagnostics_dir, Joined, f_clang_Group, INVALID, nullptr, NoArgumentUnused | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcray-pointer", cray_pointer_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcreate-profile", fcreate_profile, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcuda-allow-variadic-functions", fcuda_allow_variadic_functions, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow variadic functions in CUDA device code.", nullptr, nullptr)
+OPTION(prefix_1, "fcuda-approx-transcendentals", fcuda_approx_transcendentals, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Use approximate transcendental functions", nullptr, nullptr)
+OPTION(prefix_1, "fcuda-flush-denormals-to-zero", fcuda_flush_denormals_to_zero, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Flush denormal floating point values to zero in CUDA device mode.", nullptr, nullptr)
+OPTION(prefix_1, "fcuda-include-gpubinary", fcuda_include_gpubinary, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Incorporate CUDA device-side binary into host object file.", nullptr, nullptr)
+OPTION(prefix_1, "fcuda-is-device", fcuda_is_device, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate code for CUDA device", nullptr, nullptr)
+OPTION(prefix_1, "fcuda-rdc", anonymous_5, Flag, INVALID, fgpu_rdc, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fcuda-short-ptr", fcuda_short_ptr, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Use 32-bit pointers for accessing const/local/shared address spaces.", nullptr, nullptr)
+OPTION(prefix_1, "fcxx-exceptions", fcxx_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable C++ exceptions", nullptr, nullptr)
+OPTION(prefix_1, "fcxx-modules", fcxx_modules, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "FC", _SLASH_FC, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fd-lines-as-code", d_lines_as_code_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fd-lines-as-comments", d_lines_as_comments_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdata-sections", fdata_sections, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Place each data in its own section (ELF Only)", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-compilation-dir", fdebug_compilation_dir, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "The compilation directory to embed in the debug info.", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-info-for-profiling", fdebug_info_for_profiling, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Emit extra debug info to make sample profile more accurate.", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-macro", fdebug_macro, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Emit macro debug information", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-pass-arguments", fdebug_pass_arguments, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdebug-pass-manager", fdebug_pass_manager, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Prints debug information for the new pass manager", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-pass-structure", fdebug_pass_structure, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdebug-prefix-map=", fdebug_prefix_map_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | CC1AsOption, 0,
+       "remap file source paths in debug info", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-ranges-base-address", fdebug_ranges_base_address, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use DWARF base address selection entries in debug_ranges", nullptr, nullptr)
+OPTION(prefix_1, "fdebug-types-section", fdebug_types_section, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Place debug types in their own section (ELF Only)", nullptr, nullptr)
+OPTION(prefix_1, "fdebugger-cast-result-to-id", fdebugger_cast_result_to_id, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable casting unknown expression results to id", nullptr, nullptr)
+OPTION(prefix_1, "fdebugger-objc-literal", fdebugger_objc_literal, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable special debugger support for Objective-C subscripting and literals", nullptr, nullptr)
+OPTION(prefix_1, "fdebugger-support", fdebugger_support, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable special debugger support behavior", nullptr, nullptr)
+OPTION(prefix_1, "fdeclspec", fdeclspec, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow __declspec as a keyword", nullptr, nullptr)
+OPTION(prefix_1, "fdefault-calling-conv=", fdefault_calling_conv_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set default calling convention", nullptr, "cdecl,fastcall,stdcall,vectorcall,regcall")
+OPTION(prefix_1, "fdefault-double-8", default_double_8_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdefault-inline", default_inline_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdefault-integer-8", default_integer_8_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdefault-real-8", default_real_8_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdefer-pop", anonymous_12, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdelayed-template-parsing", fdelayed_template_parsing, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Parse templated function definitions at the end of the translation unit", nullptr, nullptr)
+OPTION(prefix_1, "fdelete-null-pointer-checks", fdelete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Treat usage of null pointers as undefined behavior.", nullptr, nullptr)
+OPTION(prefix_1, "fdenormal-fp-math=", fdenormal_fp_math_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdepfile-entry=", fdepfile_entry, Joined, f_clang_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdeprecated-macro", fdeprecated_macro, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Defines the __DEPRECATED macro", nullptr, nullptr)
+OPTION(prefix_1, "fdevirtualize-speculatively", devirtualize_speculatively_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdevirtualize", devirtualize_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-absolute-paths", fdiagnostics_absolute_paths, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Print absolute paths in diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-color=", fdiagnostics_color_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-color", fdiagnostics_color, Flag, f_Group, INVALID, nullptr, CoreOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-fixit-info", fdiagnostics_fixit_info, Flag, f_clang_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-format=", fdiagnostics_format_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-format", fdiagnostics_format, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Change diagnostic formatting to match IDE and command line tools", nullptr, "clang,msvc,msvc-fallback,vi")
+OPTION(prefix_1, "fdiagnostics-hotness-threshold=", fdiagnostics_hotness_threshold_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Prevent optimization remarks from being output if they do not have at least this profile count", "<number>", nullptr)
+OPTION(prefix_1, "fdiagnostics-parseable-fixits", fdiagnostics_parseable_fixits, Flag, f_clang_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Print fix-its in machine parseable form", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-print-source-range-info", fdiagnostics_print_source_range_info, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Print source range spans in numeric form", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-category=", fdiagnostics_show_category_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-category", fdiagnostics_show_category, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Print diagnostic category", nullptr, "none,id,name")
+OPTION(prefix_1, "fdiagnostics-show-hotness", fdiagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable profile hotness information in diagnostic line", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-location=", fdiagnostics_show_location_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-note-include-stack", fdiagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Display include stacks for diagnostic notes", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-option", fdiagnostics_show_option, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Print option name with mappable diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fdiagnostics-show-template-tree", fdiagnostics_show_template_tree, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Print a template comparison tree for differing templates", nullptr, nullptr)
+OPTION(prefix_1, "fdigraphs", fdigraphs, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)", nullptr, nullptr)
+OPTION(prefix_1, "fdisable-module-hash", fdisable_module_hash, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable the module hash", nullptr, nullptr)
+OPTION(prefix_1, "fdiscard-value-names", fdiscard_value_names, Flag, f_clang_Group, INVALID, nullptr, DriverOption, 0,
+       "Discard value names in LLVM IR", nullptr, nullptr)
+OPTION(prefix_1, "fdollar-ok", dollar_ok_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdollars-in-identifiers", fdollars_in_identifiers, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow '$' in identifiers", nullptr, nullptr)
+OPTION(prefix_1, "fdouble-square-bracket-attributes", fdouble_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Enable '[[]]' attributes in all C and C++ language modes", nullptr, nullptr)
+OPTION(prefix_1, "fdump-fortran-optimized", dump_fortran_optimized_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdump-fortran-original", dump_fortran_original_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdump-parse-tree", dump_parse_tree_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdump-record-layouts-simple", fdump_record_layouts_simple, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump record layout information in a simple form used for testing", nullptr, nullptr)
+OPTION(prefix_1, "fdump-record-layouts", fdump_record_layouts, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump record layout information", nullptr, nullptr)
+OPTION(prefix_1, "fdump-vtable-layouts", fdump_vtable_layouts, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump the layouts of all vtables that will be emitted in a translation unit", nullptr, nullptr)
+OPTION(prefix_1, "fdwarf-directory-asm", fdwarf_directory_asm, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fdwarf-exceptions", fdwarf_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use DWARF style exceptions", nullptr, nullptr)
+OPTION(prefix_1, "fdwarf2-cfi-asm", fdwarf2_cfi_asm, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Fd", _SLASH_Fd, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "felide-constructors", felide_constructors, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "feliminate-unused-debug-symbols", feliminate_unused_debug_symbols, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "feliminate-unused-debug-types", eliminate_unused_debug_types_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fembed-bitcode-marker", fembed_bitcode_marker, Flag, INVALID, fembed_bitcode_EQ, "marker\0", 0, 0,
+       "Embed placeholder LLVM IR data as a marker", nullptr, nullptr)
+OPTION(prefix_1, "fembed-bitcode=", fembed_bitcode_EQ, Joined, f_Group, INVALID, nullptr, DriverOption | CC1Option | CC1AsOption, 0,
+       "Embed LLVM bitcode (option: off, all, bitcode, marker)", "<option>", nullptr)
+OPTION(prefix_1, "fembed-bitcode", fembed_bitcode, Flag, f_Group, fembed_bitcode_EQ, "all\0", 0, 0,
+       "Embed LLVM IR bitcode as data", nullptr, nullptr)
+OPTION(prefix_1, "femit-all-decls", femit_all_decls, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Emit all declarations, even if unused", nullptr, nullptr)
+OPTION(prefix_1, "femit-coverage-data", femit_coverage_data, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Instrument the program to emit gcov coverage data when run.", nullptr, nullptr)
+OPTION(prefix_1, "femit-coverage-notes", femit_coverage_notes, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit a gcov coverage notes file when compiling.", nullptr, nullptr)
+OPTION(prefix_1, "femulated-tls", femulated_tls, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use emutls functions to access thread_local variables", nullptr, nullptr)
+OPTION(prefix_1, "fencode-extended-block-signature", fencode_extended_block_signature, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "enable extended encoding of block type signature", nullptr, nullptr)
+OPTION(prefix_1, "fencoding=", fencoding_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ferror-limit=", ferror_limit_EQ, Joined, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ferror-limit", ferror_limit, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of errors to emit before stopping (0 = no limit).", "<N>", nullptr)
+OPTION(prefix_1, "fescaping-block-tail-calls", fescaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexceptions", fexceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable support for exception handling", nullptr, nullptr)
+OPTION(prefix_1, "fexcess-precision=", fexcess_precision_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexec-charset=", fexec_charset_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexpensive-optimizations", anonymous_10, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexperimental-isel", fexperimental_isel, Flag, f_clang_Group, INVALID, nullptr, 0, 0,
+       "Enables the experimental global instruction selector", nullptr, nullptr)
+OPTION(prefix_1, "fexperimental-new-pass-manager", fexperimental_new_pass_manager, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Enables an experimental new pass manager in LLVM.", nullptr, nullptr)
+OPTION(prefix_1, "fextdirs=", fextdirs_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fextended-identifiers", anonymous_14, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexternal-blas", external_blas_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fexternc-nounwind", fexternc_nounwind, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Assume all functions with C linkage do not unwind", nullptr, nullptr)
+OPTION(prefix_2, "Fe", _SLASH_Fe, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set output executable file or directory (ends in / or \\)", "<file or directory>", nullptr)
+OPTION(prefix_1, "ff2c", f2c_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffake-address-space-map", ffake_address_space_map, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use a fake address space map; OpenCL testing purposes only", nullptr, nullptr)
+OPTION(prefix_1, "ffast-math", ffast_math, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow aggressive, lossy floating-point optimizations", nullptr, nullptr)
+OPTION(prefix_1, "ffat-lto-objects", fat_lto_objects_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffine-grained-bitfield-accesses", ffine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Use separate accesses for consecutive bitfield runs with legal widths and alignments.", nullptr, nullptr)
+OPTION(prefix_1, "ffinite-math-only", ffinite_math_only, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffixed-form", fixed_form_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffixed-line-length-", ffixed_line_length_VALUE, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffixed-point", ffixed_point, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable fixed point types", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-r19", ffixed_r19, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Reserve register r19 (Hexagon only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-r9", ffixed_r9, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the r9 register (ARM only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x10", ffixed_x10, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 10 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x11", ffixed_x11, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 11 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x12", ffixed_x12, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 12 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x13", ffixed_x13, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 13 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x14", ffixed_x14, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 14 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x15", ffixed_x15, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 15 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x18", ffixed_x18, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 18 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x1", ffixed_x1, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 1 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x20", ffixed_x20, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 20 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x21", ffixed_x21, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 21 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x22", ffixed_x22, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 22 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x23", ffixed_x23, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 23 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x24", ffixed_x24, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 24 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x25", ffixed_x25, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 25 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x26", ffixed_x26, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 26 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x27", ffixed_x27, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 27 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x28", ffixed_x28, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 28 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x2", ffixed_x2, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 2 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x3", ffixed_x3, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 3 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x4", ffixed_x4, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 4 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x5", ffixed_x5, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 5 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x6", ffixed_x6, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 6 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x7", ffixed_x7, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 7 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffixed-x9", ffixed_x9, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Reserve the 9 register (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "ffloat-store", float_store_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffor-scope", ffor_scope, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fforbid-guard-variables", fforbid_guard_variables, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit an error if a C++ static local initializer would need a guard variable", nullptr, nullptr)
+OPTION(prefix_1, "fforce-addr", force_addr, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fforce-emit-vtables", fforce_emit_vtables, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Emits more virtual tables to improve devirtualization", nullptr, nullptr)
+OPTION(prefix_1, "fforce-enable-int128", fforce_enable_int128, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable support for int128_t type", nullptr, nullptr)
+OPTION(prefix_1, "ffp-contract=", ffp_contract, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Form fused FP ops (e.g. FMAs): fast (everywhere) | on (according to FP_CONTRACT pragma, default) | off (never fuse)", nullptr, "fast,on,off")
+OPTION(prefix_1, "ffpe-trap=", ffpe_trap_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffree-form", free_form_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffree-line-length-", ffree_line_length_VALUE, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffreestanding", ffreestanding, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Assert that the compilation takes place in a freestanding environment", nullptr, nullptr)
+OPTION(prefix_1, "ffriend-injection", friend_injection_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffrontend-optimize", frontend_optimize_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffunction-attribute-list", function_attribute_list_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ffunction-sections", ffunction_sections, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Place each function in its own section (ELF Only)", nullptr, nullptr)
+OPTION(prefix_1, "fgcse-after-reload", gcse_after_reload_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgcse-las", gcse_las_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgcse-sm", gcse_sm_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgcse", gcse_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgnu-inline-asm", fgnu_inline_asm, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgnu-keywords", fgnu_keywords, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow GNU-extension keywords regardless of language standard", nullptr, nullptr)
+OPTION(prefix_1, "fgnu-runtime", fgnu_runtime, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Generate output compatible with the standard GNU Objective-C runtime", nullptr, nullptr)
+OPTION(prefix_1, "fgnu89-inline", fgnu89_inline, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use the gnu89 inline semantics", nullptr, nullptr)
+OPTION(prefix_1, "fgnu", gnu_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fgpu-rdc", fgpu_rdc, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Generate relocatable device code, also known as separate compilation mode.", nullptr, nullptr)
+OPTION(prefix_1, "fheinous-gnu-extensions", fheinous_gnu_extensions, Flag, INVALID, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fhip-dump-offload-linker-script", fhip_dump_offload_linker_script, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fhonor-infinites", anonymous_16, Flag, INVALID, fhonor_infinities, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fhonor-infinities", fhonor_infinities, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fhonor-nans", fhonor_nans, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fhosted", fhosted, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fident", anonymous_3, Flag, f_Group, Qy, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "filelist", filelist, Separate, Link_Group, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "filetype", filetype, Separate, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Specify the output file type ('asm', 'null', or 'obj')", nullptr, nullptr)
+OPTION(prefix_1, "fimplement-inlines", implement_inlines_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fimplicit-module-maps", fimplicit_module_maps, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Implicitly search the file system for module map files.", nullptr, nullptr)
+OPTION(prefix_1, "fimplicit-modules", fimplicit_modules, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fimplicit-none", implicit_none_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fimplicit-templates", implicit_templates_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finclude-default-header", finclude_default_header, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include the default header file for OpenCL", nullptr, nullptr)
+OPTION(prefix_1, "findirect-virtual-calls", anonymous_18, Flag, INVALID, fapple_kext, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finit-character=", finit_character_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finit-integer=", finit_integer_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finit-local-zero", init_local_zero_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finit-logical=", finit_logical_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finit-real=", finit_real_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finline-functions-called-once", inline_functions_called_once_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finline-functions", finline_functions, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Inline suitable functions", nullptr, nullptr)
+OPTION(prefix_1, "finline-hint-functions", finline_hint_functions, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Inline functions which are (explicitly or implicitly) marked inline", nullptr, nullptr)
+OPTION(prefix_1, "finline-limit=", finline_limit_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finline-limit", finline_limit_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finline-small-functions", inline_small_functions_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finline", finline, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finput-charset=", finput_charset_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "finstrument-function-entry-bare", finstrument_function_entry_bare, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Instrument function entry only, after inlining, without arguments to the instrumentation call", nullptr, nullptr)
+OPTION(prefix_1, "finstrument-functions-after-inlining", finstrument_functions_after_inlining, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Like -finstrument-functions, but insert the calls after inlining", nullptr, nullptr)
+OPTION(prefix_1, "finstrument-functions", finstrument_functions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Generate calls to instrument function entry and exit", nullptr, nullptr)
+OPTION(prefix_1, "finteger-4-integer-8", integer_4_integer_8_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fintegrated-as", fintegrated_as, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Enable the integrated assembler", nullptr, nullptr)
+OPTION(prefix_1, "fintrinsic-modules-path", intrinsic_modules_path_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fipa-cp", ipa_cp_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fivopts", ivopts_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fix-only-warnings", fix_only_warnings, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it advice only for warnings, not errors", nullptr, nullptr)
+OPTION(prefix_1, "fix-what-you-can", fix_what_you_can, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it advice even in the presence of unfixable errors", nullptr, nullptr)
+OPTION(prefix_1, "fixit-recompile", fixit_recompile, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it changes and recompile", nullptr, nullptr)
+OPTION(prefix_1, "fixit-to-temporary", fixit_to_temp, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it changes to temporary files", nullptr, nullptr)
+OPTION(prefix_1, "fixit=", fixit_EQ, Joined, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it advice creating a file with the given suffix", nullptr, nullptr)
+OPTION(prefix_1, "fixit", fixit, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Apply fix-it advice to the input source", nullptr, nullptr)
+OPTION(prefix_2, "FI", _SLASH_FI, JoinedOrSeparate, cl_Group, include, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Include file before parsing", nullptr, nullptr)
+OPTION(prefix_2, "Fi", _SLASH_Fi, Joined, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Set preprocess output file name (with /P)", "<file>", nullptr)
+OPTION(prefix_1, "fjump-tables", fjump_tables, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fkeep-inline-functions", anonymous_34_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fkeep-static-consts", fkeep_static_consts, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Keep static const variables even if unused", nullptr, nullptr)
+OPTION(prefix_1, "flat_namespace", flat__namespace, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "flax-vector-conversions", flax_vector_conversions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "flimit-debug-info", flimit_debug_info, Flag, INVALID, fno_standalone_debug, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "flimited-precision=", flimited_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "flto-jobs=", flto_jobs_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)", nullptr, nullptr)
+OPTION(prefix_1, "flto-unit", flto_unit, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit IR to support LTO unit features (CFI, whole program vtable opt)", nullptr, nullptr)
+OPTION(prefix_1, "flto-visibility-public-std", flto_visibility_public_std, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use public LTO visibility for classes in std and stdext namespaces", nullptr, nullptr)
+OPTION(prefix_1, "flto=", flto_EQ, Joined, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Set LTO mode to either 'full' or 'thin'", nullptr, "thin,full")
+OPTION(prefix_1, "flto", flto, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Enable LTO in 'full' mode", nullptr, nullptr)
+OPTION(prefix_1, "fmacro-backtrace-limit=", fmacro_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmacro-backtrace-limit", fmacro_backtrace_limit, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit).", "<N>", nullptr)
+OPTION(prefix_1, "fmath-errno", fmath_errno, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Require math functions to indicate errors by setting errno", nullptr, nullptr)
+OPTION(prefix_1, "fmax-array-constructor=", fmax_array_constructor_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmax-errors=", fmax_errors_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmax-identifier-length", max_identifier_length_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmax-stack-var-size=", fmax_stack_var_size_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmax-subrecord-length=", fmax_subrecord_length_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmax-type-align=", fmax_type_align_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify the maximum alignment to enforce on pointers lacking an explicit alignment", nullptr, nullptr)
+OPTION(prefix_1, "fmerge-all-constants", fmerge_all_constants, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Allow merging of constants", nullptr, nullptr)
+OPTION(prefix_1, "fmerge-constants", merge_constants_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmerge-functions", fmerge_functions, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Permit merging of identical functions when optimizing.", nullptr, nullptr)
+OPTION(prefix_1, "fmessage-length=", fmessage_length_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmessage-length", fmessage_length, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Format message diagnostics so that they fit within N columns or fewer, when possible.", "<N>", nullptr)
+OPTION(prefix_1, "fmodule-feature", fmodule_feature, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable <feature> in module map requires declarations", "<feature>", nullptr)
+OPTION(prefix_1, "fmodule-file-deps", fmodule_file_deps, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodule-file=", fmodule_file, Joined, i_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.", "[<name>=]<file>", nullptr)
+OPTION(prefix_1, "fmodule-format=", fmodule_format_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Select the container format for clang modules and PCH. Supported options are 'raw' and 'obj'.", nullptr, nullptr)
+OPTION(prefix_1, "fmodule-implementation-of", fmodule_implementation_of, Separate, INVALID, fmodule_name_EQ, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodule-map-file-home-is-cwd", fmodule_map_file_home_is_cwd, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use the current working directory as the home directory of module maps specified by -fmodule-map-file=<FILE>", nullptr, nullptr)
+OPTION(prefix_1, "fmodule-map-file=", fmodule_map_file, Joined, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Load this module map file", "<file>", nullptr)
+OPTION(prefix_1, "fmodule-maps", fmodule_maps, Flag, INVALID, fimplicit_module_maps, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodule-name=", fmodule_name_EQ, Joined, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify the name of the module to build", "<name>", nullptr)
+OPTION(prefix_1, "fmodule-name", fmodule_name, Separate, INVALID, fmodule_name_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodule-private", module_private_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodules-cache-path=", fmodules_cache_path, Joined, i_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify the module cache path", "<directory>", nullptr)
+OPTION(prefix_1, "fmodules-codegen", fmodules_codegen, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate code for uses of this module that assumes an explicit object file will be built for the module", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-debuginfo", fmodules_debuginfo, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate debug info for types in an object file built from this module and do not generate them elsewhere", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-decluse", fmodules_decluse, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Require declaration of modules used within a module", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-disable-diagnostic-validation", fmodules_disable_diagnostic_validation, Flag, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable validation of the diagnostic options when loading the module", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-embed-all-files", fmodules_embed_all_files, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Embed the contents of all files read by this compilation into the produced module file.", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-embed-file=", fmodules_embed_file_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Embed the contents of the specified file into the module file being compiled.", "<file>", nullptr)
+OPTION(prefix_1, "fmodules-hash-content", fmodules_hash_content, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable hashing the content of a module file", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-ignore-macro=", fmodules_ignore_macro, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Ignore the definition of the given macro when building and loading modules", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-local-submodule-visibility", fmodules_local_submodule_visibility, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enforce name visibility rules across submodules of the same top-level module.", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-prune-after=", fmodules_prune_after, Joined, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify the interval (in seconds) after which a module file will be considered unused", "<seconds>", nullptr)
+OPTION(prefix_1, "fmodules-prune-interval=", fmodules_prune_interval, Joined, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify the interval (in seconds) between attempts to prune the module cache", "<seconds>", nullptr)
+OPTION(prefix_1, "fmodules-search-all", fmodules_search_all, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Search even non-imported modules to resolve references", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-strict-decluse", fmodules_strict_decluse, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Like -fmodules-decluse but requires all headers to be in modules", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-ts", fmodules_ts, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable support for the C++ Modules TS", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-user-build-path", fmodules_user_build_path, Separate, i_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify the module user build path", "<directory>", nullptr)
+OPTION(prefix_1, "fmodules-validate-once-per-build-session", fmodules_validate_once_per_build_session, Flag, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Don't verify input files for the modules if the module has been successfully validated or loaded during this build session", nullptr, nullptr)
+OPTION(prefix_1, "fmodules-validate-system-headers", fmodules_validate_system_headers, Flag, i_Group, INVALID, nullptr, CC1Option, 0,
+       "Validate the system headers that a module depends on when loading the module", nullptr, nullptr)
+OPTION(prefix_1, "fmodules", fmodules, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Enable the 'modules' language feature", nullptr, nullptr)
+OPTION(prefix_1, "fmodulo-sched-allow-regmoves", modulo_sched_allow_regmoves_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmodulo-sched", modulo_sched_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fms-compatibility-version=", fms_compatibility_version, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))", nullptr, nullptr)
+OPTION(prefix_1, "fms-compatibility", fms_compatibility, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable full Microsoft Visual C++ compatibility", nullptr, nullptr)
+OPTION(prefix_1, "fms-extensions", fms_extensions, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Accept some non-standard constructs supported by the Microsoft compiler", nullptr, nullptr)
+OPTION(prefix_1, "fms-memptr-rep=", fms_memptr_rep_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fms-volatile", fms_volatile, Joined, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmsc-version=", fmsc_version, Joined, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))", nullptr, nullptr)
+OPTION(prefix_1, "fmudflapth", fmudflapth, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fmudflap", fmudflap, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Fm", _SLASH_Fm, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnative-half-arguments-and-returns", fnative_half_arguments_and_returns, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)", nullptr, nullptr)
+OPTION(prefix_1, "fnative-half-type", fnative_half_type, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use the native half type for __fp16 instead of promoting to float", nullptr, nullptr)
+OPTION(prefix_1, "fnested-functions", fnested_functions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnew-alignment=", fnew_alignment_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Specifies the largest alignment guaranteed by '::operator new(size_t)'", "<align>", nullptr)
+OPTION(prefix_1, "fnew-alignment", anonymous_19, Separate, INVALID, fnew_alignment_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnext-runtime", fnext_runtime, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-access-control", fno_access_control, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable C++ access control", nullptr, nullptr)
+OPTION(prefix_1, "fno-addrsig", fno_addrsig, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Don't emit an address-significance table", nullptr, nullptr)
+OPTION(prefix_1, "fno-aggressive-function-elimination", aggressive_function_elimination_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-align-commons", align_commons_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-align-functions", fno_align_functions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-align-jumps", align_jumps_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-align-labels", align_labels_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-align-loops", align_loops_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-aligned-allocation", fno_aligned_allocation, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-aligned-new", anonymous_21, Flag, INVALID, fno_aligned_allocation, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-all-intrinsics", all_intrinsics_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-allow-editor-placeholders", fno_allow_editor_placeholders, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-altivec", fno_altivec, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-apple-pragma-pack", fno_apple_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-application-extension", fno_application_extension, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-asm-blocks", fno_asm_blocks, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-asm", fno_asm, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-associative-math", fno_associative_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-assume-sane-operator-new", fno_assume_sane_operator_new, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Don't assume that C++'s global operator new can't alias any pointer", nullptr, nullptr)
+OPTION(prefix_1, "fno-asynchronous-unwind-tables", fno_asynchronous_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-auto-profile-accurate", fno_auto_profile_accurate, Flag, f_Group, fno_profile_sample_accurate, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-auto-profile", fno_auto_profile, Flag, f_Group, fno_profile_sample_use, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-autolink", fno_autolink, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Disable generation of linker directives for automatic library linking", nullptr, nullptr)
+OPTION(prefix_1, "fno-automatic", automatic_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-backslash", backslash_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-backtrace", backtrace_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-bitfield-type-align", fno_bitfield_type_align, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Ignore bit-field types when aligning structures", nullptr, nullptr)
+OPTION(prefix_1, "fno-blocks", fno_blocks, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-borland-extensions", fno_borland_extensions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-bounds-check", bounds_check_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-branch-count-reg", branch_count_reg_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-builtin-", fno_builtin_, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable implicit builtin knowledge of a specific function", nullptr, nullptr)
+OPTION(prefix_1, "fno-builtin", fno_builtin, Flag, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable implicit builtin knowledge of functions", nullptr, nullptr)
+OPTION(prefix_1, "fno-c++-static-destructors", fno_cxx_static_destructors, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable C++ static destructor registration", nullptr, nullptr)
+OPTION(prefix_1, "fno-caller-saves", caller_saves_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-caret-diagnostics", fno_caret_diagnostics, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-char8_t", fno_char8__t, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable C++ builtin type char8_t", nullptr, nullptr)
+OPTION(prefix_1, "fno-check-array-temporaries", check_array_temporaries_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-check-new", fcheck_new_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-color-diagnostics", fno_color_diagnostics, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-common", fno_common, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Compile common globals like normal definitions", nullptr, nullptr)
+OPTION(prefix_1, "fno-complete-member-pointers", fno_complete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, CoreOption, 0,
+       "Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI", nullptr, nullptr)
+OPTION(prefix_1, "fno-const-strings", fno_const_strings, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't use a const qualified type for string literals in C and ObjC", nullptr, nullptr)
+OPTION(prefix_1, "fno-constant-cfstrings", fno_constant_cfstrings, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable creation of CodeFoundation-type constant strings", nullptr, nullptr)
+OPTION(prefix_1, "fno-coroutines-ts", fno_coroutines_ts, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-coverage-mapping", fno_coverage_mapping, Flag, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Disable code coverage analysis", nullptr, nullptr)
+OPTION(prefix_1, "fno-crash-diagnostics", fno_crash_diagnostics, Flag, f_clang_Group, INVALID, nullptr, NoArgumentUnused | CoreOption, 0,
+       "Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash", nullptr, nullptr)
+OPTION(prefix_1, "fno-cray-pointer", cray_pointer_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cuda-approx-transcendentals", fno_cuda_approx_transcendentals, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cuda-flush-denormals-to-zero", fno_cuda_flush_denormals_to_zero, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cuda-host-device-constexpr", fno_cuda_host_device_constexpr, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't treat unattributed constexpr functions as __host__ __device__.", nullptr, nullptr)
+OPTION(prefix_1, "fno-cuda-rdc", anonymous_6, Flag, INVALID, fno_gpu_rdc, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cuda-short-ptr", fno_cuda_short_ptr, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cxx-exceptions", fno_cxx_exceptions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-cxx-modules", fno_cxx_modules, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-d-lines-as-code", d_lines_as_code_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-d-lines-as-comments", d_lines_as_comments_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-data-sections", fno_data_sections, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-debug-info-for-profiling", fno_debug_info_for_profiling, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Do not emit extra debug info for sample profiler.", nullptr, nullptr)
+OPTION(prefix_1, "fno-debug-macro", fno_debug_macro, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Do not emit macro debug information", nullptr, nullptr)
+OPTION(prefix_1, "fno-debug-pass-manager", fno_debug_pass_manager, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disables debug printing for the new pass manager", nullptr, nullptr)
+OPTION(prefix_1, "fno-debug-ranges-base-address", fno_debug_ranges_base_address, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-debug-types-section", fno_debug_types_section, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-declspec", fno_declspec, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Disallow __declspec as a keyword", nullptr, nullptr)
+OPTION(prefix_1, "fno-default-double-8", default_double_8_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-default-inline", default_inline_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-default-integer-8", default_integer_8_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-default-real-8", default_real_8_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-defer-pop", anonymous_13, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-delayed-template-parsing", fno_delayed_template_parsing, Flag, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Disable delayed template parsing", nullptr, nullptr)
+OPTION(prefix_1, "fno-delete-null-pointer-checks", fno_delete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not treat usage of null pointers as undefined behavior.", nullptr, nullptr)
+OPTION(prefix_1, "fno-deprecated-macro", fno_deprecated_macro, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Undefines the __DEPRECATED macro", nullptr, nullptr)
+OPTION(prefix_1, "fno-devirtualize-speculatively", devirtualize_speculatively_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-devirtualize", devirtualize_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-color", fno_diagnostics_color, Flag, f_Group, INVALID, nullptr, CoreOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-fixit-info", fno_diagnostics_fixit_info, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not include fixit information in diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-show-hotness", fno_diagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-show-note-include-stack", fno_diagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-show-option", fno_diagnostics_show_option, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-diagnostics-use-presumed-location", fno_diagnostics_use_presumed_location, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Ignore #line directives when displaying diagnostic locations", nullptr, nullptr)
+OPTION(prefix_1, "fno-digraphs", fno_digraphs, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'", nullptr, nullptr)
+OPTION(prefix_1, "fno-discard-value-names", fno_discard_value_names, Flag, f_clang_Group, INVALID, nullptr, DriverOption, 0,
+       "Do not discard value names in LLVM IR", nullptr, nullptr)
+OPTION(prefix_1, "fno-dllexport-inlines", fno_dllexport_inlines, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dollar-ok", dollar_ok_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dollars-in-identifiers", fno_dollars_in_identifiers, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disallow '$' in identifiers", nullptr, nullptr)
+OPTION(prefix_1, "fno-double-square-bracket-attributes", fno_double_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Disable '[[]]' attributes in all C and C++ language modes", nullptr, nullptr)
+OPTION(prefix_1, "fno-dump-fortran-optimized", dump_fortran_optimized_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dump-fortran-original", dump_fortran_original_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dump-parse-tree", dump_parse_tree_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dwarf-directory-asm", fno_dwarf_directory_asm, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-dwarf2-cfi-asm", fno_dwarf2_cfi_asm, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-elide-constructors", fno_elide_constructors, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable C++ copy constructor elision", nullptr, nullptr)
+OPTION(prefix_1, "fno-elide-type", fno_elide_type, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not elide types when printing diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fno-eliminate-unused-debug-symbols", fno_eliminate_unused_debug_symbols, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-eliminate-unused-debug-types", eliminate_unused_debug_types_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-emulated-tls", fno_emulated_tls, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-escaping-block-tail-calls", fno_escaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-exceptions", fno_exceptions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-expensive-optimizations", anonymous_11, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-experimental-isel", fno_experimental_isel, Flag, f_clang_Group, INVALID, nullptr, 0, 0,
+       "Disables the experimental global instruction selector", nullptr, nullptr)
+OPTION(prefix_1, "fno-experimental-new-pass-manager", fno_experimental_new_pass_manager, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Disables an experimental new pass manager in LLVM.", nullptr, nullptr)
+OPTION(prefix_1, "fno-extended-identifiers", anonymous_15, Flag, f_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-external-blas", external_blas_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-f2c", f2c_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-fast-math", fno_fast_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-fat-lto-objects", fat_lto_objects_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-fine-grained-bitfield-accesses", fno_fine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Use large-integer access for consecutive bitfield runs.", nullptr, nullptr)
+OPTION(prefix_1, "fno-finite-math-only", fno_finite_math_only, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-fixed-form", fixed_form_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-fixed-point", fno_fixed_point, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Disable fixed point types", nullptr, nullptr)
+OPTION(prefix_1, "fno-float-store", float_store_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-for-scope", fno_for_scope, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-force-emit-vtables", fno_force_emit_vtables, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-force-enable-int128", fno_force_enable_int128, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable support for int128_t type", nullptr, nullptr)
+OPTION(prefix_1, "fno-free-form", free_form_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-friend-injection", friend_injection_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-frontend-optimize", frontend_optimize_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-function-attribute-list", function_attribute_list_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-function-sections", fno_function_sections, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gcse-after-reload", gcse_after_reload_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gcse-las", gcse_las_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gcse-sm", gcse_sm_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gcse", gcse_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gnu-inline-asm", fno_gnu_inline_asm, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Disable GNU style inline asm", nullptr, nullptr)
+OPTION(prefix_1, "fno-gnu-keywords", fno_gnu_keywords, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gnu89-inline", fno_gnu89_inline, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gnu", gnu_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-gpu-rdc", fno_gpu_rdc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-honor-infinites", anonymous_17, Flag, INVALID, fno_honor_infinities, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-honor-infinities", fno_honor_infinities, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-honor-nans", fno_honor_nans, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ident", anonymous_4, Flag, f_Group, Qn, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-implement-inlines", implement_inlines_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-implicit-module-maps", fno_implicit_module_maps, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-implicit-modules", fno_implicit_modules, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-implicit-none", implicit_none_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-implicit-templates", implicit_templates_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-init-local-zero", init_local_zero_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-inline-functions-called-once", inline_functions_called_once_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-inline-functions", fno_inline_functions, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-inline-limit", finline_limit_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-inline-small-functions", inline_small_functions_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-inline", fno_inline, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-integer-4-integer-8", integer_4_integer_8_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-integrated-as", fno_integrated_as, Flag, f_Group, INVALID, nullptr, CC1Option | DriverOption, 0,
+       "Disable the integrated assembler", nullptr, nullptr)
+OPTION(prefix_1, "fno-intrinsic-modules-path", intrinsic_modules_path_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ipa-cp", ipa_cp_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ivopts", ivopts_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-jump-tables", fno_jump_tables, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not use jump tables for lowering switches", nullptr, nullptr)
+OPTION(prefix_1, "fno-keep-inline-functions", anonymous_34_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-lax-vector-conversions", fno_lax_vector_conversions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disallow implicit conversions between vectors with a different number of elements or different element types", nullptr, nullptr)
+OPTION(prefix_1, "fno-limit-debug-info", fno_limit_debug_info, Flag, INVALID, fstandalone_debug, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-lto-unit", fno_lto_unit, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-lto", fno_lto, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Disable LTO mode (default)", nullptr, nullptr)
+OPTION(prefix_1, "fno-math-builtin", fno_math_builtin, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Disable implicit builtin knowledge of math functions", nullptr, nullptr)
+OPTION(prefix_1, "fno-math-errno", fno_math_errno, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-max-identifier-length", max_identifier_length_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-max-type-align", fno_max_type_align, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-merge-all-constants", fno_merge_all_constants, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Disallow merging of constants", nullptr, nullptr)
+OPTION(prefix_1, "fno-merge-constants", merge_constants_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-module-file-deps", fno_module_file_deps, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-module-maps", fno_module_maps, Flag, INVALID, fno_implicit_module_maps, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-module-private", module_private_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modules-decluse", fno_modules_decluse, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modules-error-recovery", fno_modules_error_recovery, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not automatically import modules for error recovery", nullptr, nullptr)
+OPTION(prefix_1, "fno-modules-global-index", fno_modules_global_index, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not automatically generate or update the global module index", nullptr, nullptr)
+OPTION(prefix_1, "fno-modules-search-all", fno_modules_search_all, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modules-validate-system-headers", fno_modules_validate_system_headers, Flag, i_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modules", fno_modules, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modulo-sched-allow-regmoves", modulo_sched_allow_regmoves_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-modulo-sched", modulo_sched_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ms-compatibility", fno_ms_compatibility, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ms-extensions", fno_ms_extensions, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-non-call-exceptions", non_call_exceptions_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-arc-exceptions", fno_objc_arc_exceptions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-arc", fno_objc_arc, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-convert-messages-to-runtime-calls", fno_objc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-exceptions", fno_objc_exceptions, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-infer-related-result-type", fno_objc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "do not infer Objective-C related result type based on method family", nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-legacy-dispatch", fno_objc_legacy_dispatch, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-nonfragile-abi", fno_objc_nonfragile_abi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-objc-weak", fno_objc_weak, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-omit-frame-pointer", fno_omit_frame_pointer, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-openmp-cuda-force-full-runtime", fno_openmp_cuda_force_full_runtime, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-openmp-cuda-mode", fno_openmp_cuda_mode, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-openmp-optimistic-collapse", fno_openmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-openmp-simd", fno_openmp_simd, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-openmp", fno_openmp, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-operator-names", fno_operator_names, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not treat C++ operator name keywords as synonyms for operators", nullptr, nullptr)
+OPTION(prefix_1, "fno-optimize-sibling-calls", fno_optimize_sibling_calls, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pack-derived", pack_derived_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pack-struct", fno_pack_struct, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-padding-on-unsigned-fixed-point", fno_padding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pascal-strings", fno_pascal_strings, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pch-timestamp", fno_pch_timestamp, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable inclusion of timestamp in precompiled headers", nullptr, nullptr)
+OPTION(prefix_1, "fno-peel-loops", peel_loops_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-permissive", permissive_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-PIC", fno_PIC, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pic", fno_pic, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-PIE", fno_PIE, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-pie", fno_pie, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-plt", fno_plt, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not use the PLT to make function calls", nullptr, nullptr)
+OPTION(prefix_1, "fno-prefetch-loop-arrays", prefetch_loop_arrays_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-preserve-as-comments", fno_preserve_as_comments, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not preserve comments in inline assembly", nullptr, nullptr)
+OPTION(prefix_1, "fno-printf", printf_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-arcs", fno_profile_arcs, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-correction", profile_correction_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-generate-sampling", profile_generate_sampling_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-generate", fno_profile_generate, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Disable generation of profile instrumentation.", nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-instr-generate", fno_profile_instr_generate, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Disable generation of profile instrumentation.", nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-instr-use", fno_profile_instr_use, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Disable using instrumentation data for profile-guided optimization", nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-reusedist", profile_reusedist_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-sample-accurate", fno_profile_sample_accurate, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-sample-use", fno_profile_sample_use, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-use", fno_profile_use, Flag, INVALID, fno_profile_instr_use, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile-values", profile_values_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-profile", profile_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-protect-parens", protect_parens_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-range-check", range_check_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-4-real-10", real_4_real_10_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-4-real-16", real_4_real_16_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-4-real-8", real_4_real_8_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-8-real-10", real_8_real_10_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-8-real-16", real_8_real_16_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-real-8-real-4", real_8_real_4_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-realloc-lhs", realloc_lhs_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-reciprocal-math", fno_reciprocal_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-record-command-line", fno_record_command_line, Flag, f_clang_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-record-gcc-switches", anonymous_9, Flag, INVALID, fno_record_command_line, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-recursive", recursive_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-register-global-dtors-with-atexit", fno_register_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Don't use atexit or __cxa_atexit to register global destructors", nullptr, nullptr)
+OPTION(prefix_1, "fno-regs-graph", regs_graph_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-relaxed-template-template-args", fno_relaxed_template_template_args, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-rename-registers", rename_registers_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-reorder-blocks", reorder_blocks_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-repack-arrays", repack_arrays_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-reroll-loops", fno_reroll_loops, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Turn off loop reroller", nullptr, nullptr)
+OPTION(prefix_1, "fno-rewrite-imports", fno_rewrite_imports, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-rewrite-includes", fno_rewrite_includes, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ripa", ripa_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-ropi", fno_ropi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-rounding-math", rounding_math_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-rtlib-add-rpath", fno_rtlib_add_rpath, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, 0,
+       "Do not add -rpath with architecture-specific resource directory to the linker flags", nullptr, nullptr)
+OPTION(prefix_1, "fno-rtti-data", fno_rtti_data, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Control emission of RTTI data", nullptr, nullptr)
+OPTION(prefix_1, "fno-rtti", fno_rtti, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable generation of rtti information", nullptr, nullptr)
+OPTION(prefix_1, "fno-rwpi", fno_rwpi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-address-poison-custom-array-cookie", fno_sanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable poisoning array cookies when using custom operator new[] in AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-address-use-after-scope", fno_sanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable use-after-scope detection in AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-address-use-odr-indicator", fno_sanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable ODR indicator globals", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-blacklist", fno_sanitize_blacklist, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Don't use blacklist file for sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-cfi-cross-dso", fno_sanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable control flow integrity (CFI) checks for cross-DSO calls.", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-coverage=", fno_sanitize_coverage, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable specified features of coverage instrumentation for Sanitizers", nullptr, "func,bb,edge,indirect-calls,trace-bb,trace-cmp,trace-div,trace-gep,8bit-counters,trace-pc,trace-pc-guard,no-prune,inline-8bit-counters")
+OPTION(prefix_1, "fno-sanitize-memory-track-origins", fno_sanitize_memory_track_origins, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable origins tracking in MemorySanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-memory-use-after-dtor", fno_sanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable use-after-destroy detection in MemorySanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-minimal-runtime", fno_sanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-recover=", fno_sanitize_recover_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable recovery for specified sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-recover", fno_sanitize_recover, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-stats", fno_sanitize_stats, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable sanitizer statistics gathering.", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-thread-atomics", fno_sanitize_thread_atomics, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable atomic operations instrumentation in ThreadSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-thread-func-entry-exit", fno_sanitize_thread_func_entry_exit, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable function entry/exit instrumentation in ThreadSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-thread-memory-access", fno_sanitize_thread_memory_access, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable memory access instrumentation in ThreadSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-trap=", fno_sanitize_trap_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable trapping for specified sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize-undefined-trap-on-error", fno_sanitize_undefined_trap_on_error, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-sanitize=", fno_sanitize_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-save-optimization-record", fno_save_optimization_record, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-schedule-insns2", schedule_insns2_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-schedule-insns", schedule_insns_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-second-underscore", second_underscore_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-see", see_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-short-enums", fno_short_enums, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-short-wchar", fno_short_wchar, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Force wchar_t to be an unsigned int", nullptr, nullptr)
+OPTION(prefix_1, "fno-show-column", fno_show_column, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not include column number on diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fno-show-source-location", fno_show_source_location, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not include source location information with diagnostics", nullptr, nullptr)
+OPTION(prefix_1, "fno-sign-zero", sign_zero_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-signaling-math", fno_signaling_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-signaling-nans", signaling_nans_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-signed-char", fno_signed_char, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Char is unsigned", nullptr, nullptr)
+OPTION(prefix_1, "fno-signed-wchar", fno_signed_wchar, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use an unsigned type for wchar_t", nullptr, nullptr)
+OPTION(prefix_1, "fno-signed-zeros", fno_signed_zeros, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow optimizations that ignore the sign of floating point zeros", nullptr, nullptr)
+OPTION(prefix_1, "fno-single-precision-constant", single_precision_constant_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-sized-deallocation", fno_sized_deallocation, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-slp-vectorize-aggressive", anonymous_1, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-slp-vectorize", fno_slp_vectorize, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-spec-constr-count", spec_constr_count_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-spell-checking", fno_spell_checking, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable spell-checking", nullptr, nullptr)
+OPTION(prefix_1, "fno-split-dwarf-inlining", fno_split_dwarf_inlining, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-split-lto-unit", fno_split_lto_unit, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-stack-arrays", stack_arrays_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-stack-check", stack_check_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-stack-protector", fno_stack_protector, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Disable the use of stack protectors", nullptr, nullptr)
+OPTION(prefix_1, "fno-stack-size-section", fno_stack_size_section, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Don't emit section containing metadata on function stack sizes", nullptr, nullptr)
+OPTION(prefix_1, "fno-standalone-debug", fno_standalone_debug, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Limit debug information produced to reduce size of debug binary", nullptr, nullptr)
+OPTION(prefix_1, "fno-strength-reduce", strength_reduce_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-aliasing", fno_strict_aliasing, Flag, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-enums", fno_strict_enums, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-float-cast-overflow", fno_strict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions", nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-modules-decluse", fno_modules_strict_decluse, Flag, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-overflow", fno_strict_overflow, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-return", fno_strict_return, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-strict-vtable-pointers", fno_strict_vtable_pointers, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-struct-path-tbaa", fno_struct_path_tbaa, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-threadsafe-statics", fno_threadsafe_statics, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not emit code to make initialization of local statics thread safe", nullptr, nullptr)
+OPTION(prefix_1, "fno-tls-model", tls_model_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tracer", tracer_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-trapping-math", fno_trapping_math, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-dce", tree_dce_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-salias", tree_salias_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-slp-vectorize", anonymous_26, Flag, INVALID, fno_slp_vectorize, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-ter", tree_ter_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-vectorizer-verbose", tree_vectorizer_verbose_fno, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-vectorize", anonymous_24, Flag, INVALID, fno_vectorize, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree-vrp", tree_vrp_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree_loop_im", tree_loop_im_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree_loop_ivcanon", tree_loop_ivcanon_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-tree_loop_linear", tree_loop_linear_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-trigraphs", fno_trigraphs, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Do not process trigraph sequences", nullptr, nullptr)
+OPTION(prefix_1, "fno-underscoring", underscoring_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unique-section-names", fno_unique_section_names, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unit-at-a-time", fno_unit_at_a_time, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unroll-all-loops", unroll_all_loops_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unroll-loops", fno_unroll_loops, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Turn off loop unroller", nullptr, nullptr)
+OPTION(prefix_1, "fno-unsafe-loop-optimizations", unsafe_loop_optimizations_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unsafe-math-optimizations", fno_unsafe_math_optimizations, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unsigned-char", fno_unsigned_char, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unswitch-loops", unswitch_loops_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-unwind-tables", fno_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-use-cxa-atexit", fno_use_cxa_atexit, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Don't use __cxa_atexit for calling destructors", nullptr, nullptr)
+OPTION(prefix_1, "fno-use-init-array", fno_use_init_array, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Don't use .init_array instead of .ctors", nullptr, nullptr)
+OPTION(prefix_1, "fno-use-line-directives", fno_use_line_directives, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-use-linker-plugin", use_linker_plugin_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-validate-pch", fno_validate_pch, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable validation of precompiled headers", nullptr, nullptr)
+OPTION(prefix_1, "fno-var-tracking", fno_var_tracking, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-variable-expansion-in-unroller", variable_expansion_in_unroller_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-vect-cost-model", vect_cost_model_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-vectorize", fno_vectorize, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-verbose-asm", fno_verbose_asm, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-wchar", fno_wchar, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable C++ builtin type wchar_t", nullptr, nullptr)
+OPTION(prefix_1, "fno-web", web_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-whole-file", whole_file_fno, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-whole-program-vtables", fno_whole_program_vtables, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-whole-program", whole_program_fno, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-working-directory", fno_working_directory, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-wrapv", fno_wrapv, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-xray-always-emit-customevents", fnoxray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-xray-always-emit-typedevents", fnoxray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-xray-instrument", fnoxray_instrument, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-zero-initialized-in-bss", fno_zero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fno-zvector", fno_zvector, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnon-call-exceptions", non_call_exceptions_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnoopenmp-relocatable-target", fnoopenmp_relocatable_target, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnoopenmp-use-tls", fnoopenmp_use_tls, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fnoxray-link-deps", fnoxray_link_deps, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-abi-version=", fobjc_abi_version_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-arc-cxxlib=", fobjc_arc_cxxlib_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Objective-C++ Automatic Reference Counting standard library kind", nullptr, "libc++,libstdc++,none")
+OPTION(prefix_1, "fobjc-arc-exceptions", fobjc_arc_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-arc", fobjc_arc, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Synthesize retain and release calls for Objective-C pointers", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-atdefs", fobjc_atdefs, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-call-cxx-cdtors", fobjc_call_cxx_cdtors, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-convert-messages-to-runtime-calls", fobjc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-dispatch-method=", fobjc_dispatch_method_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Objective-C dispatch method to use", nullptr, "legacy,non-legacy,mixed")
+OPTION(prefix_1, "fobjc-exceptions", fobjc_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable Objective-C exceptions", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-gc-only", fobjc_gc_only, Flag, f_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use GC exclusively for Objective-C related memory management", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-gc", fobjc_gc, Flag, f_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable Objective-C garbage collection", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-infer-related-result-type", fobjc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-legacy-dispatch", fobjc_legacy_dispatch, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-link-runtime", fobjc_link_runtime, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-new-property", fobjc_new_property, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-nonfragile-abi-version=", fobjc_nonfragile_abi_version_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-nonfragile-abi", fobjc_nonfragile_abi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-runtime-has-weak", fobjc_runtime_has_weak, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "The target Objective-C runtime supports ARC weak operations", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-runtime=", fobjc_runtime_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Specify the target Objective-C runtime kind and version", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-sender-dependent-dispatch", fobjc_sender_dependent_dispatch, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fobjc-subscripting-legacy-runtime", fobjc_subscripting_legacy_runtime, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow Objective-C array and dictionary subscripting in legacy runtime", nullptr, nullptr)
+OPTION(prefix_1, "fobjc-weak", fobjc_weak, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable ARC-style weak references in Objective-C", nullptr, nullptr)
+OPTION(prefix_1, "fomit-frame-pointer", fomit_frame_pointer, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-cuda-blocks-per-sm=", fopenmp_cuda_blocks_per_sm_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-cuda-force-full-runtime", fopenmp_cuda_force_full_runtime, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-cuda-mode", fopenmp_cuda_mode, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-cuda-number-of-sm=", fopenmp_cuda_number_of_sm_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-dump-offload-linker-script", fopenmp_dump_offload_linker_script, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-host-ir-file-path", fopenmp_host_ir_file_path, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Path to the IR file produced by the frontend for the host.", nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-is-device", fopenmp_is_device, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate code only for an OpenMP target device.", nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-optimistic-collapse", fopenmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-relocatable-target", fopenmp_relocatable_target, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-simd", fopenmp_simd, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused, 0,
+       "Emit OpenMP code only for SIMD-based constructs.", nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-targets=", fopenmp_targets_EQ, CommaJoined, INVALID, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify comma-separated list of triples OpenMP offloading targets to be supported", nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-use-tls", fopenmp_use_tls, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp-version=", fopenmp_version_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp=", fopenmp_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fopenmp", fopenmp, Flag, f_Group, INVALID, nullptr, CC1Option | NoArgumentUnused, 0,
+       "Parse OpenMP pragmas and generate parallel code.", nullptr, nullptr)
+OPTION(prefix_1, "foperator-arrow-depth=", foperator_arrow_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "foperator-arrow-depth", foperator_arrow_depth, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Maximum number of 'operator->'s to call for a member access", nullptr, nullptr)
+OPTION(prefix_1, "foptimization-record-file=", foptimization_record_file_EQ, Joined, f_Group, INVALID, nullptr, 0, 0,
+       "Specify the file name of any generated YAML optimization record", nullptr, nullptr)
+OPTION(prefix_1, "foptimize-sibling-calls", foptimize_sibling_calls, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "for-linker=", _for_linker_EQ, Joined, INVALID, Xlinker, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "for-linker", _for_linker, Separate, INVALID, Xlinker, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "force-link=", _force_link_EQ, Joined, INVALID, u, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "force-link", _force_link, Separate, INVALID, u, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "force_cpusubtype_ALL", force__cpusubtype__ALL, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "force_flat_namespace", force__flat__namespace, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "force_load", force__load, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "foutput-class-dir=", foutput_class_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "foverride-record-layout=", foverride_record_layout_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Override record layouts with those in the given file", nullptr, nullptr)
+OPTION(prefix_2, "Fo", _SLASH_Fo, Joined, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Set output object file, or directory (ends in / or \\) (with /c)", "<file or directory>", nullptr)
+OPTION(prefix_2, "fp:except-", _SLASH_fp_except_, Flag, cl_Group, fno_trapping_math, nullptr, CLOption | DriverOption | CLOption, 0,
+       "", nullptr, nullptr)
+OPTION(prefix_2, "fp:except", _SLASH_fp_except, Flag, cl_Group, ftrapping_math, nullptr, CLOption | DriverOption | CLOption, 0,
+       "", nullptr, nullptr)
+OPTION(prefix_2, "fp:fast", _SLASH_fp_fast, Flag, cl_Group, ffast_math, nullptr, CLOption | DriverOption | CLOption, 0,
+       "", nullptr, nullptr)
+OPTION(prefix_2, "fp:precise", _SLASH_fp_precise, Flag, cl_Group, fno_fast_math, nullptr, CLOption | DriverOption | CLOption, 0,
+       "", nullptr, nullptr)
+OPTION(prefix_2, "fp:strict", _SLASH_fp_strict, Flag, cl_Group, fno_fast_math, nullptr, CLOption | DriverOption | CLOption, 0,
+       "", nullptr, nullptr)
+OPTION(prefix_1, "fpack-derived", pack_derived_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpack-struct=", fpack_struct_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify the default maximum struct packing alignment", nullptr, nullptr)
+OPTION(prefix_1, "fpack-struct", fpack_struct, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpadding-on-unsigned-fixed-point", fpadding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Force each unsigned fixed point type to have an extra bit of padding to align their scales with those of signed fixed point types", nullptr, nullptr)
+OPTION(prefix_1, "fparse-all-comments", fparse_all_comments, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpascal-strings", fpascal_strings, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Recognize and construct Pascal-style string literals", nullptr, nullptr)
+OPTION(prefix_1, "fpass-plugin=", fpass_plugin_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Load pass plugin from a dynamic shared object file (only with new pass manager).", "<dsopath>", nullptr)
+OPTION(prefix_1, "fpcc-struct-return", fpcc_struct_return, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Override the default ABI to return all structs on the stack", nullptr, nullptr)
+OPTION(prefix_1, "fpch-preprocess", fpch_preprocess, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpeel-loops", peel_loops_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpermissive", permissive_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fPIC", fPIC, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpic", fpic, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fPIE", fPIE, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpie", fpie, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fplt", fplt, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use the PLT to make function calls", nullptr, nullptr)
+OPTION(prefix_1, "fplugin=", fplugin_EQ, Joined, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Load the named plugin (dynamic shared object)", "<dsopath>", nullptr)
+OPTION(prefix_1, "fprebuilt-module-path=", fprebuilt_module_path, Joined, i_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specify the prebuilt module path", "<directory>", nullptr)
+OPTION(prefix_1, "fprefetch-loop-arrays", prefetch_loop_arrays_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpreserve-as-comments", fpreserve_as_comments, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fpreserve-vec3-type", fpreserve_vec3_type, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Preserve 3-component vector type", nullptr, nullptr)
+OPTION(prefix_1, "fprintf", printf_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-arcs", fprofile_arcs, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-correction", profile_correction_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-dir=", fprofile_dir, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-exclude-files=", fprofile_exclude_files_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Instrument only functions from files where names don't match all the regexes separated by a semi-colon", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-filter-files=", fprofile_filter_files_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Instrument only functions from files where names match any regex separated by a semi-colon", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-generate-sampling", profile_generate_sampling_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-generate=", fprofile_generate_EQ, Joined, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)", "<directory>", nullptr)
+OPTION(prefix_1, "fprofile-generate", fprofile_generate, Flag, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instr-generate=", fprofile_instr_generate_EQ, Joined, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)", "<file>", nullptr)
+OPTION(prefix_1, "fprofile-instr-generate", fprofile_instr_generate, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instr-use=", fprofile_instr_use_EQ, Joined, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Use instrumentation data for profile-guided optimization", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instr-use", fprofile_instr_use, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instrument-path=", fprofile_instrument_path_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instrument-use-path=", fprofile_instrument_use_path_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Specify the profile path in PGO use compilation", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-instrument=", fprofile_instrument_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable PGO instrumentation. The accepted value is clang, llvm, or none", nullptr, "none,clang,llvm")
+OPTION(prefix_1, "fprofile-remapping-file=", fprofile_remapping_file_EQ, Joined, f_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Use the remappings described in <file> to match the profile data against names in the program", "<file>", nullptr)
+OPTION(prefix_1, "fprofile-remapping-file", fprofile_remapping_file, Separate, f_Group, fprofile_remapping_file_EQ, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-reusedist", profile_reusedist_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-sample-accurate", fprofile_sample_accurate, Flag, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Specifies that the sample profile is accurate", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-sample-use=", fprofile_sample_use_EQ, Joined, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Enable sample-based profile guided optimizations", nullptr, nullptr)
+OPTION(prefix_1, "fprofile-sample-use", fprofile_sample_use, Flag, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-use=", fprofile_use_EQ, Joined, f_Group, INVALID, nullptr, DriverOption, 0,
+       "Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.", "<pathname>", nullptr)
+OPTION(prefix_1, "fprofile-use", fprofile_use, Flag, f_Group, fprofile_instr_use, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile-values", profile_values_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprofile", profile_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fprotect-parens", protect_parens_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Fp", _SLASH_Fp, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set pch filename (with /Yc and /Yu)", "<filename>", nullptr)
+OPTION(prefix_1, "framework", framework, Separate, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frandom-seed=", frandom_seed_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frange-check", range_check_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-4-real-10", real_4_real_10_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-4-real-16", real_4_real_16_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-4-real-8", real_4_real_8_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-8-real-10", real_8_real_10_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-8-real-16", real_8_real_16_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freal-8-real-4", real_8_real_4_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frealloc-lhs", realloc_lhs_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freciprocal-math", freciprocal_math, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allow division operations to be reassociated", nullptr, nullptr)
+OPTION(prefix_1, "frecord-command-line", frecord_command_line, Flag, f_clang_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frecord-gcc-switches", anonymous_8, Flag, INVALID, frecord_command_line, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frecord-marker=", frecord_marker_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frecursive", recursive_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freg-struct-return", freg_struct_return, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Override the default ABI to return small structs in registers", nullptr, nullptr)
+OPTION(prefix_1, "fregister-global-dtors-with-atexit", fregister_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use atexit or __cxa_atexit to register global destructors", nullptr, nullptr)
+OPTION(prefix_1, "fregs-graph", regs_graph_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frelaxed-template-template-args", frelaxed_template_template_args, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable C++17 relaxed template template argument matching", nullptr, nullptr)
+OPTION(prefix_1, "frename-registers", rename_registers_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freorder-blocks", reorder_blocks_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frepack-arrays", repack_arrays_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "freroll-loops", freroll_loops, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Turn on loop reroller", nullptr, nullptr)
+OPTION(prefix_1, "fretain-comments-from-system-headers", fretain_comments_from_system_headers, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frewrite-imports", frewrite_imports, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frewrite-includes", frewrite_includes, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frewrite-map-file=", frewrite_map_file_EQ, Joined, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frewrite-map-file", frewrite_map_file, Separate, f_Group, INVALID, nullptr, DriverOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fripa", ripa_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fropi", fropi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frounding-math", rounding_math_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frtlib-add-rpath", frtlib_add_rpath, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, 0,
+       "Add -rpath with architecture-specific resource directory to the linker flags", nullptr, nullptr)
+OPTION(prefix_1, "frtti", frtti, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "frwpi", frwpi, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "FR", _SLASH_FR, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Fr", _SLASH_Fr, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-address-field-padding=", fsanitize_address_field_padding, Joined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Level of field padding for AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-address-globals-dead-stripping", fsanitize_address_globals_dead_stripping, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable linker dead stripping of globals in AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-address-poison-custom-array-cookie", fsanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable poisoning array cookies when using custom operator new[] in AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-address-use-after-scope", fsanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable use-after-scope detection in AddressSanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-address-use-odr-indicator", fsanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-blacklist=", fsanitize_blacklist, Joined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Path to blacklist file for sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-cfi-cross-dso", fsanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable control flow integrity (CFI) checks for cross-DSO calls.", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-cfi-icall-generalize-pointers", fsanitize_cfi_icall_generalize_pointers, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Generalize pointers in CFI indirect call type signature checks", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-8bit-counters", fsanitize_coverage_8bit_counters, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable frequency counters in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-indirect-calls", fsanitize_coverage_indirect_calls, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable sanitizer coverage for indirect calls", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-inline-8bit-counters", fsanitize_coverage_inline_8bit_counters, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable inline 8-bit counters in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-no-prune", fsanitize_coverage_no_prune, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable coverage pruning (i.e. instrument all blocks/edges)", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-pc-table", fsanitize_coverage_pc_table, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Create a table of coverage-instrumented PCs", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-stack-depth", fsanitize_coverage_stack_depth, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable max stack depth tracing", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-bb", fsanitize_coverage_trace_bb, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable basic block tracing in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-cmp", fsanitize_coverage_trace_cmp, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable cmp instruction tracing in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-div", fsanitize_coverage_trace_div, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable div instruction tracing in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-gep", fsanitize_coverage_trace_gep, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable gep instruction tracing in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-pc-guard", fsanitize_coverage_trace_pc_guard, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable PC tracing with guard in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-trace-pc", fsanitize_coverage_trace_pc, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable PC tracing in sanitizer coverage", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage-type=", fsanitize_coverage_type, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Sanitizer coverage type", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-coverage=", fsanitize_coverage, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Specify the type of coverage instrumentation for Sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-hwaddress-abi=", fsanitize_hwaddress_abi_EQ, Joined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Select the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor)", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-link-c++-runtime", fsanitize_link_cxx_runtime, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-memory-track-origins=", fsanitize_memory_track_origins_EQ, Joined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable origins tracking in MemorySanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-memory-track-origins", fsanitize_memory_track_origins, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable origins tracking in MemorySanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-memory-use-after-dtor", fsanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable use-after-destroy detection in MemorySanitizer", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-minimal-runtime", fsanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-recover=", fsanitize_recover_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable recovery for specified sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-recover", fsanitize_recover, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-stats", fsanitize_stats, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable sanitizer statistics gathering.", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-thread-atomics", fsanitize_thread_atomics, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable atomic operations instrumentation in ThreadSanitizer (default)", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-thread-func-entry-exit", fsanitize_thread_func_entry_exit, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable function entry/exit instrumentation in ThreadSanitizer (default)", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-thread-memory-access", fsanitize_thread_memory_access, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable memory access instrumentation in ThreadSanitizer (default)", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-trap=", fsanitize_trap_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable trapping for specified sanitizers", nullptr, nullptr)
+OPTION(prefix_1, "fsanitize-undefined-strip-path-components=", fsanitize_undefined_strip_path_components_EQ, Joined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Strip (or keep only, if negative) a given number of path components when emitting check metadata.", "<number>", nullptr)
+OPTION(prefix_1, "fsanitize-undefined-trap-on-error", fsanitize_undefined_trap_on_error, Flag, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsanitize=", fsanitize_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks", "<check>", nullptr)
+OPTION(prefix_1, "fsave-optimization-record", fsave_optimization_record, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Generate a YAML optimization record file", nullptr, nullptr)
+OPTION(prefix_1, "fsched-interblock", anonymous_22, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fschedule-insns2", schedule_insns2_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fschedule-insns", schedule_insns_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsecond-underscore", second_underscore_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsee", see_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fseh-exceptions", fseh_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use SEH style exceptions", nullptr, nullptr)
+OPTION(prefix_1, "fshort-enums", fshort_enums, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Allocate to an enum type only as many bytes as it needs for the declared range of possible values", nullptr, nullptr)
+OPTION(prefix_1, "fshort-wchar", fshort_wchar, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Force wchar_t to be a short unsigned int", nullptr, nullptr)
+OPTION(prefix_1, "fshow-column", fshow_column, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fshow-overloads=", fshow_overloads_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Which overload candidates to show when overload resolution fails: best|all; defaults to all", nullptr, "best,all")
+OPTION(prefix_1, "fshow-source-location", fshow_source_location, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsign-zero", sign_zero_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsignaling-math", fsignaling_math, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsignaling-nans", signaling_nans_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsigned-bitfields", fsigned_bitfields, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsigned-char", fsigned_char, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsigned-wchar", fsigned_wchar, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use a signed type for wchar_t", nullptr, nullptr)
+OPTION(prefix_1, "fsigned-zeros", fsigned_zeros, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsingle-precision-constant", single_precision_constant_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsized-deallocation", fsized_deallocation, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable C++14 sized global deallocation functions", nullptr, nullptr)
+OPTION(prefix_1, "fsjlj-exceptions", fsjlj_exceptions, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use SjLj style exceptions", nullptr, nullptr)
+OPTION(prefix_1, "fslp-vectorize-aggressive", anonymous_0, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fslp-vectorize", fslp_vectorize, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable the superword-level parallelism vectorization passes", nullptr, nullptr)
+OPTION(prefix_1, "fspec-constr-count", spec_constr_count_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fspell-checking-limit=", fspell_checking_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fspell-checking-limit", fspell_checking_limit, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit).", "<N>", nullptr)
+OPTION(prefix_1, "fspell-checking", fspell_checking, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsplit-dwarf-inlining", fsplit_dwarf_inlining, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF", nullptr, nullptr)
+OPTION(prefix_1, "fsplit-lto-unit", fsplit_lto_unit, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Enables splitting of the LTO unit.", nullptr, nullptr)
+OPTION(prefix_1, "fsplit-stack", fsplit_stack, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstack-arrays", stack_arrays_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstack-check", stack_check_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstack-protector-all", fstack_protector_all, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable stack protectors for all functions", nullptr, nullptr)
+OPTION(prefix_1, "fstack-protector-strong", fstack_protector_strong, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable stack protectors for some functions vulnerable to stack smashing. Compared to -fstack-protector, this uses a stronger heuristic that includes functions containing arrays of any size (and any type), as well as any calls to alloca or the taking of an address from a local variable", nullptr, nullptr)
+OPTION(prefix_1, "fstack-protector", fstack_protector, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable stack protectors for some functions vulnerable to stack smashing. This uses a loose heuristic which considers functions vulnerable if they contain a char (or 8bit integer) array or constant sized calls to alloca, which are of greater size than ssp-buffer-size (default: 8 bytes). All variable sized calls to alloca are considered vulnerable", nullptr, nullptr)
+OPTION(prefix_1, "fstack-size-section", fstack_size_section, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Emit section containing metadata on function stack sizes", nullptr, nullptr)
+OPTION(prefix_1, "fstandalone-debug", fstandalone_debug, Flag, f_Group, INVALID, nullptr, CoreOption, 0,
+       "Emit full debug info for all types used by the program", nullptr, nullptr)
+OPTION(prefix_1, "fstrength-reduce", strength_reduce_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstrict-aliasing", fstrict_aliasing, Flag, f_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstrict-enums", fstrict_enums, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable optimizations based on the strict definition of an enum's value range", nullptr, nullptr)
+OPTION(prefix_1, "fstrict-float-cast-overflow", fstrict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Assume that overflowing float-to-int casts are undefined (default)", nullptr, nullptr)
+OPTION(prefix_1, "fstrict-overflow", fstrict_overflow, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fstrict-return", fstrict_return, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Always treat control flow paths that fall off the end of a non-void function as unreachable", nullptr, nullptr)
+OPTION(prefix_1, "fstrict-vtable-pointers", fstrict_vtable_pointers, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable optimizations based on the strict rules for overwriting polymorphic C++ objects", nullptr, nullptr)
+OPTION(prefix_1, "fstruct-path-tbaa", fstruct_path_tbaa, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fsyntax-only", fsyntax_only, Flag, Action_Group, INVALID, nullptr, DriverOption | CoreOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "FS", _SLASH_FS, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftabstop=", ftabstop_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftabstop", ftabstop, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the tab stop distance.", "<N>", nullptr)
+OPTION(prefix_1, "ftemplate-backtrace-limit=", ftemplate_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftemplate-backtrace-limit", ftemplate_backtrace_limit, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit).", "<N>", nullptr)
+OPTION(prefix_1, "ftemplate-depth-", ftemplate_depth_, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftemplate-depth=", ftemplate_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftemplate-depth", ftemplate_depth, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Maximum depth of recursive template instantiation", nullptr, nullptr)
+OPTION(prefix_1, "fterminated-vtables", anonymous_27, Flag, INVALID, fapple_kext, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftest-coverage", ftest_coverage, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftest-module-file-extension=", ftest_module_file_extension_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "introduce a module file extension for testing purposes. The argument is parsed as blockname:major:minor:hashed:user info", nullptr, nullptr)
+OPTION(prefix_1, "fthin-link-bitcode=", fthin_link_bitcode_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Write minimized bitcode to <file> for the ThinLTO thin link only", nullptr, nullptr)
+OPTION(prefix_1, "fthinlto-index=", fthinlto_index_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Perform ThinLTO importing using provided function summary index", nullptr, nullptr)
+OPTION(prefix_1, "fthreadsafe-statics", fthreadsafe_statics, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftime-report", ftime_report, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftls-model=", ftlsmodel_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftls-model", tls_model_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftracer", tracer_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftrap-function=", ftrap_function_EQ, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Issue call to specified function rather than a trap instruction", nullptr, nullptr)
+OPTION(prefix_1, "ftrapping-math", ftrapping_math, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftrapv-handler=", ftrapv_handler_EQ, Joined, f_Group, INVALID, nullptr, 0, 0,
+       "Specify the function to be called on overflow", "<function name>", nullptr)
+OPTION(prefix_1, "ftrapv-handler", ftrapv_handler, Separate, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftrapv", ftrapv, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Trap on integer overflow", nullptr, nullptr)
+OPTION(prefix_1, "ftree-dce", tree_dce_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-salias", tree_salias_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-slp-vectorize", anonymous_25, Flag, INVALID, fslp_vectorize, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-ter", tree_ter_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-vectorizer-verbose", tree_vectorizer_verbose_f, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-vectorize", anonymous_23, Flag, INVALID, fvectorize, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree-vrp", tree_vrp_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree_loop_im", tree_loop_im_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree_loop_ivcanon", tree_loop_ivcanon_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftree_loop_linear", tree_loop_linear_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ftrigraphs", ftrigraphs, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Process trigraph sequences", nullptr, nullptr)
+OPTION(prefix_1, "ftrivial-auto-var-init=", ftrivial_auto_var_init, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Initialize trivial automatic stack variables: uninitialized (default) | pattern", nullptr, "uninitialized,pattern")
+OPTION(prefix_1, "ftype-visibility", ftype_visibility, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Default type visibility", nullptr, nullptr)
+OPTION(prefix_1, "function-alignment", function_alignment, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "default alignment for functions", nullptr, nullptr)
+OPTION(prefix_1, "funderscoring", underscoring_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funique-section-names", funique_section_names, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use unique names for text and data sections (ELF Only)", nullptr, nullptr)
+OPTION(prefix_1, "funit-at-a-time", funit_at_a_time, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funknown-anytype", funknown_anytype, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable parser support for the __unknown_anytype type; for testing purposes only", nullptr, nullptr)
+OPTION(prefix_1, "funroll-all-loops", unroll_all_loops_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funroll-loops", funroll_loops, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Turn on loop unroller", nullptr, nullptr)
+OPTION(prefix_1, "funsafe-loop-optimizations", unsafe_loop_optimizations_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funsafe-math-optimizations", funsafe_math_optimizations, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funsigned-bitfields", funsigned_bitfields, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funsigned-char", funsigned_char, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funswitch-loops", unswitch_loops_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "funwind-tables", funwind_tables, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fuse-cxa-atexit", fuse_cxa_atexit, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fuse-init-array", fuse_init_array, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use .init_array instead of .ctors", nullptr, nullptr)
+OPTION(prefix_1, "fuse-ld=", fuse_ld_EQ, Joined, f_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fuse-line-directives", fuse_line_directives, Flag, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fuse-linker-plugin", use_linker_plugin_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fuse-register-sized-bitfield-access", fuse_register_sized_bitfield_access, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use register sized accesses to bit-fields, when possible.", nullptr, nullptr)
+OPTION(prefix_2, "FU", _SLASH_FU, JoinedOrSeparate, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fvariable-expansion-in-unroller", variable_expansion_in_unroller_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fveclib=", fveclib, Joined, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Use the given vector functions library", nullptr, "Accelerate,SVML,none")
+OPTION(prefix_1, "fvect-cost-model", vect_cost_model_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fvectorize", fvectorize, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Enable the loop vectorization passes", nullptr, nullptr)
+OPTION(prefix_1, "fverbose-asm", fverbose_asm, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fvisibility-global-new-delete-hidden", fvisibility_global_new_delete_hidden, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Give global C++ operator new and delete declarations hidden visibility", nullptr, nullptr)
+OPTION(prefix_1, "fvisibility-inlines-hidden", fvisibility_inlines_hidden, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Give inline C++ member functions hidden visibility by default", nullptr, nullptr)
+OPTION(prefix_1, "fvisibility-ms-compat", fvisibility_ms_compat, Flag, f_Group, INVALID, nullptr, 0, 0,
+       "Give global types 'default' visibility and global functions and variables 'hidden' visibility by default", nullptr, nullptr)
+OPTION(prefix_1, "fvisibility=", fvisibility_EQ, Joined, f_Group, INVALID, nullptr, 0, 0,
+       "Set the default symbol visibility for all global declarations", nullptr, "hidden,default")
+OPTION(prefix_1, "fvisibility", fvisibility, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Default type and symbol visibility", nullptr, nullptr)
+OPTION(prefix_1, "fwchar-type=", fwchar_type_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Select underlying type for wchar_t", nullptr, "char,short,int")
+OPTION(prefix_1, "fweb", web_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fwhole-file", whole_file_f, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fwhole-program-vtables", fwhole_program_vtables, Flag, f_Group, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Enables whole-program vtable optimization. Requires -flto", nullptr, nullptr)
+OPTION(prefix_1, "fwhole-program", whole_program_f, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fwrapv", fwrapv, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Treat signed integer overflow as two's complement", nullptr, nullptr)
+OPTION(prefix_1, "fwritable-strings", fwritable_strings, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Store string literals as writable data", nullptr, nullptr)
+OPTION(prefix_1, "fxray-always-emit-customevents", fxray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Determine whether to always emit __xray_customevent(...) calls even if the function it appears in is not always instrumented.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-always-emit-typedevents", fxray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Determine whether to always emit __xray_typedevent(...) calls even if the function it appears in is not always instrumented.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-always-instrument=", fxray_always_instrument, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-attr-list=", fxray_attr_list, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Filename defining the list of functions/types for imbuing XRay attributes.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-instruction-threshold=", fxray_instruction_threshold_EQ, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Sets the minimum function size to instrument with XRay", nullptr, nullptr)
+OPTION(prefix_1, "fxray-instruction-threshold", fxray_instruction_threshold_, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fxray-instrumentation-bundle=", fxray_instrumentation_bundle, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Select which XRay instrumentation points to emit. Options: all, none, function, custom. Default is 'all'.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-instrument", fxray_instrument, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Generate XRay instrumentation sleds on function entry and exit", nullptr, nullptr)
+OPTION(prefix_1, "fxray-link-deps", fxray_link_deps, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Tells clang to add the link dependencies for XRay.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-modes=", fxray_modes, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "List of modes to link in by default into XRay instrumented binaries.", nullptr, nullptr)
+OPTION(prefix_1, "fxray-never-instrument=", fxray_never_instrument, JoinedOrSeparate, f_Group, INVALID, nullptr, CC1Option, 0,
+       "DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.", nullptr, nullptr)
+OPTION(prefix_2, "Fx", _SLASH_Fx, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fzero-initialized-in-bss", fzero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "fzvector", fzvector, Flag, f_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable System z vector language extension", nullptr, nullptr)
+OPTION(prefix_1, "F", F, JoinedOrSeparate, INVALID, INVALID, nullptr, RenderJoined | CC1Option, 0,
+       "Add directory to framework include search path", nullptr, nullptr)
+OPTION(prefix_2, "F", _SLASH_F, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "g0", g0, Flag, gN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "G1", _SLASH_G1, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "g1", g1, Flag, gN_Group, gline_tables_only, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "G2", _SLASH_G2, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "g2", g2, Flag, gN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "g3", g3, Flag, gN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "G=", G_EQ, Joined, m_Group, G, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GA", _SLASH_GA, Flag, cl_Group, ftlsmodel_EQ, "local-exec\0", CLOption | DriverOption | CLOption, 0,
+       "Assume thread-local variables are defined in the executable", nullptr, nullptr)
+OPTION(prefix_3, "gcc-toolchain=", gcc_toolchain, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Use the gcc toolchain at the given directory", nullptr, nullptr)
+OPTION(prefix_1, "gcc-toolchain", gcc_toolchain_legacy_spelling, Separate, INVALID, gcc_toolchain, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gcodeview-ghash", gcodeview_ghash, Flag, INVALID, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Emit type record hashes in a .debug$H section", nullptr, nullptr)
+OPTION(prefix_1, "gcodeview", gcodeview, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | CoreOption, 0,
+       "Generate CodeView debug information", nullptr, nullptr)
+OPTION(prefix_1, "gcoff", gcoff, Joined, g_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gcolumn-info", gcolumn_info, Flag, g_flags_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gdwarf-2", gdwarf_2, Flag, g_Group, INVALID, nullptr, 0, 0,
+       "Generate source-level debug information with dwarf version 2", nullptr, nullptr)
+OPTION(prefix_1, "gdwarf-3", gdwarf_3, Flag, g_Group, INVALID, nullptr, 0, 0,
+       "Generate source-level debug information with dwarf version 3", nullptr, nullptr)
+OPTION(prefix_1, "gdwarf-4", gdwarf_4, Flag, g_Group, INVALID, nullptr, 0, 0,
+       "Generate source-level debug information with dwarf version 4", nullptr, nullptr)
+OPTION(prefix_1, "gdwarf-5", gdwarf_5, Flag, g_Group, INVALID, nullptr, 0, 0,
+       "Generate source-level debug information with dwarf version 5", nullptr, nullptr)
+OPTION(prefix_1, "gdwarf-aranges", gdwarf_aranges, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gdwarf", gdwarf, Flag, INVALID, gdwarf_4, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gd", _SLASH_Gd, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set __cdecl as a default calling convention", nullptr, nullptr)
+OPTION(prefix_1, "gembed-source", gembed_source, Flag, g_flags_Group, INVALID, nullptr, CC1Option, 0,
+       "Embed source text in DWARF debug sections", nullptr, nullptr)
+OPTION(prefix_1, "gen-reproducer", gen_reproducer, Flag, internal_debug_Group, INVALID, nullptr, DriverOption | HelpHidden | CoreOption, 0,
+       "Auto-generates preprocessed source files and a reproduction script", nullptr, nullptr)
+OPTION(prefix_2, "Ge", _SLASH_Ge, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GF-", _SLASH_GF_, Flag, cl_Group, fwritable_strings, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable string pooling", nullptr, nullptr)
+OPTION(prefix_1, "gfull", gfull, Flag, g_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GF", _SLASH_GF, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Enable string pooling (default)", nullptr, nullptr)
+OPTION(prefix_1, "ggdb0", ggdb0, Flag, ggdbN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ggdb1", ggdb1, Flag, ggdbN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ggdb2", ggdb2, Flag, ggdbN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ggdb3", ggdb3, Flag, ggdbN_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ggdb", ggdb, Flag, gTune_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "ggnu-pubnames", ggnu_pubnames, Flag, g_flags_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GH", _SLASH_GH, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gh", _SLASH_Gh, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GL-", _SLASH_GL_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gline-directives-only", gline_directives_only, Flag, gN_Group, INVALID, nullptr, CoreOption, 0,
+       "Emit debug line info directives only", nullptr, nullptr)
+OPTION(prefix_1, "gline-tables-only", gline_tables_only, Flag, gN_Group, INVALID, nullptr, CoreOption, 0,
+       "Emit debug line number tables only", nullptr, nullptr)
+OPTION(prefix_1, "glldb", glldb, Flag, gTune_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GL", _SLASH_GL, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gm-", _SLASH_Gm_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gmlt", gmlt, Flag, INVALID, gline_tables_only, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gmodules", gmodules, Flag, gN_Group, INVALID, nullptr, 0, 0,
+       "Generate debug info with external references to clang modules or precompiled headers", nullptr, nullptr)
+OPTION(prefix_2, "Gm", _SLASH_Gm, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-codeview-ghash", gno_codeview_ghash, Flag, INVALID, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-column-info", gno_column_info, Flag, g_flags_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-embed-source", gno_embed_source, Flag, g_flags_Group, INVALID, nullptr, DriverOption, 0,
+       "Restore the default behavior of not embedding source text in DWARF debug sections", nullptr, nullptr)
+OPTION(prefix_1, "gno-gnu-pubnames", gno_gnu_pubnames, Flag, g_flags_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-pubnames", gno_pubnames, Flag, g_flags_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-record-command-line", gno_record_command_line, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-record-gcc-switches", anonymous_29, Flag, INVALID, gno_record_command_line, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gno-strict-dwarf", gno_strict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gpubnames", gpubnames, Flag, g_flags_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GR-", _SLASH_GR_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable emission of RTTI data", nullptr, nullptr)
+OPTION(prefix_1, "grecord-command-line", grecord_command_line, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "grecord-gcc-switches", anonymous_28, Flag, INVALID, grecord_command_line, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gregcall", _SLASH_Gregcall, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set __regcall as a default calling convention", nullptr, nullptr)
+OPTION(prefix_2, "GR", _SLASH_GR, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable emission of RTTI data", nullptr, nullptr)
+OPTION(prefix_2, "Gr", _SLASH_Gr, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set __fastcall as a default calling convention", nullptr, nullptr)
+OPTION(prefix_2, "GS-", _SLASH_GS_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable buffer security check", nullptr, nullptr)
+OPTION(prefix_1, "gsce", gsce, Flag, gTune_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gsplit-dwarf=", gsplit_dwarf_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, 0,
+       "Set DWARF fission mode to either 'split' or 'single'", nullptr, "split,single")
+OPTION(prefix_1, "gsplit-dwarf", gsplit_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gstabs", gstabs, Joined, g_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gstrict-dwarf", gstrict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GS", _SLASH_GS, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable buffer security check (default)", nullptr, nullptr)
+OPTION(prefix_2, "Gs", anonymous_35, Flag, cl_Group, mstack_probe_size, "4096\0", CLOption | DriverOption | CLOption, 0,
+       "Use stack probes (default)", nullptr, nullptr)
+OPTION(prefix_2, "Gs", _SLASH_Gs, Joined, cl_Group, mstack_probe_size, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set stack probe size (default 4096)", nullptr, nullptr)
+OPTION(prefix_1, "gtoggle", gtoggle, Flag, g_flags_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GT", _SLASH_GT, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "guard:", _SLASH_guard, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable Control Flow Guard with /guard:cf, or only the table with /guard:cf,nochecks", nullptr, nullptr)
+OPTION(prefix_1, "gused", gused, Flag, g_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "gvms", gvms, Joined, g_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gv", _SLASH_Gv, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set __vectorcall as a default calling convention", nullptr, nullptr)
+OPTION(prefix_2, "Gw-", _SLASH_Gw_, Flag, cl_Group, fno_data_sections, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't put each data item in its own section", nullptr, nullptr)
+OPTION(prefix_2, "Gw", _SLASH_Gw, Flag, cl_Group, fdata_sections, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Put each data item in its own section", nullptr, nullptr)
+OPTION(prefix_2, "GX-", _SLASH_GX_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable exception handling", nullptr, nullptr)
+OPTION(prefix_1, "gxcoff", gxcoff, Joined, g_Group, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "GX", _SLASH_GX, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable exception handling", nullptr, nullptr)
+OPTION(prefix_2, "Gy-", _SLASH_Gy_, Flag, cl_Group, fno_function_sections, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't put each function in its own section (default)", nullptr, nullptr)
+OPTION(prefix_2, "Gy", _SLASH_Gy, Flag, cl_Group, ffunction_sections, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Put each function in its own section", nullptr, nullptr)
+OPTION(prefix_1, "gz=", gz_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, 0,
+       "DWARF debug sections compression type", nullptr, nullptr)
+OPTION(prefix_2, "GZ", _SLASH_GZ, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Gz", _SLASH_Gz, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set __stdcall as a default calling convention", nullptr, nullptr)
+OPTION(prefix_1, "gz", gz, Flag, g_flags_Group, INVALID, nullptr, 0, 0,
+       "DWARF debug sections compression type", nullptr, nullptr)
+OPTION(prefix_1, "G", G, JoinedOrSeparate, m_Group, INVALID, nullptr, DriverOption, 0,
+       "Put objects of at most <size> bytes into small data section (MIPS / Hexagon)", "<size>", nullptr)
+OPTION(prefix_1, "g", g_Flag, Flag, g_Group, INVALID, nullptr, 0, 0,
+       "Generate source-level debug information", nullptr, nullptr)
+OPTION(prefix_1, "header-include-file", header_include_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Filename (or -) to write header include output to", nullptr, nullptr)
+OPTION(prefix_1, "headerpad_max_install_names", headerpad__max__install__names, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "help-hidden", _help_hidden, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Display help for hidden options", nullptr, nullptr)
+OPTION(prefix_2, "HELP", _SLASH_HELP, Flag, cl_Group, help, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "help", help, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption, 0,
+       "Display available options", nullptr, nullptr)
+OPTION(prefix_2, "help", _SLASH_help, Flag, cl_Group, help, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Display available options", nullptr, nullptr)
+OPTION(prefix_3, "hip-device-lib-path=", hip_device_lib_path_EQ, Joined, Link_Group, INVALID, nullptr, 0, 0,
+       "HIP device library path", nullptr, nullptr)
+OPTION(prefix_3, "hip-device-lib=", hip_device_lib_EQ, Joined, Link_Group, INVALID, nullptr, 0, 0,
+       "HIP device library", nullptr, nullptr)
+OPTION(prefix_3, "hip-link", hip_link, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Link clang-offload-bundler bundles for HIP", nullptr, nullptr)
+OPTION(prefix_2, "homeparams", _SLASH_homeparams, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "hotpatch", _SLASH_hotpatch, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "H", H, Flag, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Show header includes and nesting depth", nullptr, nullptr)
+OPTION(prefix_2, "H", _SLASH_H, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "I-", I_, Flag, I_Group, INVALID, nullptr, 0, 0,
+       "Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path", nullptr, nullptr)
+OPTION(prefix_1, "idirafter", idirafter, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to AFTER include search path", nullptr, nullptr)
+OPTION(prefix_1, "iframeworkwithsysroot", iframeworkwithsysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot", "<directory>", nullptr)
+OPTION(prefix_1, "iframework", iframework, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to SYSTEM framework search path", nullptr, nullptr)
+OPTION(prefix_3, "imacros=", _imacros_EQ, Joined, INVALID, imacros, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "imacros", imacros, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Include macros from file before parsing", "<file>", nullptr)
+OPTION(prefix_1, "image_base", image__base, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "imsvc", _SLASH_imsvc, JoinedOrSeparate, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Add directory to system include search path, as if part of %INCLUDE%", "<dir>", nullptr)
+OPTION(prefix_1, "imultilib", imultilib, Separate, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-barrier", _include_barrier, Flag, INVALID, I_, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-directory-after=", _include_directory_after_EQ, Joined, INVALID, idirafter, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-directory-after", _include_directory_after, Separate, INVALID, idirafter, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-directory=", _include_directory_EQ, Joined, INVALID, I, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-directory", _include_directory, Separate, INVALID, I, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "include-pch", include_pch, Separate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Include precompiled header file", "<file>", nullptr)
+OPTION(prefix_3, "include-prefix=", _include_prefix_EQ, Joined, INVALID, iprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-prefix", _include_prefix, Separate, INVALID, iprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix-after=", _include_with_prefix_after_EQ, Joined, INVALID, iwithprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix-after", _include_with_prefix_after, Separate, INVALID, iwithprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix-before=", _include_with_prefix_before_EQ, Joined, INVALID, iwithprefixbefore, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix-before", _include_with_prefix_before, Separate, INVALID, iwithprefixbefore, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix=", _include_with_prefix_EQ, Joined, INVALID, iwithprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include-with-prefix", _include_with_prefix, Separate, INVALID, iwithprefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "include=", _include_EQ, Joined, INVALID, include, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "include", include, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Include file before parsing", "<file>", nullptr)
+OPTION(prefix_1, "index-header-map", index_header_map, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Make the next included directory (-I or -F) an indexer header map", nullptr, nullptr)
+OPTION(prefix_1, "init-only", init_only, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Only execute frontend initialization", nullptr, nullptr)
+OPTION(prefix_1, "init", init, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "install_name", install__name, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "integrated-as", anonymous_32, Flag, INVALID, fintegrated_as, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "internal-externc-isystem", internal_externc_isystem, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add directory to the internal system include search path with implicit extern \"C\" semantics; these are assumed to not be user-provided and are used to model system and standard headers' paths.", "<directory>", nullptr)
+OPTION(prefix_1, "internal-isystem", internal_isystem, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add directory to the internal system include search path; these are assumed to not be user-provided and are used to model system and standard headers' paths.", "<directory>", nullptr)
+OPTION(prefix_1, "iprefix", iprefix, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Set the -iwithprefix/-iwithprefixbefore prefix", "<dir>", nullptr)
+OPTION(prefix_1, "iquote", iquote, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to QUOTE include search path", "<directory>", nullptr)
+OPTION(prefix_1, "isysroot", isysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Set the system root directory (usually /)", "<dir>", nullptr)
+OPTION(prefix_1, "isystem-after", isystem_after, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, DriverOption, 0,
+       "Add directory to end of the SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "isystem", isystem, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "ivfsoverlay", ivfsoverlay, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Overlay the virtual filesystem described by file over the real file system", nullptr, nullptr)
+OPTION(prefix_1, "iwithprefixbefore", iwithprefixbefore, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Set directory to include search path with prefix", "<dir>", nullptr)
+OPTION(prefix_1, "iwithprefix", iwithprefix, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Set directory to SYSTEM include search path with prefix", "<dir>", nullptr)
+OPTION(prefix_1, "iwithsysroot", iwithsysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Add directory to SYSTEM include search path, absolute paths are relative to -isysroot", "<directory>", nullptr)
+OPTION(prefix_1, "I", I, JoinedOrSeparate, I_Group, INVALID, nullptr, CC1Option | CC1AsOption, 0,
+       "Add directory to include search path", "<dir>", nullptr)
+OPTION(prefix_2, "I", _SLASH_I, JoinedOrSeparate, cl_Group, I, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Add directory to include search path", "<dir>", nullptr)
+OPTION(prefix_2, "JMC", _SLASH_JMC, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "J", J, JoinedOrSeparate, gfortran_Group, INVALID, nullptr, RenderJoined, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "J", _SLASH_J, Flag, cl_Group, funsigned_char, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Make char type unsigned", nullptr, nullptr)
+OPTION(prefix_1, "keep_private_externs", keep__private__externs, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "kernel-", _SLASH_kernel_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "kernel", _SLASH_kernel, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "language=", _language_EQ, Joined, INVALID, x, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "language", _language, Separate, INVALID, x, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "lazy_framework", lazy__framework, Separate, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "lazy_library", lazy__library, Separate, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "LDd", _SLASH_LDd, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Create debug DLL", nullptr, nullptr)
+OPTION(prefix_2, "LD", _SLASH_LD, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Create DLL", nullptr, nullptr)
+OPTION(prefix_3, "libomptarget-nvptx-path=", libomptarget_nvptx_path_EQ, Joined, i_Group, INVALID, nullptr, 0, 0,
+       "Path to libomptarget-nvptx libraries", nullptr, nullptr)
+OPTION(prefix_3, "library-directory=", _library_directory_EQ, Joined, INVALID, L, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "library-directory", _library_directory, Separate, INVALID, L, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "linker-option=", linker_option, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add linker option", nullptr, nullptr)
+OPTION(prefix_2, "link", _SLASH_link, RemainingArgsJoined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Forward options to the linker", "<options>", nullptr)
+OPTION(prefix_2, "LN", _SLASH_LN, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "load", load, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Load the named plugin (dynamic shared object)", "<dsopath>", nullptr)
+OPTION(prefix_1, "L", L, JoinedOrSeparate, Link_Group, INVALID, nullptr, RenderJoined, 0,
+       "Add directory to library search path", "<dir>", nullptr)
+OPTION(prefix_1, "l", l, JoinedOrSeparate, Link_Group, INVALID, nullptr, LinkerInput | RenderJoined, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m16", m16, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m32", m32, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m3dnowa", m3dnowa, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m3dnow", m3dnow, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m64", m64, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "m80387", m80387, Flag, INVALID, mx87, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mabi=", mabi_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mabicalls", mabicalls, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable SVR4-style position-independent code (Mips only)", nullptr, nullptr)
+OPTION(prefix_1, "mabs=", mabs_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Mach", Mach, Flag, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "madx", madx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "maes", maes, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "main-file-name", main_file_name, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Main file name to use for debug info", nullptr, nullptr)
+OPTION(prefix_1, "malign-double", malign_double, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Align doubles to two words in structs (x86 only)", nullptr, nullptr)
+OPTION(prefix_1, "malign-functions=", malign_functions_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "malign-jumps=", malign_jumps_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "malign-loops=", malign_loops_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "maltivec", maltivec, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mamdgpu-debugger-abi=", mamdgpu_debugger_abi, Joined, m_Group, INVALID, nullptr, HelpHidden, 0,
+       "Generate additional code for specified <version> of debugger ABI (AMDGPU only)", "<version>", nullptr)
+OPTION(prefix_1, "mappletvos-version-min=", mappletvos_version_min_EQ, Joined, INVALID, mtvos_version_min_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mappletvsimulator-version-min=", mappletvsimulator_version_min_EQ, Joined, INVALID, mtvos_simulator_version_min_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "march=", march_EQ, Joined, m_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "marm", marm, Flag, INVALID, mno_thumb, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "masm-verbose", masm_verbose, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate verbose assembly output", nullptr, nullptr)
+OPTION(prefix_1, "masm=", masm_EQ, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "massembler-fatal-warnings", massembler_fatal_warnings, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Make assembler warnings fatal", nullptr, nullptr)
+OPTION(prefix_1, "mavx2", mavx2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512bitalg", mavx512bitalg, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512bw", mavx512bw, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512cd", mavx512cd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512dq", mavx512dq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512er", mavx512er, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512f", mavx512f, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512ifma", mavx512ifma, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512pf", mavx512pf, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512vbmi2", mavx512vbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512vbmi", mavx512vbmi, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512vl", mavx512vl, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512vnni", mavx512vnni, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx512vpopcntdq", mavx512vpopcntdq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mavx", mavx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbackchain", mbackchain, Flag, m_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Link stack frames through backchain on System Z", nullptr, nullptr)
+OPTION(prefix_1, "mbig-endian", mbig_endian, Flag, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbmi2", mbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbmi", mbmi, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbranch-likely", mbranch_likely, Flag, m_Group, INVALID, nullptr, HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbranch-protection=", mbranch_protection_EQ, Joined, INVALID, INVALID, nullptr, 0, 0,
+       "Enforce targets of indirect branches and function returns", nullptr, nullptr)
+OPTION(prefix_1, "mbranch-target-enforce", mbranch_target_enforce, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mbulk-memory", mbulk_memory, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcheck-zero-division", mcheck_zero_division, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcldemote", mcldemote, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mclflushopt", mclflushopt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mclwb", mclwb, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mclzero", mclzero, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcmodel=", mcmodel_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcmpb", mcmpb, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcode-model", mcode_model, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "The code model to use", nullptr, "tiny,small,kernel,medium,large")
+OPTION(prefix_1, "mcode-object-v3", mcode_object_v3, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable code object v3 (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "mcompact-branches=", mcompact_branches_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mconsole", mconsole, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mconstant-cfstrings", mconstant_cfstrings, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mconstructor-aliases", mconstructor_aliases, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Emit complete constructors and destructors as aliases when possible", nullptr, nullptr)
+OPTION(prefix_1, "mcpu=", mcpu_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcrbits", mcrbits, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcrc", mcrc, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Allow use of CRC instructions (ARM/Mips only)", nullptr, nullptr)
+OPTION(prefix_1, "mcrypto", mpower8_crypto, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mcx16", mcx16, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "MDd", _SLASH_MDd, Flag, _SLASH_M_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Use DLL debug run-time", nullptr, nullptr)
+OPTION(prefix_1, "mdebug-pass", mdebug_pass, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable additional debug output", nullptr, nullptr)
+OPTION(prefix_1, "mdefault-build-attributes", mdefault_build_attributes, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdirect-move", mdirect_move, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdisable-fp-elim", mdisable_fp_elim, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable frame pointer elimination optimization", nullptr, nullptr)
+OPTION(prefix_1, "mdisable-tail-calls", mdisable_tail_calls, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable tail call optimization, keeping the call stack accurate", nullptr, nullptr)
+OPTION(prefix_1, "mdll", mdll, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdouble-float", mdouble_float, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdspr2", mdspr2, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdsp", mdsp, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mdynamic-no-pic", mdynamic_no_pic, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MD", MD, Flag, M_Group, INVALID, nullptr, 0, 0,
+       "Write a depfile containing user and system headers", nullptr, nullptr)
+OPTION(prefix_2, "MD", _SLASH_MD, Flag, _SLASH_M_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Use DLL run-time", nullptr, nullptr)
+OPTION(prefix_1, "meabi", meabi, Separate, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Set EABI type, e.g. 4, 5 or gnu (default depends on triple)", nullptr, "default,4,5,gnu")
+OPTION(prefix_1, "membedded-data", membedded_data, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Place constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "menable-no-infs", menable_no_infinities, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow optimization to assume there are no infinities.", nullptr, nullptr)
+OPTION(prefix_1, "menable-no-nans", menable_no_nans, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow optimization to assume there are no NaNs.", nullptr, nullptr)
+OPTION(prefix_1, "menable-unsafe-fp-math", menable_unsafe_fp_math, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow unsafe floating-point math optimizations which may decrease precision", nullptr, nullptr)
+OPTION(prefix_1, "mexception-handling", mexception_handing, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mexecute-only", mexecute_only, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow generation of data access to code sections (ARM only)", nullptr, nullptr)
+OPTION(prefix_1, "mextern-sdata", mextern_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mf16c", mf16c, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfancy-math-387", mfancy_math_387, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfentry", mfentry, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Insert calls to fentry at function entry (x86 only)", nullptr, nullptr)
+OPTION(prefix_1, "mfix-and-continue", mfix_and_continue, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfix-cortex-a53-835769", mfix_cortex_a53_835769, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Workaround Cortex-A53 erratum 835769 (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mfloat-abi=", mfloat_abi_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, "soft,softfp,hard")
+OPTION(prefix_1, "mfloat-abi", mfloat_abi, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "The float ABI to use", nullptr, nullptr)
+OPTION(prefix_1, "mfloat128", mfloat128, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfma4", mfma4, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfma", mfma, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfp32", mfp32, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Use 32-bit floating point registers (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mfp64", mfp64, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Use 64-bit floating point registers (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mfpmath=", mfpmath_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfpmath", mfpmath, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Which unit to use for fp math", nullptr, nullptr)
+OPTION(prefix_1, "mfprnd", mfprnd, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfpu=", mfpu_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfpxx", mfpxx, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, 0,
+       "Avoid FPU mode dependent operations when used with the O32 ABI", nullptr, nullptr)
+OPTION(prefix_1, "mfsgsbase", mfsgsbase, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mfxsr", mfxsr, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MF", MF, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, 0,
+       "Write depfile output from -MMD, -MD, -MM, or -M to <file>", "<file>", nullptr)
+OPTION(prefix_1, "mgeneral-regs-only", mgeneral_regs_only, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Generate code which only uses the general purpose registers (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mgfni", mgfni, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mginv", mginv, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mglibc", mglibc, Flag, m_libc_Group, INVALID, nullptr, HelpHidden | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mglobal-merge", mglobal_merge, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable merging of globals", nullptr, nullptr)
+OPTION(prefix_1, "mgpopt", mgpopt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Use GP relative accesses for symbols known to be in a small data section (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "MG", MG, Flag, M_Group, INVALID, nullptr, CC1Option, 0,
+       "Add missing headers to depfile", nullptr, nullptr)
+OPTION(prefix_1, "mhard-float", mhard_float, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mhtm", mhtm, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mhvx-length=", mhexagon_hvx_length_EQ, Joined, m_hexagon_Features_HVX_Group, INVALID, nullptr, 0, 0,
+       "Set Hexagon Vector Length", nullptr, "64B,128B")
+OPTION(prefix_1, "mhvx=", mhexagon_hvx_EQ, Joined, m_hexagon_Features_HVX_Group, INVALID, nullptr, 0, 0,
+       "Enable Hexagon Vector eXtensions", nullptr, nullptr)
+OPTION(prefix_1, "mhvx", mhexagon_hvx, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, 0, 0,
+       "Enable Hexagon Vector eXtensions", nullptr, nullptr)
+OPTION(prefix_3, "mhwdiv=", _mhwdiv_EQ, Joined, INVALID, mhwdiv_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mhwdiv=", mhwdiv_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "mhwdiv", _mhwdiv, Separate, INVALID, mhwdiv_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mhwmult=", mhwmult_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "miamcu", miamcu, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Use Intel MCU ABI", nullptr, nullptr)
+OPTION(prefix_1, "mieee-fp", mieee_fp, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mieee-rnd-near", mieee_rnd_near, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "migrate", _migrate, Flag, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Run the migrator", nullptr, nullptr)
+OPTION(prefix_1, "migrate", migrate, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Migrate source code", nullptr, nullptr)
+OPTION(prefix_1, "mimplicit-float", mimplicit_float, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mimplicit-it=", mimplicit_it_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mincremental-linker-compatible", mincremental_linker_compatible, Flag, m_Group, INVALID, nullptr, CC1Option | CC1AsOption, 0,
+       "(integrated-as) Emit an object file which can be used with an incremental linker", nullptr, nullptr)
+OPTION(prefix_1, "mindirect-jump=", mindirect_jump_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Change indirect jump instructions to inhibit speculation", nullptr, nullptr)
+OPTION(prefix_1, "minline-all-stringops", minline_all_stringops, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "minvariant-function-descriptors", minvariant_function_descriptors, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "minvpcid", minvpcid, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mios-simulator-version-min=", mios_simulator_version_min_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mios-version-min=", mios_version_min_EQ, Joined, INVALID, miphoneos_version_min_EQ, nullptr, 0, 0,
+       "Set iOS deployment target", nullptr, nullptr)
+OPTION(prefix_1, "miphoneos-version-min=", miphoneos_version_min_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "miphonesimulator-version-min=", miphonesimulator_version_min_EQ, Joined, INVALID, mios_simulator_version_min_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mips16", mips16, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mips1", mips1, Flag, m_mips_Features_Group, march_EQ, "mips1\0", HelpHidden, 0,
+       "Equivalent to -march=mips1", nullptr, nullptr)
+OPTION(prefix_1, "mips2", mips2, Flag, m_mips_Features_Group, march_EQ, "mips2\0", HelpHidden, 0,
+       "Equivalent to -march=mips2", nullptr, nullptr)
+OPTION(prefix_1, "mips32r2", mips32r2, Flag, m_mips_Features_Group, march_EQ, "mips32r2\0", HelpHidden, 0,
+       "Equivalent to -march=mips32r2", nullptr, nullptr)
+OPTION(prefix_1, "mips32r3", mips32r3, Flag, m_mips_Features_Group, march_EQ, "mips32r3\0", HelpHidden, 0,
+       "Equivalent to -march=mips32r3", nullptr, nullptr)
+OPTION(prefix_1, "mips32r5", mips32r5, Flag, m_mips_Features_Group, march_EQ, "mips32r5\0", HelpHidden, 0,
+       "Equivalent to -march=mips32r5", nullptr, nullptr)
+OPTION(prefix_1, "mips32r6", mips32r6, Flag, m_mips_Features_Group, march_EQ, "mips32r6\0", HelpHidden, 0,
+       "Equivalent to -march=mips32r6", nullptr, nullptr)
+OPTION(prefix_1, "mips32", mips32, Flag, m_mips_Features_Group, march_EQ, "mips32\0", HelpHidden, 0,
+       "Equivalent to -march=mips32", nullptr, nullptr)
+OPTION(prefix_1, "mips3", mips3, Flag, m_mips_Features_Group, march_EQ, "mips3\0", HelpHidden, 0,
+       "Equivalent to -march=mips3", nullptr, nullptr)
+OPTION(prefix_1, "mips4", mips4, Flag, m_mips_Features_Group, march_EQ, "mips4\0", HelpHidden, 0,
+       "Equivalent to -march=mips4", nullptr, nullptr)
+OPTION(prefix_1, "mips5", mips5, Flag, m_mips_Features_Group, march_EQ, "mips5\0", HelpHidden, 0,
+       "Equivalent to -march=mips5", nullptr, nullptr)
+OPTION(prefix_1, "mips64r2", mips64r2, Flag, m_mips_Features_Group, march_EQ, "mips64r2\0", HelpHidden, 0,
+       "Equivalent to -march=mips64r2", nullptr, nullptr)
+OPTION(prefix_1, "mips64r3", mips64r3, Flag, m_mips_Features_Group, march_EQ, "mips64r3\0", HelpHidden, 0,
+       "Equivalent to -march=mips64r3", nullptr, nullptr)
+OPTION(prefix_1, "mips64r5", mips64r5, Flag, m_mips_Features_Group, march_EQ, "mips64r5\0", HelpHidden, 0,
+       "Equivalent to -march=mips64r5", nullptr, nullptr)
+OPTION(prefix_1, "mips64r6", mips64r6, Flag, m_mips_Features_Group, march_EQ, "mips64r6\0", HelpHidden, 0,
+       "Equivalent to -march=mips64r6", nullptr, nullptr)
+OPTION(prefix_1, "mips64", mips64, Flag, m_mips_Features_Group, march_EQ, "mips64\0", HelpHidden, 0,
+       "Equivalent to -march=mips64", nullptr, nullptr)
+OPTION(prefix_1, "misel", misel, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MJ", MJ, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, 0,
+       "Write a compilation database entry per input", nullptr, nullptr)
+OPTION(prefix_1, "mkernel", mkernel, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mldc1-sdc1", mldc1_sdc1, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mlimit-float-precision", mlimit_float_precision, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Limit float precision to the given value", nullptr, nullptr)
+OPTION(prefix_1, "mlink-bitcode-file", mlink_bitcode_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Link the given bitcode file before performing optimizations.", nullptr, nullptr)
+OPTION(prefix_1, "mlink-builtin-bitcode", mlink_builtin_bitcode, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Link and internalize needed symbols from the given bitcode file before performing optimizations.", nullptr, nullptr)
+OPTION(prefix_1, "mlink-cuda-bitcode", mlink_cuda_bitcode, Separate, INVALID, mlink_builtin_bitcode, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mlinker-version=", mlinker_version_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mlittle-endian", mlittle_endian, Flag, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mllvm", mllvm, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | CoreOption, 0,
+       "Additional arguments to forward to LLVM's option processing", nullptr, nullptr)
+OPTION(prefix_1, "mlocal-sdata", mlocal_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Extend the -G behaviour to object local data (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mlong-calls", mlong_calls, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Generate branches with extended addressability, usually via indirect jumps.", nullptr, nullptr)
+OPTION(prefix_1, "mlongcall", mlongcall, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mlwp", mlwp, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mlzcnt", mlzcnt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmacos-version-min=", mmacos_version_min_EQ, Joined, m_Group, mmacosx_version_min_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmacosx-version-min=", mmacosx_version_min_EQ, Joined, m_Group, INVALID, nullptr, 0, 0,
+       "Set Mac OS X deployment target", nullptr, nullptr)
+OPTION(prefix_1, "mmadd4", mmadd4, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable the generation of 4-operand madd.s, madd.d and related instructions.", nullptr, nullptr)
+OPTION(prefix_1, "mmcu=", mmcu_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MMD", MMD, Flag, M_Group, INVALID, nullptr, 0, 0,
+       "Write a depfile containing user headers", nullptr, nullptr)
+OPTION(prefix_1, "mmemops", mmemops, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable generation of memop instructions", nullptr, nullptr)
+OPTION(prefix_1, "mmfcrf", mmfcrf, Flag, INVALID, mmfocrf, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmfocrf", mmfocrf, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmicromips", mmicromips, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmmx", mmmx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmovbe", mmovbe, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmovdir64b", mmovdir64b, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmovdiri", mmovdiri, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mmpx", mmpx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mms-bitfields", mms_bitfields, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Set the default structure layout to be compatible with the Microsoft compiler standard", nullptr, nullptr)
+OPTION(prefix_1, "mmsa", mmsa, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable MSA ASE (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mmt", mmt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable MT ASE (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mmwaitx", mmwaitx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MM", MM, Flag, M_Group, INVALID, nullptr, 0, 0,
+       "Like -MMD, but also implies -E and writes to stdout by default", nullptr, nullptr)
+OPTION(prefix_1, "mnan=", mnan_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-3dnowa", mno_3dnowa, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-3dnow", mno_3dnow, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-80387", mno_80387, Flag, INVALID, mno_x87, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-abicalls", mno_abicalls, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable SVR4-style position-independent code (Mips only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-adx", mno_adx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-aes", mno_aes, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-altivec", mno_altivec, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx2", mno_avx2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512bitalg", mno_avx512bitalg, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512bw", mno_avx512bw, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512cd", mno_avx512cd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512dq", mno_avx512dq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512er", mno_avx512er, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512f", mno_avx512f, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512ifma", mno_avx512ifma, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512pf", mno_avx512pf, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512vbmi2", mno_avx512vbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512vbmi", mno_avx512vbmi, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512vl", mno_avx512vl, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512vnni", mno_avx512vnni, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx512vpopcntdq", mno_avx512vpopcntdq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-avx", mno_avx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-backchain", mno_backchain, Flag, m_Group, INVALID, nullptr, DriverOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-bmi2", mno_bmi2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-bmi", mno_bmi, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-branch-likely", mno_branch_likely, Flag, m_Group, INVALID, nullptr, HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-bulk-memory", mno_bulk_memory, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-check-zero-division", mno_check_zero_division, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-cldemote", mno_cldemote, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-clflushopt", mno_clflushopt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-clwb", mno_clwb, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-clzero", mno_clzero, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-cmpb", mno_cmpb, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-code-object-v3", mno_code_object_v3, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable code object v3 (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-constant-cfstrings", mno_constant_cfstrings, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-crbits", mno_crbits, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-crc", mno_crc, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow use of CRC instructions (Mips only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-crypto", mnopower8_crypto, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-cx16", mno_cx16, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-default-build-attributes", mno_default_build_attributes, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-direct-move", mnodirect_move, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-dspr2", mno_dspr2, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-dsp", mno_dsp, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-embedded-data", mno_embedded_data, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Do not place constants in the .rodata section instead of the .sdata if they meet the -G <size> threshold (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mno-exception-handling", mno_exception_handing, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-execute-only", mno_execute_only, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Allow generation of data access to code sections (ARM only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-extern-sdata", mno_extern_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Do not assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mno-f16c", mno_f16c, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fix-cortex-a53-835769", mno_fix_cortex_a53_835769, Flag, m_aarch64_Features_Group, INVALID, nullptr, 0, 0,
+       "Don't workaround Cortex-A53 erratum 835769 (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-float128", mno_float128, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fma4", mno_fma4, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fma", mno_fma, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fprnd", mno_fprnd, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fsgsbase", mno_fsgsbase, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-fxsr", mno_fxsr, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-gfni", mno_gfni, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-ginv", mno_ginv, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-global-merge", mno_global_merge, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable merging of globals", nullptr, nullptr)
+OPTION(prefix_1, "mno-gpopt", mno_gpopt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Do not use GP relative accesses for symbols known to be in a small data section (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mno-htm", mno_htm, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-hvx", mno_hexagon_hvx, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, 0, 0,
+       "Disable Hexagon Vector eXtensions", nullptr, nullptr)
+OPTION(prefix_1, "mno-iamcu", mno_iamcu, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-implicit-float", mno_implicit_float, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Don't generate implicit floating point instructions", nullptr, nullptr)
+OPTION(prefix_1, "mno-incremental-linker-compatible", mno_incremental_linker_compatible, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "(integrated-as) Emit an object file which cannot be used with an incremental linker", nullptr, nullptr)
+OPTION(prefix_1, "mno-inline-all-stringops", mno_inline_all_stringops, Flag, clang_ignored_m_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-invariant-function-descriptors", mno_invariant_function_descriptors, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-invpcid", mno_invpcid, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-isel", mno_isel, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-ldc1-sdc1", mno_ldc1_sdc1, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-local-sdata", mno_local_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Do not extend the -G behaviour to object local data (MIPS)", nullptr, nullptr)
+OPTION(prefix_1, "mno-long-calls", mno_long_calls, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Restore the default behaviour of not generating long calls", nullptr, nullptr)
+OPTION(prefix_1, "mno-longcall", mno_longcall, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-lwp", mno_lwp, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-lzcnt", mno_lzcnt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-madd4", mno_madd4, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable the generation of 4-operand madd.s, madd.d and related instructions.", nullptr, nullptr)
+OPTION(prefix_1, "mno-memops", mno_memops, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable generation of memop instructions", nullptr, nullptr)
+OPTION(prefix_1, "mno-mfcrf", mno_mfcrf, Flag, INVALID, mno_mfocrf, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-mfocrf", mno_mfocrf, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-micromips", mno_micromips, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-mips16", mno_mips16, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-mmx", mno_mmx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-movbe", mno_movbe, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-movdir64b", mno_movdir64b, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-movdiri", mno_movdiri, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-movt", mno_movt, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow use of movt/movw pairs (ARM only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-mpx", mno_mpx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-ms-bitfields", mno_ms_bitfields, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Do not set the default structure layout to be compatible with the Microsoft compiler standard", nullptr, nullptr)
+OPTION(prefix_1, "mno-msa", mno_msa, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable MSA ASE (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-mt", mno_mt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable MT ASE (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-mwaitx", mno_mwaitx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-neg-immediates", mno_neg_immediates, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow converting instructions with negative immediates to their negation or inversion.", nullptr, nullptr)
+OPTION(prefix_1, "mno-nontrapping-fptoint", mno_nontrapping_fptoint, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-nvj", mno_nvj, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable generation of new-value jumps", nullptr, nullptr)
+OPTION(prefix_1, "mno-nvs", mno_nvs, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable generation of new-value stores", nullptr, nullptr)
+OPTION(prefix_1, "mno-odd-spreg", mno_odd_spreg, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, 0,
+       "Disable odd single-precision floating point registers", nullptr, nullptr)
+OPTION(prefix_1, "mno-omit-leaf-frame-pointer", mno_omit_leaf_frame_pointer, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-outline", mno_outline, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable function outlining (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-packets", mno_packets, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable generation of instruction packets", nullptr, nullptr)
+OPTION(prefix_1, "mno-pascal-strings", mno_pascal_strings, Flag, INVALID, fno_pascal_strings, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-pclmul", mno_pclmul, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-pconfig", mno_pconfig, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-pie-copy-relocations", mno_pie_copy_relocations, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-pku", mno_pku, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-popcntd", mno_popcntd, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-popcnt", mno_popcnt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-power8-vector", mno_power8_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-power9-vector", mno_power9_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-prefetchwt1", mno_prefetchwt1, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-prfchw", mno_prfchw, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-ptwrite", mno_ptwrite, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-pure-code", mno_pure_code, Flag, INVALID, mno_execute_only, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-qpx", mno_qpx, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-rdpid", mno_rdpid, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-rdrnd", mno_rdrnd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-rdseed", mno_rdseed, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-red-zone", mno_red_zone, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-relax-all", mno_relax_all, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-relax-pic-calls", mno_relax_pic_calls, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, 0,
+       "Do not produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-relax", mno_relax, Flag, m_riscv_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable linker relaxation", nullptr, nullptr)
+OPTION(prefix_1, "mno-restrict-it", mno_restrict_it, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode", nullptr, nullptr)
+OPTION(prefix_1, "mno-retpoline-external-thunk", mno_retpoline_external_thunk, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-retpoline", mno_retpoline, Flag, m_Group, INVALID, nullptr, CoreOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-rtd", mno_rtd, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-rtm", mno_rtm, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sahf", mno_sahf, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sgx", mno_sgx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sha", mno_sha, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-shstk", mno_shstk, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sign-ext", mno_sign_ext, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-simd128", mno_simd128, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-soft-float", mno_soft_float, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-speculative-load-hardening", mno_speculative_load_hardening, Flag, m_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sram-ecc", mno_sram_ecc, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable SRAM ECC (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-sse2", mno_sse2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse3", mno_sse3, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse4.1", mno_sse4_1, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse4.2", mno_sse4_2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse4a", mno_sse4a, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse4", mno_sse4, Flag, INVALID, mno_sse4_1, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-sse", mno_sse, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-ssse3", mno_ssse3, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-stack-arg-probe", mno_stack_arg_probe, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable stack probes which are enabled by default", nullptr, nullptr)
+OPTION(prefix_1, "mno-stackrealign", mno_stackrealign, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-tbm", mno_tbm, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-thumb", mno_thumb, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-tls-direct-seg-refs", mno_tls_direct_seg_refs, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable direct TLS access through segment registers", nullptr, nullptr)
+OPTION(prefix_1, "mno-unaligned-access", mno_unaligned_access, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Force all memory accesses to be aligned (AArch32/AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-unimplemented-simd128", mno_unimplemented_simd128, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-vaes", mno_vaes, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-virt", mno_virt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-vpclmulqdq", mno_vpclmulqdq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-vsx", mno_vsx, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-vx", mno_vx, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-waitpkg", mno_waitpkg, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-warn-nonportable-cfstrings", mno_warn_nonportable_cfstrings, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-wbnoinvd", mno_wbnoinvd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-x87", mno_x87, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xgot", mno_xgot, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xnack", mno_xnack, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Disable XNACK (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "mno-xop", mno_xop, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xsavec", mno_xsavec, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xsaveopt", mno_xsaveopt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xsaves", mno_xsaves, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-xsave", mno_xsave, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mno-zero-initialized-in-bss", mno_zero_initialized_in_bss, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not put zero initialized data in the BSS", nullptr, nullptr)
+OPTION(prefix_1, "mno-zvector", mno_zvector, Flag, INVALID, fno_zvector, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mnocrc", mnocrc, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow use of CRC instructions (ARM only)", nullptr, nullptr)
+OPTION(prefix_1, "mnoexecstack", mno_exec_stack, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Mark the file as not needing an executable stack", nullptr, nullptr)
+OPTION(prefix_1, "mnontrapping-fptoint", mnontrapping_fptoint, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mnvj", mnvj, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable generation of new-value jumps", nullptr, nullptr)
+OPTION(prefix_1, "mnvs", mnvs, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable generation of new-value stores", nullptr, nullptr)
+OPTION(prefix_1, "modd-spreg", modd_spreg, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, 0,
+       "Enable odd single-precision floating point registers", nullptr, nullptr)
+OPTION(prefix_1, "module-dependency-dir", module_dependency_dir, Separate, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Directory to dump module dependencies to", nullptr, nullptr)
+OPTION(prefix_1, "module-file-deps", module_file_deps, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include module files in dependency output", nullptr, nullptr)
+OPTION(prefix_1, "module-file-info", module_file_info, Flag, Action_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Provide information about a particular module file", nullptr, nullptr)
+OPTION(prefix_1, "momit-leaf-frame-pointer", momit_leaf_frame_pointer, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Omit frame pointer setup for leaf functions", nullptr, nullptr)
+OPTION(prefix_1, "moslib=", moslib_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "moutline", moutline, Flag, f_clang_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable function outlining (AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "mpackets", mpackets, Flag, m_hexagon_Features_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable generation of instruction packets", nullptr, nullptr)
+OPTION(prefix_1, "mpascal-strings", mpascal_strings, Flag, INVALID, fpascal_strings, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpclmul", mpclmul, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpconfig", mpconfig, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpie-copy-relocations", mpie_copy_relocations, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Use copy relocations support for PIE builds", nullptr, nullptr)
+OPTION(prefix_1, "mpku", mpku, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpopcntd", mpopcntd, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpopcnt", mpopcnt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpower8-vector", mpower8_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpower9-vector", mpower9_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mprefer-vector-width=", mprefer_vector_width_EQ, Joined, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.", nullptr, nullptr)
+OPTION(prefix_1, "mprefetchwt1", mprefetchwt1, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mprfchw", mprfchw, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mptwrite", mptwrite, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mpure-code", mpure_code, Flag, INVALID, mexecute_only, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MP", MP, Flag, M_Group, INVALID, nullptr, CC1Option, 0,
+       "Create phony target for each dependency (other than main file)", nullptr, nullptr)
+OPTION(prefix_2, "MP", _SLASH_MP, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mqdsp6-compat", mqdsp6_compat, Flag, m_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Enable hexagon-qdsp6 backward compatibility", nullptr, nullptr)
+OPTION(prefix_1, "mqpx", mqpx, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MQ", MQ, JoinedOrSeparate, M_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify name of main file output to quote in depfile", nullptr, nullptr)
+OPTION(prefix_1, "mrdpid", mrdpid, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mrdrnd", mrdrnd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mrdseed", mrdseed, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mreassociate", mreassociate, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Allow reassociation transformations for floating-point instructions", nullptr, nullptr)
+OPTION(prefix_1, "mrecip=", mrecip_EQ, CommaJoined, m_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mrecip", mrecip, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mred-zone", mred_zone, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mregparm=", mregparm_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mregparm", mregparm, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Limit the number of registers available for integer arguments", nullptr, nullptr)
+OPTION(prefix_1, "mrelax-all", mrelax_all, Flag, m_Group, INVALID, nullptr, CC1Option | CC1AsOption, 0,
+       "(integrated-as) Relax all machine instructions", nullptr, nullptr)
+OPTION(prefix_1, "mrelax-pic-calls", mrelax_pic_calls, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, 0,
+       "Produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)", nullptr, nullptr)
+OPTION(prefix_3, "mrelax-relocations", mrelax_relocations, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Use relaxable elf relocations", nullptr, nullptr)
+OPTION(prefix_1, "mrelax", mrelax, Flag, m_riscv_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable linker relaxation", nullptr, nullptr)
+OPTION(prefix_1, "mrelocation-model", mrelocation_model, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "The relocation model to use", nullptr, "static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic")
+OPTION(prefix_1, "mrestrict-it", mrestrict_it, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.", nullptr, nullptr)
+OPTION(prefix_1, "mretpoline-external-thunk", mretpoline_external_thunk, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mretpoline", mretpoline, Flag, m_Group, INVALID, nullptr, CoreOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mrtd", mrtd, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Make StdCall calling convention the default", nullptr, nullptr)
+OPTION(prefix_1, "mrtm", mrtm, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msahf", msahf, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msave-temp-labels", msave_temp_labels, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Save temporary labels in the symbol table. Note this may change .s semantics and shouldn't generally be used on compiler-generated code.", nullptr, nullptr)
+OPTION(prefix_1, "msecure-plt", msecure_plt, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msgx", msgx, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msha", msha, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mshstk", mshstk, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msign-ext", msign_ext, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msign-return-address-key=", msign_return_address_key_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, "a_key,b_key")
+OPTION(prefix_1, "msign-return-address=", msign_return_address_EQ, Joined, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Select return address signing scope", nullptr, "none,all,non-leaf")
+OPTION(prefix_1, "msimd128", msimd128, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msingle-float", msingle_float, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msmall-data-threshold=", msmall_data_threshold_EQ, Joined, m_Group, G, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msoft-float", msoft_float, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Use software floating point", nullptr, nullptr)
+OPTION(prefix_1, "mspeculative-load-hardening", mspeculative_load_hardening, Flag, m_Group, INVALID, nullptr, CoreOption | CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msram-ecc", msram_ecc, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable SRAM ECC (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "msse2", msse2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse3", msse3, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse4.1", msse4_1, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse4.2", msse4_2, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse4a", msse4a, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse4", msse4, Flag, INVALID, msse4_2, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "msse", msse, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mssse3", mssse3, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mstack-alignment=", mstack_alignment, Joined, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Set the stack alignment", nullptr, nullptr)
+OPTION(prefix_1, "mstack-arg-probe", mstack_arg_probe, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Enable stack probes", nullptr, nullptr)
+OPTION(prefix_1, "mstack-probe-size=", mstack_probe_size, Joined, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Set the stack probe size", nullptr, nullptr)
+OPTION(prefix_1, "mstackrealign", mstackrealign, Flag, m_Group, INVALID, nullptr, CC1Option, 0,
+       "Force realign the stack at entry to every function", nullptr, nullptr)
+OPTION(prefix_1, "mstrict-align", mstrict_align, Flag, INVALID, mno_unaligned_access, nullptr, CC1Option | HelpHidden, 0,
+       "Force all memory accesses to be aligned (same as mno-unaligned-access)", nullptr, nullptr)
+OPTION(prefix_1, "mt-migrate-directory", mt_migrate_directory, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Directory for temporary files produced during ARC or ObjC migration", nullptr, nullptr)
+OPTION(prefix_1, "mtbm", mtbm, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "MTd", _SLASH_MTd, Flag, _SLASH_M_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Use static debug run-time", nullptr, nullptr)
+OPTION(prefix_1, "mthread-model", mthread_model, Separate, m_Group, INVALID, nullptr, CC1Option, 0,
+       "The thread model to use, e.g. posix, single (posix by default)", nullptr, "posix,single")
+OPTION(prefix_1, "mthreads", mthreads, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mthumb", mthumb, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mtls-direct-seg-refs", mtls_direct_seg_refs, Flag, m_Group, INVALID, nullptr, 0, 0,
+       "Enable direct TLS access through segment registers (default)", nullptr, nullptr)
+OPTION(prefix_1, "mtp=", mtp_mode_EQ, Joined, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Read thread pointer from coprocessor register (ARM only)", nullptr, "soft, cp15")
+OPTION(prefix_1, "mtp", mtp, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Mode for reading thread pointer", nullptr, nullptr)
+OPTION(prefix_1, "mtune=", mtune_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mtvos-simulator-version-min=", mtvos_simulator_version_min_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mtvos-version-min=", mtvos_version_min_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MT", MT, JoinedOrSeparate, M_Group, INVALID, nullptr, CC1Option, 0,
+       "Specify name of main file output in depfile", nullptr, nullptr)
+OPTION(prefix_2, "MT", _SLASH_MT, Flag, _SLASH_M_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Use static run-time", nullptr, nullptr)
+OPTION(prefix_1, "muclibc", muclibc, Flag, m_libc_Group, INVALID, nullptr, HelpHidden | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "multi_module", multi__module, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "multiply_defined_unused", multiply__defined__unused, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "multiply_defined", multiply__defined, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "munaligned-access", munaligned_access, Flag, m_arm_Features_Group, INVALID, nullptr, 0, 0,
+       "Allow memory accesses to be unaligned (AArch32/AArch64 only)", nullptr, nullptr)
+OPTION(prefix_1, "municode", municode, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "munimplemented-simd128", munimplemented_simd128, Flag, m_wasm_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "munwind-tables", munwind_tables, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate unwinding tables for all functions", nullptr, nullptr)
+OPTION(prefix_1, "mv55", mv55, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv55\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mv5", mv5, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv5\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mv60", mv60, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv60\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mv62", mv62, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv62\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mv65", mv65, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv65\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mv66", mv66, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv66\0", 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mvaes", mvaes, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mvirt", mvirt, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mvpclmulqdq", mvpclmulqdq, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mvsx", mvsx, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mvx", mvx, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "MV", MV, Flag, M_Group, INVALID, nullptr, CC1Option, 0,
+       "Use NMake/Jom format for the depfile", nullptr, nullptr)
+OPTION(prefix_1, "mwaitpkg", mwaitpkg, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwarn-nonportable-cfstrings", mwarn_nonportable_cfstrings, Flag, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwatchos-simulator-version-min=", mwatchos_simulator_version_min_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwatchos-version-min=", mwatchos_version_min_EQ, Joined, m_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwatchsimulator-version-min=", mwatchsimulator_version_min_EQ, Joined, INVALID, mwatchos_simulator_version_min_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwbnoinvd", mwbnoinvd, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mwindows", mwindows, Joined, m_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mx32", mx32, Flag, m_Group, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mx87", mx87, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxgot", mxgot, Flag, m_mips_Features_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxnack", mxnack, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, 0,
+       "Enable XNACK (AMDGPU only)", nullptr, nullptr)
+OPTION(prefix_1, "mxop", mxop, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxsavec", mxsavec, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxsaveopt", mxsaveopt, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxsaves", mxsaves, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mxsave", mxsave, Flag, m_x86_Features_Group, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "mzvector", mzvector, Flag, INVALID, fzvector, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "M", M, Flag, M_Group, INVALID, nullptr, 0, 0,
+       "Like -MD, but also implies -E and writes to stdout by default", nullptr, nullptr)
+OPTION(prefix_1, "new-struct-path-tbaa", new_struct_path_tbaa, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable enhanced struct-path aware Type Based Alias Analysis", nullptr, nullptr)
+OPTION(prefix_1, "no-canonical-prefixes", no_canonical_prefixes, Flag, INVALID, INVALID, nullptr, HelpHidden | CoreOption, 0,
+       "Use relative instead of canonical paths", nullptr, nullptr)
+OPTION(prefix_1, "no-code-completion-globals", no_code_completion_globals, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not include global declarations in code-completion results.", nullptr, nullptr)
+OPTION(prefix_1, "no-code-completion-ns-level-decls", no_code_completion_ns_level_decls, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.", nullptr, nullptr)
+OPTION(prefix_1, "no-cpp-precomp", no_cpp_precomp, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-cuda-gpu-arch=", no_cuda_gpu_arch_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Remove GPU architecture (e.g. sm_35) from the list of GPUs to compile for. 'all' resets the list to its default value.", nullptr, nullptr)
+OPTION(prefix_3, "no-cuda-include-ptx=", no_cuda_include_ptx_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.", nullptr, nullptr)
+OPTION(prefix_3, "no-cuda-noopt-device-debug", no_cuda_noopt_device_debug, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-cuda-version-check", no_cuda_version_check, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.", nullptr, nullptr)
+OPTION(prefix_1, "no-emit-llvm-uselists", no_emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't preserve order of LLVM use-lists when serializing", nullptr, nullptr)
+OPTION(prefix_1, "no-finalize-removal", migrator_no_finalize_removal, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not remove finalize method in gc mode", nullptr, nullptr)
+OPTION(prefix_1, "no-implicit-float", no_implicit_float, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Don't generate implicit floating point instructions", nullptr, nullptr)
+OPTION(prefix_1, "no-integrated-as", anonymous_33, Flag, INVALID, fno_integrated_as, nullptr, CC1Option | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "no-integrated-cpp", no_integrated_cpp, Flag, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-line-commands", _no_line_commands, Flag, INVALID, P, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "no-ns-alloc-error", migrator_no_nsalloc_error, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not error on use of NSAllocateCollectable/NSReallocateCollectable", nullptr, nullptr)
+OPTION(prefix_4, "no-pedantic", no_pedantic, Flag, pedantic_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "no-pie", no_pie, Flag, INVALID, nopie, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "no-pthread", no_pthread, Flag, INVALID, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-standard-includes", _no_standard_includes, Flag, INVALID, nostdinc, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-standard-libraries", _no_standard_libraries, Flag, INVALID, nostdlib, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "no-struct-path-tbaa", no_struct_path_tbaa, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Turn off struct-path aware Type Based Alias Analysis", nullptr, nullptr)
+OPTION(prefix_3, "no-system-header-prefix=", no_system_header_prefix, Joined, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Treat all #include paths starting with <prefix> as not including a system header.", "<prefix>", nullptr)
+OPTION(prefix_3, "no-system-header-prefix", anonymous_31, Separate, INVALID, no_system_header_prefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-undefined", _no_undefined, Flag, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "no-warnings", _no_warnings, Flag, INVALID, w, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "no_dead_strip_inits_and_terms", no__dead__strip__inits__and__terms, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nobuiltininc", nobuiltininc, Flag, INVALID, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Disable builtin #include directories", nullptr, nullptr)
+OPTION(prefix_1, "nocpp", nocpp, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nocudainc", nocudainc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nocudalib", nocudalib, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nodefaultlibs", nodefaultlibs, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nofixprebinding", nofixprebinding, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nolibc", nolibc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "nologo", _SLASH_nologo, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nomultidefs", nomultidefs, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nopie", nopie, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "noprebind", noprebind, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "noseglinkedit", noseglinkedit, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostartfiles", nostartfiles, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostdinc++", nostdincxx, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Disable standard #include directories for the C++ standard library", nullptr, nullptr)
+OPTION(prefix_1, "nostdinc", nostdinc, Flag, INVALID, INVALID, nullptr, CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostdlib++", nostdlibxx, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostdlibinc", nostdlibinc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostdlib", nostdlib, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "nostdsysteminc", nostdsysteminc, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Disable standard system #include directories", nullptr, nullptr)
+OPTION(prefix_1, "n", n, Flag, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Don't automatically start assembly file with a text section", nullptr, nullptr)
+OPTION(prefix_1, "O0", O0, Flag, O_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "O0", anonymous_36, Flag, cl_Group, O0, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable optimization", nullptr, nullptr)
+OPTION(prefix_2, "O1", anonymous_37, Flag, cl_Group, _SLASH_O, "1\0", CLOption | DriverOption | CLOption, 0,
+       "Optimize for size  (same as /Og     /Os /Oy /Ob2 /GF /Gy)", nullptr, nullptr)
+OPTION(prefix_2, "O2", anonymous_38, Flag, cl_Group, _SLASH_O, "2\0", CLOption | DriverOption | CLOption, 0,
+       "Optimize for speed (same as /Og /Oi /Ot /Oy /Ob2 /GF /Gy)", nullptr, nullptr)
+OPTION(prefix_1, "O4", O4, Flag, O_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Ob0", anonymous_39, Flag, cl_Group, _SLASH_O, "b0\0", CLOption | DriverOption | CLOption, 0,
+       "Disable function inlining", nullptr, nullptr)
+OPTION(prefix_2, "Ob1", anonymous_40, Flag, cl_Group, _SLASH_O, "b1\0", CLOption | DriverOption | CLOption, 0,
+       "Only inline functions which are (explicitly or implicitly) marked inline", nullptr, nullptr)
+OPTION(prefix_2, "Ob2", anonymous_41, Flag, cl_Group, _SLASH_O, "b2\0", CLOption | DriverOption | CLOption, 0,
+       "Inline functions as deemed beneficial by the compiler", nullptr, nullptr)
+OPTION(prefix_1, "ObjC++", ObjCXX, Flag, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Treat source input files as Objective-C++ inputs", nullptr, nullptr)
+OPTION(prefix_1, "objc-isystem", objc_isystem, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add directory to the ObjC SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "objcmt-atomic-property", objcmt_atomic_property, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Make migration to 'atomic' properties", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-all", objcmt_migrate_all, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-annotation", objcmt_migrate_annotation, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to property and method annotations", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-designated-init", objcmt_migrate_designated_init, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-instancetype", objcmt_migrate_instancetype, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to infer instancetype for method result type", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-literals", objcmt_migrate_literals, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC literals", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-ns-macros", objcmt_migrate_nsmacros, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to NS_ENUM/NS_OPTIONS macros", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-property-dot-syntax", objcmt_migrate_property_dot_syntax, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration of setter/getter messages to property-dot syntax", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-property", objcmt_migrate_property, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC property", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-protocol-conformance", objcmt_migrate_protocol_conformance, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to add protocol conformance on classes", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-readonly-property", objcmt_migrate_readonly_property, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC readonly property", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-readwrite-property", objcmt_migrate_readwrite_property, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC readwrite property", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-migrate-subscripting", objcmt_migrate_subscripting, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to modern ObjC subscripting", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-ns-nonatomic-iosonly", objcmt_ns_nonatomic_iosonly, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-returns-innerpointer-property", objcmt_returns_innerpointer_property, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable migration to annotate property with NS_RETURNS_INNER_POINTER", nullptr, nullptr)
+OPTION(prefix_1, "objcmt-white-list-dir-path=", anonymous_2, Joined, INVALID, objcmt_whitelist_dir_path, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "objcmt-whitelist-dir-path=", objcmt_whitelist_dir_path, Joined, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Only modify files with a filename contained in the provided directory path", nullptr, nullptr)
+OPTION(prefix_1, "objcxx-isystem", objcxx_isystem, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Add directory to the ObjC++ SYSTEM include search path", "<directory>", nullptr)
+OPTION(prefix_1, "ObjC", ObjC, Flag, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Treat source input files as Objective-C inputs", nullptr, nullptr)
+OPTION(prefix_1, "object", object, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Od", anonymous_42, Flag, cl_Group, _SLASH_O, "d\0", CLOption | DriverOption | CLOption, 0,
+       "Disable optimization", nullptr, nullptr)
+OPTION(prefix_1, "Ofast", Ofast, Joined, O_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Og", anonymous_43, Flag, cl_Group, _SLASH_O, "g\0", CLOption | DriverOption | CLOption, 0,
+       "No effect", nullptr, nullptr)
+OPTION(prefix_2, "Oi-", anonymous_45, Flag, cl_Group, _SLASH_O, "i-\0", CLOption | DriverOption | CLOption, 0,
+       "Disable use of builtin functions", nullptr, nullptr)
+OPTION(prefix_2, "Oi", anonymous_44, Flag, cl_Group, _SLASH_O, "i\0", CLOption | DriverOption | CLOption, 0,
+       "Enable use of builtin functions", nullptr, nullptr)
+OPTION(prefix_2, "openmp-", _SLASH_openmp_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "openmp", _SLASH_openmp, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "opt-record-file", opt_record_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "File name to use for YAML optimization record output", nullptr, nullptr)
+OPTION(prefix_3, "optimize=", _optimize_EQ, Joined, INVALID, O, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "optimize", _optimize, Flag, INVALID, O, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Os", anonymous_46, Flag, cl_Group, _SLASH_O, "s\0", CLOption | DriverOption | CLOption, 0,
+       "Optimize for size", nullptr, nullptr)
+OPTION(prefix_2, "Ot", anonymous_47, Flag, cl_Group, _SLASH_O, "t\0", CLOption | DriverOption | CLOption, 0,
+       "Optimize for speed", nullptr, nullptr)
+OPTION(prefix_1, "output-asm-variant", output_asm_variant, Separate, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Select the asm variant index to use for output", nullptr, nullptr)
+OPTION(prefix_3, "output-class-directory=", _output_class_directory_EQ, Joined, INVALID, foutput_class_dir_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "output-class-directory", _output_class_directory, Separate, INVALID, foutput_class_dir_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "output=", _output_EQ, Joined, INVALID, o, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "output", _output, Separate, INVALID, o, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Ox", anonymous_48, Flag, cl_Group, _SLASH_O, "x\0", CLOption | DriverOption | CLOption, 0,
+       "Deprecated (same as /Og /Oi /Ot /Oy /Ob2); use /O2 instead", nullptr, nullptr)
+OPTION(prefix_2, "Oy-", anonymous_50, Flag, cl_Group, _SLASH_O, "y-\0", CLOption | DriverOption | CLOption, 0,
+       "Disable frame pointer omission (x86 only, default)", nullptr, nullptr)
+OPTION(prefix_2, "Oy", anonymous_49, Flag, cl_Group, _SLASH_O, "y\0", CLOption | DriverOption | CLOption, 0,
+       "Enable frame pointer omission (x86 only)", nullptr, nullptr)
+OPTION(prefix_1, "O", O_flag, Flag, INVALID, O, "2\0", CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "O", O, Joined, O_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "O", _SLASH_O, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'", "<flags>", nullptr)
+OPTION(prefix_1, "o", o, JoinedOrSeparate, INVALID, INVALID, nullptr, DriverOption | RenderAsInput | CC1Option | CC1AsOption, 0,
+       "Write output to <file>", "<file>", nullptr)
+OPTION(prefix_2, "o", _SLASH_o, JoinedOrSeparate, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set output file or directory (ends in / or \\)", "<file or directory>", nullptr)
+OPTION(prefix_1, "pagezero_size", pagezero__size, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "param=", _param_EQ, Joined, INVALID, _param, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "param", _param, Separate, CompileOnly_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "pass-exit-codes", pass_exit_codes, Flag, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "pch-through-hdrstop-create", pch_through_hdrstop_create, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "When creating a PCH, stop PCH generation after #pragma hdrstop.", nullptr, nullptr)
+OPTION(prefix_1, "pch-through-hdrstop-use", pch_through_hdrstop_use, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "When using a PCH, skip tokens until after a #pragma hdrstop.", nullptr, nullptr)
+OPTION(prefix_1, "pch-through-header=", pch_through_header_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Stop PCH generation after including this file.  When using a PCH, skip tokens until after this file is included.", nullptr, nullptr)
+OPTION(prefix_4, "pedantic-errors", pedantic_errors, Flag, pedantic_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "pedantic", pedantic, Flag, pedantic_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "permissive-", _SLASH_permissive_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "pg", pg, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable mcount instrumentation", nullptr, nullptr)
+OPTION(prefix_1, "pic-is-pie", pic_is_pie, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "File is for a position independent executable", nullptr, nullptr)
+OPTION(prefix_1, "pic-level", pic_level, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Value for __PIC__", nullptr, nullptr)
+OPTION(prefix_1, "pie", pie, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "pipe", pipe, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Use pipes between commands, when possible", nullptr, nullptr)
+OPTION(prefix_1, "plugin-arg-", plugin_arg, JoinedAndSeparate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Pass <arg> to plugin <name>", "<name> <arg>", nullptr)
+OPTION(prefix_1, "plugin", plugin, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Use the named plugin action instead of the default action (use \"help\" to list available options)", "<name>", nullptr)
+OPTION(prefix_1, "preamble-bytes=", preamble_bytes_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Assume that the precompiled header is a precompiled preamble covering the first N bytes of the main file", nullptr, nullptr)
+OPTION(prefix_1, "prebind_all_twolevel_modules", prebind__all__twolevel__modules, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "prebind", prebind, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "precompile", _precompile, Flag, Action_Group, INVALID, nullptr, DriverOption, 0,
+       "Only precompile the input", nullptr, nullptr)
+OPTION(prefix_3, "prefix=", _prefix_EQ, Joined, INVALID, B, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "prefix", _prefix, Separate, INVALID, B, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "preload", preload, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "preprocess", _preprocess, Flag, INVALID, E, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "print-diagnostic-categories", _print_diagnostic_categories, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "print-effective-triple", print_effective_triple, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Print the effective target triple", nullptr, nullptr)
+OPTION(prefix_4, "print-file-name=", print_file_name_EQ, Joined, INVALID, INVALID, nullptr, 0, 0,
+       "Print the full library path of <file>", "<file>", nullptr)
+OPTION(prefix_3, "print-file-name", _print_file_name, Separate, INVALID, print_file_name_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "print-ivar-layout", print_ivar_layout, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable Objective-C Ivar layout bitmap print trace", nullptr, nullptr)
+OPTION(prefix_4, "print-libgcc-file-name", print_libgcc_file_name, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Print the library path for the currently used compiler runtime library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")", nullptr, nullptr)
+OPTION(prefix_3, "print-missing-file-dependencies", _print_missing_file_dependencies, Flag, INVALID, MG, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "print-multi-directory", print_multi_directory, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "print-multi-lib", print_multi_lib, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "print-multi-os-directory", print_multi_os_directory, Flag, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "print-preamble", print_preamble, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Print the \"preamble\" of a file, which is a candidate for implicit precompiled headers.", nullptr, nullptr)
+OPTION(prefix_4, "print-prog-name=", print_prog_name_EQ, Joined, INVALID, INVALID, nullptr, 0, 0,
+       "Print the full program path of <name>", "<name>", nullptr)
+OPTION(prefix_3, "print-prog-name", _print_prog_name, Separate, INVALID, print_prog_name_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "print-resource-dir", print_resource_dir, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Print the resource directory pathname", nullptr, nullptr)
+OPTION(prefix_4, "print-search-dirs", print_search_dirs, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Print the paths used for finding libraries and programs", nullptr, nullptr)
+OPTION(prefix_1, "print-stats", print_stats, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Print performance metrics and statistics", nullptr, nullptr)
+OPTION(prefix_4, "print-target-triple", print_target_triple, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Print the normalized target triple", nullptr, nullptr)
+OPTION(prefix_1, "private_bundle", private__bundle, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "profile-blocks", _profile_blocks, Flag, INVALID, a, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "profile", _profile, Flag, INVALID, p, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "pthreads", pthreads, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "pthread", pthread, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Support POSIX threads in generated code", nullptr, nullptr)
+OPTION(prefix_3, "ptxas-path=", ptxas_path_EQ, Joined, i_Group, INVALID, nullptr, 0, 0,
+       "Path to ptxas (used for compiling CUDA code)", nullptr, nullptr)
+OPTION(prefix_1, "P", P, Flag, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Disable linemarker output in -E mode", nullptr, nullptr)
+OPTION(prefix_2, "P", _SLASH_P, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Preprocess to file", nullptr, nullptr)
+OPTION(prefix_1, "p", p, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Qfast_transcendentals", _SLASH_Qfast_transcendentals, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "QIfist", _SLASH_QIfist, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Qimprecise_fwaits", _SLASH_Qimprecise_fwaits, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Qn", Qn, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Do not emit metadata containing compiler name and version", nullptr, nullptr)
+OPTION(prefix_2, "Qpar", _SLASH_Qpar, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Qunused-arguments", Qunused_arguments, Flag, INVALID, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Don't emit warning for unused driver arguments", nullptr, nullptr)
+OPTION(prefix_2, "Qvec-report", _SLASH_Qvec_report, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Qvec-", _SLASH_Qvec_, Flag, cl_Group, fno_vectorize, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable the loop vectorization passes", nullptr, nullptr)
+OPTION(prefix_2, "Qvec", _SLASH_Qvec, Flag, cl_Group, fvectorize, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable the loop vectorization passes", nullptr, nullptr)
+OPTION(prefix_1, "Qy", Qy, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Emit metadata containing compiler name and version", nullptr, nullptr)
+OPTION(prefix_1, "Q", Q, Flag, INVALID, INVALID, nullptr, HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "rdynamic", rdynamic, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "read_only_relocs", read__only__relocs, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "record-command-line", record_command_line, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "The string to embed in the .LLVM.command.line section.", nullptr, nullptr)
+OPTION(prefix_1, "relaxed-aliasing", relaxed_aliasing, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Turn off Type Based Alias Analysis", nullptr, nullptr)
+OPTION(prefix_4, "relocatable-pch", relocatable_pch, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Whether to build a relocatable precompiled header", nullptr, nullptr)
+OPTION(prefix_1, "remap-file", remap_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Replace the contents of the <from> file with the contents of the <to> file", "<from>;<to>", nullptr)
+OPTION(prefix_1, "remap", remap, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "resource-dir=", resource_dir_EQ, Joined, INVALID, resource_dir, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "resource-dir", resource_dir, Separate, INVALID, INVALID, nullptr, DriverOption | CC1Option | CoreOption | HelpHidden, 0,
+       "The directory which holds the compiler resource files", nullptr, nullptr)
+OPTION(prefix_3, "resource=", _resource_EQ, Joined, INVALID, fcompile_resource_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "resource", _resource, Separate, INVALID, fcompile_resource_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "rewrite-legacy-objc", rewrite_legacy_objc, Flag, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Rewrite Legacy Objective-C source to C++", nullptr, nullptr)
+OPTION(prefix_1, "rewrite-macros", rewrite_macros, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Expand macros without full preprocessing", nullptr, nullptr)
+OPTION(prefix_1, "rewrite-objc", rewrite_objc, Flag, Action_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Rewrite Objective-C source to C++", nullptr, nullptr)
+OPTION(prefix_1, "rewrite-test", rewrite_test, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Rewriter playground", nullptr, nullptr)
+OPTION(prefix_1, "Rpass-analysis=", Rpass_analysis_EQ, Joined, R_value_Group, INVALID, nullptr, CC1Option, 0,
+       "Report transformation analysis from optimization passes whose name matches the given POSIX regular expression", nullptr, nullptr)
+OPTION(prefix_1, "Rpass-missed=", Rpass_missed_EQ, Joined, R_value_Group, INVALID, nullptr, CC1Option, 0,
+       "Report missed transformations by optimization passes whose name matches the given POSIX regular expression", nullptr, nullptr)
+OPTION(prefix_1, "Rpass=", Rpass_EQ, Joined, R_value_Group, INVALID, nullptr, CC1Option, 0,
+       "Report transformations performed by optimization passes whose name matches the given POSIX regular expression", nullptr, nullptr)
+OPTION(prefix_1, "rpath", rpath, Separate, Link_Group, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "rsp-quoting=", rsp_quoting, Joined, internal_driver_Group, INVALID, nullptr, CoreOption | DriverOption | HelpHidden, 0,
+       "Set the rsp quoting to either 'posix', or 'windows'", nullptr, nullptr)
+OPTION(prefix_2, "RTC", _SLASH_RTC, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "rtlib=", rtlib_EQ, Joined, INVALID, INVALID, nullptr, 0, 0,
+       "Compiler runtime library to use", nullptr, nullptr)
+OPTION(prefix_3, "rtlib", _rtlib, Separate, INVALID, rtlib_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "R", R_Joined, Joined, R_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable the specified remark", "<remark>", nullptr)
+OPTION(prefix_1, "r", r, Flag, Link_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "save-stats=", save_stats_EQ, Joined, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Save llvm statistics.", nullptr, nullptr)
+OPTION(prefix_4, "save-stats", save_stats, Flag, INVALID, save_stats_EQ, "cwd\0", DriverOption, 0,
+       "Save llvm statistics.", nullptr, nullptr)
+OPTION(prefix_4, "save-temps=", save_temps_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | DriverOption, 0,
+       "Save intermediate compilation results.", nullptr, nullptr)
+OPTION(prefix_4, "save-temps", save_temps, Flag, INVALID, save_temps_EQ, "cwd\0", DriverOption, 0,
+       "Save intermediate compilation results", nullptr, nullptr)
+OPTION(prefix_2, "sdl-", _SLASH_sdl_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "sdl", _SLASH_sdl, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sectalign", sectalign, MultiArg, INVALID, INVALID, nullptr, 0, 3, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sectcreate", sectcreate, MultiArg, INVALID, INVALID, nullptr, 0, 3, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sectobjectsymbols", sectobjectsymbols, MultiArg, INVALID, INVALID, nullptr, 0, 2, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sectorder", sectorder, MultiArg, INVALID, INVALID, nullptr, 0, 3, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "seg1addr", seg1addr, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "seg_addr_table_filename", seg__addr__table__filename, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "seg_addr_table", seg__addr__table, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segaddr", segaddr, MultiArg, INVALID, INVALID, nullptr, 0, 2, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segcreate", segcreate, MultiArg, INVALID, INVALID, nullptr, 0, 3, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "seglinkedit", seglinkedit, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segprot", segprot, MultiArg, INVALID, INVALID, nullptr, 0, 3, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segs_read_only_addr", segs__read__only__addr, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segs_read_write_addr", segs__read__write__addr, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "segs_read_", segs__read__, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "serialize-diagnostic-file", diagnostic_serialized_file, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "File for serializing diagnostics in a binary format", "<filename>", nullptr)
+OPTION(prefix_4, "serialize-diagnostics", _serialize_diags, Separate, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Serialize compiler diagnostics to a file", nullptr, nullptr)
+OPTION(prefix_1, "shared-libasan", anonymous_7, Flag, INVALID, shared_libsan, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "shared-libgcc", shared_libgcc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "shared-libsan", shared_libsan, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Dynamically link the sanitizer runtime", nullptr, nullptr)
+OPTION(prefix_4, "shared", shared, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "show-encoding", show_encoding, Flag, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Show instruction encoding information in transliterate mode", nullptr, nullptr)
+OPTION(prefix_3, "show-includes", show_includes, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Print cl.exe style /showIncludes to stdout", nullptr, nullptr)
+OPTION(prefix_1, "show-inst", show_inst, Flag, INVALID, INVALID, nullptr, CC1AsOption | NoDriverOption, 0,
+       "Show internal instruction representation in transliterate mode", nullptr, nullptr)
+OPTION(prefix_2, "showFilenames-", _SLASH_showFilenames_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't print the name of each compiled file (default)", nullptr, nullptr)
+OPTION(prefix_2, "showFilenames", _SLASH_showFilenames, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Print the name of each compiled file", nullptr, nullptr)
+OPTION(prefix_2, "showIncludes", _SLASH_showIncludes, Flag, cl_Group, show_includes, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Print info about included files to stderr", nullptr, nullptr)
+OPTION(prefix_3, "signed-char", _signed_char, Flag, INVALID, fsigned_char, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "single_module", single__module, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "source-charset:", _SLASH_source_charset, Joined, cl_compile_Group, finput_charset_EQ, nullptr, CLOption | DriverOption, 0,
+       "Source encoding, supports only UTF-8", nullptr, nullptr)
+OPTION(prefix_4, "specs=", specs_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "specs", specs, Separate, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "split-dwarf-file", split_dwarf_file, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "File name to use for split dwarf debug info output", nullptr, nullptr)
+OPTION(prefix_1, "split-dwarf", split_dwarf, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Split out the dwarf .dwo sections", nullptr, nullptr)
+OPTION(prefix_1, "split-stacks", split_stacks, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Try to use a split stack if possible.", nullptr, nullptr)
+OPTION(prefix_1, "stack-protector-buffer-size", stack_protector_buffer_size, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Lower bound for a buffer to be considered for stack protection", nullptr, nullptr)
+OPTION(prefix_1, "stack-protector", stack_protector, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Enable stack protectors", nullptr, nullptr)
+OPTION(prefix_1, "static-define", static_define, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Should __STATIC__ be defined", nullptr, nullptr)
+OPTION(prefix_1, "static-libgcc", static_libgcc, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "static-libgfortran", static_libgfortran, Flag, gfortran_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "static-libsan", static_libsan, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Statically link the sanitizer runtime", nullptr, nullptr)
+OPTION(prefix_1, "static-libstdc++", static_libstdcxx, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "static", static, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "stats-file=", stats_file, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Filename to write statistics to", nullptr, nullptr)
+OPTION(prefix_1, "std-default=", std_default_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "std:", _SLASH_std, Joined, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Language standard to compile for", nullptr, nullptr)
+OPTION(prefix_4, "std=", std_EQ, Joined, CompileOnly_Group, INVALID, nullptr, CC1Option, 0,
+       "Language standard to compile for", nullptr, nullptr)
+OPTION(prefix_4, "stdlib=", stdlib_EQ, Joined, INVALID, INVALID, nullptr, CC1Option, 0,
+       "C++ standard library to use", nullptr, "libc++,libstdc++,platform")
+OPTION(prefix_3, "stdlib", _stdlib, Separate, INVALID, stdlib_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "std", _std, Separate, INVALID, std_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sub_library", sub__library, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sub_umbrella", sub__umbrella, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "sys-header-deps", sys_header_deps, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Include system headers in dependency output", nullptr, nullptr)
+OPTION(prefix_3, "sysroot=", _sysroot_EQ, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "sysroot", _sysroot, Separate, INVALID, _sysroot_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "system-header-prefix=", system_header_prefix, Joined, clang_i_Group, INVALID, nullptr, CC1Option, 0,
+       "Treat all #include paths starting with <prefix> as including a system header.", "<prefix>", nullptr)
+OPTION(prefix_3, "system-header-prefix", anonymous_30, Separate, INVALID, system_header_prefix, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "S", S, Flag, Action_Group, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Only run preprocess and compilation steps", nullptr, nullptr)
+OPTION(prefix_1, "s", s, Flag, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "target-abi", target_abi, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Target a particular ABI type", nullptr, nullptr)
+OPTION(prefix_1, "target-cpu", target_cpu, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Target a specific cpu type", nullptr, nullptr)
+OPTION(prefix_1, "target-feature", target_feature, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Target specific attributes", nullptr, nullptr)
+OPTION(prefix_3, "target-help", _target_help, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "target-linker-version", target_linker_version, Separate, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Target linker version", nullptr, nullptr)
+OPTION(prefix_1, "target-sdk-version=", target_sdk_version_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "The version of target SDK used for compilation", nullptr, nullptr)
+OPTION(prefix_3, "target=", target, Joined, INVALID, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Generate code for the given target", nullptr, nullptr)
+OPTION(prefix_1, "target", target_legacy_spelling, Separate, INVALID, target, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Tbss", Tbss, JoinedOrSeparate, T_Group, INVALID, nullptr, 0, 0,
+       "Set starting address of BSS to <addr>", "<addr>", nullptr)
+OPTION(prefix_2, "TC", _SLASH_TC, Flag, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Treat all source files as C", nullptr, nullptr)
+OPTION(prefix_2, "Tc", _SLASH_Tc, JoinedOrSeparate, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Specify a C source file", "<filename>", nullptr)
+OPTION(prefix_1, "Tdata", Tdata, JoinedOrSeparate, T_Group, INVALID, nullptr, 0, 0,
+       "Set starting address of DATA to <addr>", "<addr>", nullptr)
+OPTION(prefix_1, "templight-dump", templight_dump, Flag, Action_Group, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Dump templight information to stdout", nullptr, nullptr)
+OPTION(prefix_1, "test-coverage", test_coverage, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Do not generate coverage files or remove coverage changes from IR", nullptr, nullptr)
+OPTION(prefix_1, "time", time, Flag, INVALID, INVALID, nullptr, 0, 0,
+       "Time individual commands", nullptr, nullptr)
+OPTION(prefix_2, "TP", _SLASH_TP, Flag, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Treat all source files as C++", nullptr, nullptr)
+OPTION(prefix_2, "Tp", _SLASH_Tp, JoinedOrSeparate, cl_compile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Specify a C++ source file", "<filename>", nullptr)
+OPTION(prefix_3, "trace-includes", _trace_includes, Flag, INVALID, H, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "traditional-cpp", traditional_cpp, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Enable some traditional CPP emulation", nullptr, nullptr)
+OPTION(prefix_4, "traditional", traditional, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_4, "trigraphs", trigraphs, Flag, INVALID, ftrigraphs, nullptr, 0, 0,
+       "Process trigraph sequences", nullptr, nullptr)
+OPTION(prefix_1, "trim-egraph", trim_egraph, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Only show error-related paths in the analysis graph", nullptr, nullptr)
+OPTION(prefix_1, "triple=", triple_EQ, Joined, INVALID, triple, nullptr, CC1Option | NoDriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "triple", triple, Separate, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Specify target triple (e.g. i686-apple-darwin9)", nullptr, nullptr)
+OPTION(prefix_1, "Ttext", Ttext, JoinedOrSeparate, T_Group, INVALID, nullptr, 0, 0,
+       "Set starting address of TEXT to <addr>", "<addr>", nullptr)
+OPTION(prefix_1, "twolevel_namespace_hints", twolevel__namespace__hints, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "twolevel_namespace", twolevel__namespace, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "T", T, JoinedOrSeparate, T_Group, INVALID, nullptr, 0, 0,
+       "Specify <script> as linker script", "<script>", nullptr)
+OPTION(prefix_1, "t", t, Flag, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "umbrella", umbrella, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "undefine-macro=", _undefine_macro_EQ, Joined, INVALID, U, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "undefine-macro", _undefine_macro, Separate, INVALID, U, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "undefined", undefined, JoinedOrSeparate, u_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "undef", undef, Flag, u_Group, INVALID, nullptr, CC1Option, 0,
+       "undef all system defines", nullptr, nullptr)
+OPTION(prefix_1, "unexported_symbols_list", unexported__symbols__list, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "unoptimized-cfg", analysis_UnoptimizedCFG, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Generate unoptimized CFGs for all analyses", nullptr, nullptr)
+OPTION(prefix_3, "unsigned-char", _unsigned_char, Flag, INVALID, funsigned_char, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "user-dependencies", _user_dependencies, Flag, INVALID, MM, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "utf-8", _SLASH_utf8, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Set source and runtime encoding to UTF-8 (default)", nullptr, nullptr)
+OPTION(prefix_1, "U", U, JoinedOrSeparate, Preprocessor_Group, INVALID, nullptr, CC1Option, 0,
+       "Undefine macro <macro>", "<macro>", nullptr)
+OPTION(prefix_2, "U", _SLASH_U, JoinedOrSeparate, cl_Group, U, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Undefine macro", "<macro>", nullptr)
+OPTION(prefix_1, "u", u, JoinedOrSeparate, u_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "u", _SLASH_u, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "validate-charset-", _SLASH_validate_charset_, Flag, cl_Group, W_Joined, "no-invalid-source-encoding\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "validate-charset", _SLASH_validate_charset, Flag, cl_Group, W_Joined, "invalid-source-encoding\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "vd", _SLASH_vd, Joined, cl_Group, vtordisp_mode_EQ, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Control vtordisp placement", nullptr, nullptr)
+OPTION(prefix_1, "vectorize-loops", vectorize_loops, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Run the Loop vectorization passes", nullptr, nullptr)
+OPTION(prefix_1, "vectorize-slp", vectorize_slp, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Run the SLP vectorization passes", nullptr, nullptr)
+OPTION(prefix_3, "verbose", _verbose, Flag, INVALID, v, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "verify-debug-info", verify_debug_info, Flag, INVALID, INVALID, nullptr, DriverOption, 0,
+       "Verify the binary representation of debug output", nullptr, nullptr)
+OPTION(prefix_1, "verify-ignore-unexpected=", verify_ignore_unexpected_EQ, CommaJoined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Ignore unexpected diagnostic messages", nullptr, nullptr)
+OPTION(prefix_1, "verify-ignore-unexpected", verify_ignore_unexpected, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Ignore unexpected diagnostic messages", nullptr, nullptr)
+OPTION(prefix_1, "verify-pch", verify_pch, Flag, Action_Group, INVALID, nullptr, CC1Option, 0,
+       "Load and verify that a pre-compiled header file is not stale", nullptr, nullptr)
+OPTION(prefix_1, "verify=", verify_EQ, CommaJoined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Verify diagnostic output using comment directives that start with prefixes in the comma-separated sequence <prefixes>", "<prefixes>", nullptr)
+OPTION(prefix_1, "verify", verify, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Equivalent to -verify=expected", nullptr, nullptr)
+OPTION(prefix_3, "version", _version, Flag, INVALID, INVALID, nullptr, CoreOption | CC1Option, 0,
+       "Print version information", nullptr, nullptr)
+OPTION(prefix_1, "version", version, Flag, INVALID, INVALID, nullptr, CC1Option | CC1AsOption | NoDriverOption, 0,
+       "Print the compiler version", nullptr, nullptr)
+OPTION(prefix_4, "via-file-asm", via_file_asm, Flag, internal_debug_Group, INVALID, nullptr, DriverOption | HelpHidden | CoreOption, 0,
+       "Write assembly to file for input to assemble jobs", nullptr, nullptr)
+OPTION(prefix_2, "vmb", _SLASH_vmb, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Use a best-case representation method for member pointers", nullptr, nullptr)
+OPTION(prefix_2, "vmg", _SLASH_vmg, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Use a most-general representation for member pointers", nullptr, nullptr)
+OPTION(prefix_2, "vmm", _SLASH_vmm, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set the default most-general representation to multiple inheritance", nullptr, nullptr)
+OPTION(prefix_2, "vms", _SLASH_vms, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set the default most-general representation to single inheritance", nullptr, nullptr)
+OPTION(prefix_2, "vmv", _SLASH_vmv, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Set the default most-general representation to virtual inheritance", nullptr, nullptr)
+OPTION(prefix_2, "volatile:iso", _SLASH_volatile_iso, Flag, _SLASH_volatile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Volatile loads and stores have standard semantics", nullptr, nullptr)
+OPTION(prefix_2, "volatile:ms", _SLASH_volatile_ms, Flag, _SLASH_volatile_Group, INVALID, nullptr, CLOption | DriverOption, 0,
+       "Volatile loads and stores have acquire and release semantics", nullptr, nullptr)
+OPTION(prefix_1, "vtordisp-mode=", vtordisp_mode_EQ, Joined, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Control vtordisp placement on win32 targets", nullptr, nullptr)
+OPTION(prefix_1, "V", V, JoinedOrSeparate, INVALID, INVALID, nullptr, DriverOption | Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "V", _SLASH_V, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "v", v, Flag, INVALID, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Show commands to run and use verbose output", nullptr, nullptr)
+OPTION(prefix_2, "W0", _SLASH_W0, Flag, cl_Group, w, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable all warnings", nullptr, nullptr)
+OPTION(prefix_2, "W1", _SLASH_W1, Flag, cl_Group, Wall, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable -Wall", nullptr, nullptr)
+OPTION(prefix_2, "W2", _SLASH_W2, Flag, cl_Group, Wall, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable -Wall", nullptr, nullptr)
+OPTION(prefix_2, "W3", _SLASH_W3, Flag, cl_Group, Wall, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable -Wall", nullptr, nullptr)
+OPTION(prefix_2, "W4", _SLASH_W4, Flag, cl_Group, WCL4, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable -Wall and -Wextra", nullptr, nullptr)
+OPTION(prefix_1, "Wa,", Wa_COMMA, CommaJoined, INVALID, INVALID, nullptr, 0, 0,
+       "Pass the comma separated arguments in <arg> to the assembler", "<arg>", nullptr)
+OPTION(prefix_1, "Wall", Wall, Flag, W_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Wall", _SLASH_Wall, Flag, cl_Group, W_Joined, "everything\0", CLOption | DriverOption | CLOption, 0,
+       "Enable -Weverything", nullptr, nullptr)
+OPTION(prefix_3, "warn-=", _warn__EQ, Joined, INVALID, W_Joined, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "warn-", _warn_, Joined, INVALID, W_Joined, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "WCL4", WCL4, Flag, W_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "wd4005", _SLASH_wd4005, Flag, cl_Group, W_Joined, "no-macro-redefined\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "wd4018", _SLASH_wd4018, Flag, cl_Group, W_Joined, "no-sign-compare\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "wd4100", _SLASH_wd4100, Flag, cl_Group, W_Joined, "no-unused-parameter\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "wd4910", _SLASH_wd4910, Flag, cl_Group, W_Joined, "no-dllexport-explicit-instantiation-decl\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "wd4996", _SLASH_wd4996, Flag, cl_Group, W_Joined, "no-deprecated-declarations\0", CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wdeprecated", Wdeprecated, Flag, W_Group, INVALID, nullptr, CC1Option, 0,
+       "Enable warnings for deprecated constructs and define __DEPRECATED", nullptr, nullptr)
+OPTION(prefix_1, "weak-l", weak_l, Joined, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "weak_framework", weak__framework, Separate, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "weak_library", weak__library, Separate, INVALID, INVALID, nullptr, LinkerInput, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "weak_reference_mismatches", weak__reference__mismatches, Separate, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wframe-larger-than=", Wframe_larger_than_EQ, Joined, f_Group, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "whatsloaded", whatsloaded, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "whyload", whyload, Flag, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wl,", Wl_COMMA, CommaJoined, Link_Group, INVALID, nullptr, LinkerInput | RenderAsInput, 0,
+       "Pass the comma separated arguments in <arg> to the linker", "<arg>", nullptr)
+OPTION(prefix_1, "Wlarge-by-value-copy=", Wlarge_by_value_copy_EQ, Joined, INVALID, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wlarge-by-value-copy", Wlarge_by_value_copy_def, Flag, INVALID, INVALID, nullptr, HelpHidden, 0,
+       "Warn if a function definition returns or accepts an object larger in bytes than a given value", nullptr, nullptr)
+OPTION(prefix_1, "Wlarger-than-", Wlarger_than_, Joined, INVALID, Wlarger_than_EQ, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wlarger-than=", Wlarger_than_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "WL", _SLASH_WL, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wno-deprecated", Wno_deprecated, Flag, W_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wno-nonportable-cfstrings", Wno_nonportable_cfstrings, Joined, W_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wno-rewrite-macros", Wno_rewrite_macros, Flag, INVALID, INVALID, nullptr, CC1Option | NoDriverOption, 0,
+       "Silence ObjC rewriting warnings", nullptr, nullptr)
+OPTION(prefix_1, "Wno-write-strings", Wno_write_strings, Flag, W_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wnonportable-cfstrings", Wnonportable_cfstrings, Joined, W_Group, INVALID, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "working-directory=", working_directory_EQ, Joined, INVALID, working_directory, nullptr, CC1Option, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "working-directory", working_directory, JoinedOrSeparate, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Resolve file paths relative to the specified directory", nullptr, nullptr)
+OPTION(prefix_1, "Wp,", Wp_COMMA, CommaJoined, Preprocessor_Group, INVALID, nullptr, 0, 0,
+       "Pass the comma separated arguments in <arg> to the preprocessor", "<arg>", nullptr)
+OPTION(prefix_2, "Wp64", _SLASH_Wp64, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "write-dependencies", _write_dependencies, Flag, INVALID, MD, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "write-user-dependencies", _write_user_dependencies, Flag, INVALID, MMD, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Wwrite-strings", Wwrite_strings, Flag, W_Group, INVALID, nullptr, CC1Option | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "WX-", _SLASH_WX_, Flag, cl_Group, W_Joined, "no-error\0", CLOption | DriverOption | CLOption, 0,
+       "Do not treat warnings as errors", nullptr, nullptr)
+OPTION(prefix_2, "WX", _SLASH_WX, Flag, cl_Group, W_Joined, "error\0", CLOption | DriverOption | CLOption, 0,
+       "Treat warnings as errors", nullptr, nullptr)
+OPTION(prefix_1, "W", W_Joined, Joined, W_Group, INVALID, nullptr, CC1Option | CoreOption, 0,
+       "Enable the specified warning", "<warning>", nullptr)
+OPTION(prefix_1, "w", w, Flag, INVALID, INVALID, nullptr, CC1Option, 0,
+       "Suppress all warnings", nullptr, nullptr)
+OPTION(prefix_2, "w", _SLASH_w_flag, Flag, cl_Group, w, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable all warnings", nullptr, nullptr)
+OPTION(prefix_2, "w", _SLASH_w, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Xanalyzer", Xanalyzer, Separate, StaticAnalyzer_Group, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the static analyzer", "<arg>", nullptr)
+OPTION(prefix_1, "Xarch_", Xarch__, JoinedAndSeparate, INVALID, INVALID, nullptr, DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Xassembler", Xassembler, Separate, CompileOnly_Group, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the assembler", "<arg>", nullptr)
+OPTION(prefix_1, "Xclang", Xclang, Separate, CompileOnly_Group, INVALID, nullptr, DriverOption | CoreOption, 0,
+       "Pass <arg> to the clang compiler", "<arg>", nullptr)
+OPTION(prefix_1, "Xcuda-fatbinary", Xcuda_fatbinary, Separate, INVALID, INVALID, nullptr, 0, 0,
+       "Pass <arg> to fatbinary invocation", "<arg>", nullptr)
+OPTION(prefix_1, "Xcuda-ptxas", Xcuda_ptxas, Separate, INVALID, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the ptxas assembler", "<arg>", nullptr)
+OPTION(prefix_1, "Xlinker", Xlinker, Separate, Link_Group, INVALID, nullptr, LinkerInput | RenderAsInput, 0,
+       "Pass <arg> to the linker", "<arg>", nullptr)
+OPTION(prefix_1, "Xopenmp-target=", Xopenmp_target_EQ, JoinedAndSeparate, INVALID, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the target offloading toolchain identified by <triple>.", "<triple> <arg>", nullptr)
+OPTION(prefix_1, "Xopenmp-target", Xopenmp_target, Separate, INVALID, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the target offloading toolchain.", "<arg>", nullptr)
+OPTION(prefix_1, "Xpreprocessor", Xpreprocessor, Separate, Preprocessor_Group, INVALID, nullptr, 0, 0,
+       "Pass <arg> to the preprocessor", "<arg>", nullptr)
+OPTION(prefix_1, "X", X_Flag, Flag, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "X", X_Joined, Joined, INVALID, INVALID, nullptr, HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "X", _SLASH_X, Flag, cl_Group, nostdlibinc, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't add %INCLUDE% to the include search path", nullptr, nullptr)
+OPTION(prefix_1, "x", x, JoinedOrSeparate, INVALID, INVALID, nullptr, DriverOption | CC1Option, 0,
+       "Treat subsequent input files as having type <language>", "<language>", nullptr)
+OPTION(prefix_2, "Y-", _SLASH_Y_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable precompiled headers, overrides /Yc and /Yu", nullptr, nullptr)
+OPTION(prefix_2, "Yc", _SLASH_Yc, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Generate a pch file for all code up to and including <filename>", "<filename>", nullptr)
+OPTION(prefix_2, "Yd", _SLASH_Yd, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Yl", _SLASH_Yl, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Yu", _SLASH_Yu, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Load a pch file and use it instead of all code up to and including <filename>", "<filename>", nullptr)
+OPTION(prefix_1, "y", y, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Z-reserved-lib-cckext", Z_reserved_lib_cckext, Flag, reserved_lib_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused | Unsupported | Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Z-reserved-lib-stdc++", Z_reserved_lib_stdcxx, Flag, reserved_lib_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused | Unsupported | Unsupported, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Z-Xlinker-no-demangle", Z_Xlinker__no_demangle, Flag, INVALID, INVALID, nullptr, Unsupported | NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Z7", _SLASH_Z7, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable CodeView debug information in object files", nullptr, nullptr)
+OPTION(prefix_2, "Za", _SLASH_Za, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:__cplusplus", _SLASH_Zc___cplusplus, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:alignedNew-", _SLASH_Zc_alignedNew_, Flag, cl_Group, fno_aligned_allocation, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable C++17 aligned allocation functions", nullptr, nullptr)
+OPTION(prefix_2, "Zc:alignedNew", _SLASH_Zc_alignedNew, Flag, cl_Group, faligned_allocation, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable C++17 aligned allocation functions", nullptr, nullptr)
+OPTION(prefix_2, "Zc:auto", _SLASH_Zc_auto, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:dllexportInlines-", _SLASH_Zc_dllexportInlines_, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't dllexport/dllimport inline member functions of dllexport/import classes", nullptr, nullptr)
+OPTION(prefix_2, "Zc:dllexportInlines", _SLASH_Zc_dllexportInlines, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "dllexport/dllimport inline member functions of dllexport/import classes (default)", nullptr, nullptr)
+OPTION(prefix_2, "Zc:forScope", _SLASH_Zc_forScope, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:inline", _SLASH_Zc_inline, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:rvalueCast", _SLASH_Zc_rvalueCast, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:sizedDealloc-", _SLASH_Zc_sizedDealloc_, Flag, cl_Group, fno_sized_deallocation, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable C++14 sized global deallocation functions", nullptr, nullptr)
+OPTION(prefix_2, "Zc:sizedDealloc", _SLASH_Zc_sizedDealloc, Flag, cl_Group, fsized_deallocation, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable C++14 sized global deallocation functions", nullptr, nullptr)
+OPTION(prefix_2, "Zc:strictStrings", _SLASH_Zc_strictStrings, Flag, cl_Group, W_Joined, "error=c++11-compat-deprecated-writable-strings\0", CLOption | DriverOption | CLOption, 0,
+       "Treat string literals as const", nullptr, nullptr)
+OPTION(prefix_2, "Zc:ternary", _SLASH_Zc_ternary, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:threadSafeInit-", _SLASH_Zc_threadSafeInit_, Flag, cl_Group, fno_threadsafe_statics, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable thread-safe initialization of static variables", nullptr, nullptr)
+OPTION(prefix_2, "Zc:threadSafeInit", _SLASH_Zc_threadSafeInit, Flag, cl_Group, fthreadsafe_statics, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable thread-safe initialization of static variables", nullptr, nullptr)
+OPTION(prefix_2, "Zc:trigraphs-", _SLASH_Zc_trigraphs_off, Flag, cl_Group, fno_trigraphs, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable trigraphs (default)", nullptr, nullptr)
+OPTION(prefix_2, "Zc:trigraphs", _SLASH_Zc_trigraphs, Flag, cl_Group, ftrigraphs, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable trigraphs", nullptr, nullptr)
+OPTION(prefix_2, "Zc:twoPhase-", _SLASH_Zc_twoPhase_, Flag, cl_Group, fdelayed_template_parsing, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Disable two-phase name lookup in templates", nullptr, nullptr)
+OPTION(prefix_2, "Zc:twoPhase", _SLASH_Zc_twoPhase, Flag, cl_Group, fno_delayed_template_parsing, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Enable two-phase name lookup in templates", nullptr, nullptr)
+OPTION(prefix_2, "Zc:wchar_t", _SLASH_Zc_wchar_t, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zc:", _SLASH_Zc, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zd", _SLASH_Zd, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Emit debug line number tables only", nullptr, nullptr)
+OPTION(prefix_2, "Ze", _SLASH_Ze, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zg", _SLASH_Zg, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "ZI", _SLASH_ZI, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zi", _SLASH_Zi, Flag, cl_Group, _SLASH_Z7, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Alias for /Z7. Does not produce PDBs.", nullptr, nullptr)
+OPTION(prefix_1, "Zlinker-input", Zlinker_input, Separate, INVALID, INVALID, nullptr, Unsupported | NoArgumentUnused, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zl", _SLASH_Zl, Flag, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Don't mention any default libraries in the object file", nullptr, nullptr)
+OPTION(prefix_2, "Zm", _SLASH_Zm, Joined, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption | HelpHidden, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zo-", _SLASH_Zo_, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zo", _SLASH_Zo, Flag, cl_ignored_Group, INVALID, nullptr, CLOption | DriverOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_2, "Zp", _SLASH_Zp_flag, Flag, cl_Group, fpack_struct_EQ, "1\0", CLOption | DriverOption | CLOption, 0,
+       "Set the default maximum struct packing alignment to 1", nullptr, nullptr)
+OPTION(prefix_2, "Zp", _SLASH_Zp, Joined, cl_Group, fpack_struct_EQ, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Specify the default maximum struct packing alignment", nullptr, nullptr)
+OPTION(prefix_2, "Zs", _SLASH_Zs, Flag, cl_Group, fsyntax_only, nullptr, CLOption | DriverOption | CLOption, 0,
+       "Syntax-check only", nullptr, nullptr)
+OPTION(prefix_2, "ZW", _SLASH_ZW, Joined, cl_Group, INVALID, nullptr, CLOption | DriverOption | CLOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Z", Z_Flag, Flag, Link_Group, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "Z", Z_Joined, Joined, INVALID, INVALID, nullptr, 0, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_1, "z", z, Separate, Link_Group, INVALID, nullptr, LinkerInput | RenderAsInput, 0,
+       "Pass -z <arg> to the linker", "<arg>", nullptr)
+OPTION(prefix_3, "", _DASH_DASH, RemainingArgs, INVALID, INVALID, nullptr, DriverOption | CoreOption, 0, nullptr, nullptr, nullptr)
+OPTION(prefix_3, "", _, Joined, INVALID, INVALID, nullptr, Unsupported, 0, nullptr, nullptr, nullptr)
+#endif // OPTION
+
+#ifdef OPTTABLE_ARG_INIT
+//////////
+// Option Values
+
+{
+bool ValuesWereAdded;
+
+    const char *Values =
+    #define GET_CHECKERS
+    #define CHECKER(FULLNAME, CLASS, HT, DOC_URI)  FULLNAME ","
+    #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+    #undef GET_CHECKERS
+    #define GET_PACKAGES
+    #define PACKAGE(FULLNAME)  FULLNAME ","
+    #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
+    #undef GET_PACKAGES
+    ;
+  
+ValuesWereAdded = Opt.addValues("-analyzer-checker", Values);
+(void)ValuesWereAdded;
+assert(ValuesWereAdded && "Couldn't add values to OptTable!");
+}
+{
+bool ValuesWereAdded;
+
+    const char *Values =
+    #define LANGSTANDARD(id, name, lang, desc, features) name ","
+    #define LANGSTANDARD_ALIAS(id, alias) alias ","
+    #include "clang/Frontend/LangStandards.def"
+    ;
+  
+ValuesWereAdded = Opt.addValues("-std=", Values);
+(void)ValuesWereAdded;
+assert(ValuesWereAdded && "Couldn't add values to OptTable!");
+ValuesWereAdded = Opt.addValues("--std=", Values);
+(void)ValuesWereAdded;
+assert(ValuesWereAdded && "Couldn't add values to OptTable!");
+}
+
+#endif // OPTTABLE_ARG_INIT
diff --git a/clang-r353983e/include/clang/Driver/Phases.h b/clang-r353983e/include/clang/Driver/Phases.h
new file mode 100644
index 00000000..7199c657
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Phases.h
@@ -0,0 +1,36 @@
+//===--- Phases.h - Transformations on Driver Types -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_PHASES_H
+#define LLVM_CLANG_DRIVER_PHASES_H
+
+namespace clang {
+namespace driver {
+namespace phases {
+  /// ID - Ordered values for successive stages in the
+  /// compilation process which interact with user options.
+  enum ID {
+    Preprocess,
+    Precompile,
+    Compile,
+    Backend,
+    Assemble,
+    Link
+  };
+
+  enum {
+    MaxNumberOfPhases = Link + 1
+  };
+
+  const char *getPhaseName(ID Id);
+
+} // end namespace phases
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/SanitizerArgs.h b/clang-r353983e/include/clang/Driver/SanitizerArgs.h
new file mode 100644
index 00000000..18e8e4fe
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/SanitizerArgs.h
@@ -0,0 +1,94 @@
+//===--- SanitizerArgs.h - Arguments for sanitizer tools  -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_DRIVER_SANITIZERARGS_H
+#define LLVM_CLANG_DRIVER_SANITIZERARGS_H
+
+#include "clang/Basic/Sanitizers.h"
+#include "clang/Driver/Types.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace driver {
+
+class ToolChain;
+
+class SanitizerArgs {
+  SanitizerSet Sanitizers;
+  SanitizerSet RecoverableSanitizers;
+  SanitizerSet TrapSanitizers;
+
+  std::vector<std::string> BlacklistFiles;
+  std::vector<std::string> ExtraDeps;
+  int CoverageFeatures = 0;
+  int MsanTrackOrigins = 0;
+  bool MsanUseAfterDtor = true;
+  bool CfiCrossDso = false;
+  bool CfiICallGeneralizePointers = false;
+  int AsanFieldPadding = 0;
+  bool SharedRuntime = false;
+  bool AsanUseAfterScope = true;
+  bool AsanPoisonCustomArrayCookie = false;
+  bool AsanGlobalsDeadStripping = false;
+  bool AsanUseOdrIndicator = false;
+  std::string HwasanAbi;
+  bool LinkCXXRuntimes = false;
+  bool NeedPIE = false;
+  bool SafeStackRuntime = false;
+  bool Stats = false;
+  bool TsanMemoryAccess = true;
+  bool TsanFuncEntryExit = true;
+  bool TsanAtomics = true;
+  bool MinimalRuntime = false;
+  // True if cross-dso CFI support if provided by the system (i.e. Android).
+  bool ImplicitCfiRuntime = false;
+
+ public:
+  /// Parses the sanitizer arguments from an argument list.
+  SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
+
+  bool needsSharedRt() const { return SharedRuntime; }
+
+  bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
+  bool needsHwasanRt() const { return Sanitizers.has(SanitizerKind::HWAddress); }
+  bool needsTsanRt() const { return Sanitizers.has(SanitizerKind::Thread); }
+  bool needsMsanRt() const { return Sanitizers.has(SanitizerKind::Memory); }
+  bool needsFuzzer() const { return Sanitizers.has(SanitizerKind::Fuzzer); }
+  bool needsLsanRt() const {
+    return Sanitizers.has(SanitizerKind::Leak) &&
+           !Sanitizers.has(SanitizerKind::Address) &&
+           !Sanitizers.has(SanitizerKind::HWAddress);
+  }
+  bool needsUbsanRt() const;
+  bool requiresMinimalRuntime() const { return MinimalRuntime; }
+  bool needsDfsanRt() const { return Sanitizers.has(SanitizerKind::DataFlow); }
+  bool needsSafeStackRt() const { return SafeStackRuntime; }
+  bool needsCfiRt() const;
+  bool needsCfiDiagRt() const;
+  bool needsStatsRt() const { return Stats; }
+  bool needsEsanRt() const {
+    return Sanitizers.hasOneOf(SanitizerKind::Efficiency);
+  }
+  bool needsScudoRt() const { return Sanitizers.has(SanitizerKind::Scudo); }
+
+  bool requiresPIE() const;
+  bool needsUnwindTables() const;
+  bool needsLTO() const;
+  bool linkCXXRuntimes() const { return LinkCXXRuntimes; }
+  bool hasCrossDsoCfi() const { return CfiCrossDso; }
+  bool hasAnySanitizer() const { return !Sanitizers.empty(); }
+  void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
+               llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const;
+};
+
+}  // namespace driver
+}  // namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/Tool.h b/clang-r353983e/include/clang/Driver/Tool.h
new file mode 100644
index 00000000..8d049160
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Tool.h
@@ -0,0 +1,150 @@
+//===--- Tool.h - Compilation Tools -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_TOOL_H
+#define LLVM_CLANG_DRIVER_TOOL_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/Support/Program.h"
+
+namespace llvm {
+namespace opt {
+  class ArgList;
+}
+}
+
+namespace clang {
+namespace driver {
+
+  class Compilation;
+  class InputInfo;
+  class Job;
+  class JobAction;
+  class ToolChain;
+
+  typedef SmallVector<InputInfo, 4> InputInfoList;
+
+/// Tool - Information on a specific compilation tool.
+class Tool {
+public:
+  // Documents the level of support for response files in this tool.
+  // Response files are necessary if the command line gets too large,
+  // requiring the arguments to be transferred to a file.
+  enum ResponseFileSupport {
+    // Provides full support for response files, which means we can transfer
+    // all tool input arguments to a file. E.g.: clang, gcc, binutils and MSVC
+    // tools.
+    RF_Full,
+    // Input file names can live in a file, but flags can't. E.g.: ld64 (Mac
+    // OS X linker).
+    RF_FileList,
+    // Does not support response files: all arguments must be passed via
+    // command line.
+    RF_None
+  };
+
+private:
+  /// The tool name (for debugging).
+  const char *Name;
+
+  /// The human readable name for the tool, for use in diagnostics.
+  const char *ShortName;
+
+  /// The tool chain this tool is a part of.
+  const ToolChain &TheToolChain;
+
+  /// The level of support for response files seen in this tool
+  const ResponseFileSupport ResponseSupport;
+
+  /// The encoding to use when writing response files for this tool on Windows
+  const llvm::sys::WindowsEncodingMethod ResponseEncoding;
+
+  /// The flag used to pass a response file via command line to this tool
+  const char *const ResponseFlag;
+
+public:
+  Tool(const char *Name, const char *ShortName, const ToolChain &TC,
+       ResponseFileSupport ResponseSupport = RF_None,
+       llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8,
+       const char *ResponseFlag = "@");
+
+public:
+  virtual ~Tool();
+
+  const char *getName() const { return Name; }
+
+  const char *getShortName() const { return ShortName; }
+
+  const ToolChain &getToolChain() const { return TheToolChain; }
+
+  virtual bool hasIntegratedAssembler() const { return false; }
+  virtual bool canEmitIR() const { return false; }
+  virtual bool hasIntegratedCPP() const = 0;
+  virtual bool isLinkJob() const { return false; }
+  virtual bool isDsymutilJob() const { return false; }
+  /// Returns the level of support for response files of this tool,
+  /// whether it accepts arguments to be passed via a file on disk.
+  ResponseFileSupport getResponseFilesSupport() const {
+    return ResponseSupport;
+  }
+  /// Returns which encoding the response file should use. This is only
+  /// relevant on Windows platforms where there are different encodings being
+  /// accepted for different tools. On UNIX, UTF8 is universal.
+  ///
+  /// Windows use cases: - GCC and Binutils on mingw only accept ANSI response
+  /// files encoded with the system current code page.
+  /// - MSVC's CL.exe and LINK.exe accept UTF16 on Windows.
+  /// - Clang accepts both UTF8 and UTF16.
+  ///
+  /// FIXME: When GNU tools learn how to parse UTF16 on Windows, we should
+  /// always use UTF16 for Windows, which is the Windows official encoding for
+  /// international characters.
+  llvm::sys::WindowsEncodingMethod getResponseFileEncoding() const {
+    return ResponseEncoding;
+  }
+  /// Returns which prefix to use when passing the name of a response
+  /// file as a parameter to this tool.
+  const char *getResponseFileFlag() const { return ResponseFlag; }
+
+  /// Does this tool have "good" standardized diagnostics, or should the
+  /// driver add an additional "command failed" diagnostic on failures.
+  virtual bool hasGoodDiagnostics() const { return false; }
+
+  /// ConstructJob - Construct jobs to perform the action \p JA,
+  /// writing to \p Output and with \p Inputs, and add the jobs to
+  /// \p C.
+  ///
+  /// \param TCArgs - The argument list for this toolchain, with any
+  /// tool chain specific translations applied.
+  /// \param LinkingOutput - If this output will eventually feed the
+  /// linker, then this is the final output name of the linked image.
+  virtual void ConstructJob(Compilation &C, const JobAction &JA,
+                            const InputInfo &Output,
+                            const InputInfoList &Inputs,
+                            const llvm::opt::ArgList &TCArgs,
+                            const char *LinkingOutput) const = 0;
+  /// Construct jobs to perform the action \p JA, writing to the \p Outputs and
+  /// with \p Inputs, and add the jobs to \p C. The default implementation
+  /// assumes a single output and is expected to be overloaded for the tools
+  /// that support multiple inputs.
+  ///
+  /// \param TCArgs The argument list for this toolchain, with any
+  /// tool chain specific translations applied.
+  /// \param LinkingOutput If this output will eventually feed the
+  /// linker, then this is the final output name of the linked image.
+  virtual void ConstructJobMultipleOutputs(Compilation &C, const JobAction &JA,
+                                           const InputInfoList &Outputs,
+                                           const InputInfoList &Inputs,
+                                           const llvm::opt::ArgList &TCArgs,
+                                           const char *LinkingOutput) const;
+};
+
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/ToolChain.h b/clang-r353983e/include/clang/Driver/ToolChain.h
new file mode 100644
index 00000000..e82675d3
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/ToolChain.h
@@ -0,0 +1,588 @@
+//===- ToolChain.h - Collections of tools for one platform ------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_TOOLCHAIN_H
+#define LLVM_CLANG_DRIVER_TOOLCHAIN_H
+
+#include "clang/Basic/DebugInfoOptions.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/Sanitizers.h"
+#include "clang/Driver/Action.h"
+#include "clang/Driver/Multilib.h"
+#include "clang/Driver/Types.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/VersionTuple.h"
+#include "llvm/Target/TargetOptions.h"
+#include <cassert>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace llvm {
+namespace opt {
+
+class Arg;
+class ArgList;
+class DerivedArgList;
+
+} // namespace opt
+namespace vfs {
+
+class FileSystem;
+
+} // namespace vfs
+} // namespace llvm
+
+namespace clang {
+
+class ObjCRuntime;
+
+namespace driver {
+
+class Driver;
+class InputInfo;
+class SanitizerArgs;
+class Tool;
+class XRayArgs;
+
+/// Helper structure used to pass information extracted from clang executable
+/// name such as `i686-linux-android-g++`.
+struct ParsedClangName {
+  /// Target part of the executable name, as `i686-linux-android`.
+  std::string TargetPrefix;
+
+  /// Driver mode part of the executable name, as `g++`.
+  std::string ModeSuffix;
+
+  /// Corresponding driver mode argument, as '--driver-mode=g++'
+  const char *DriverMode = nullptr;
+
+  /// True if TargetPrefix is recognized as a registered target name.
+  bool TargetIsValid = false;
+
+  ParsedClangName() = default;
+  ParsedClangName(std::string Suffix, const char *Mode)
+      : ModeSuffix(Suffix), DriverMode(Mode) {}
+  ParsedClangName(std::string Target, std::string Suffix, const char *Mode,
+                  bool IsRegistered)
+      : TargetPrefix(Target), ModeSuffix(Suffix), DriverMode(Mode),
+        TargetIsValid(IsRegistered) {}
+
+  bool isEmpty() const {
+    return TargetPrefix.empty() && ModeSuffix.empty() && DriverMode == nullptr;
+  }
+};
+
+/// ToolChain - Access to tools for a single platform.
+class ToolChain {
+public:
+  using path_list = SmallVector<std::string, 16>;
+
+  enum CXXStdlibType {
+    CST_Libcxx,
+    CST_Libstdcxx
+  };
+
+  enum RuntimeLibType {
+    RLT_CompilerRT,
+    RLT_Libgcc
+  };
+
+  enum RTTIMode {
+    RM_Enabled,
+    RM_Disabled,
+  };
+
+private:
+  friend class RegisterEffectiveTriple;
+
+  const Driver &D;
+  llvm::Triple Triple;
+  const llvm::opt::ArgList &Args;
+
+  // We need to initialize CachedRTTIArg before CachedRTTIMode
+  const llvm::opt::Arg *const CachedRTTIArg;
+
+  const RTTIMode CachedRTTIMode;
+
+  /// The list of toolchain specific path prefixes to search for libraries.
+  path_list LibraryPaths;
+
+  /// The list of toolchain specific path prefixes to search for files.
+  path_list FilePaths;
+
+  /// The list of toolchain specific path prefixes to search for programs.
+  path_list ProgramPaths;
+
+  mutable std::unique_ptr<Tool> Clang;
+  mutable std::unique_ptr<Tool> Assemble;
+  mutable std::unique_ptr<Tool> Link;
+  mutable std::unique_ptr<Tool> OffloadBundler;
+
+  Tool *getClang() const;
+  Tool *getAssemble() const;
+  Tool *getLink() const;
+  Tool *getClangAs() const;
+  Tool *getOffloadBundler() const;
+
+  mutable std::unique_ptr<SanitizerArgs> SanitizerArguments;
+  mutable std::unique_ptr<XRayArgs> XRayArguments;
+
+  /// The effective clang triple for the current Job.
+  mutable llvm::Triple EffectiveTriple;
+
+  /// Set the toolchain's effective clang triple.
+  void setEffectiveTriple(llvm::Triple ET) const {
+    EffectiveTriple = std::move(ET);
+  }
+
+protected:
+  MultilibSet Multilibs;
+  Multilib SelectedMultilib;
+
+  ToolChain(const Driver &D, const llvm::Triple &T,
+            const llvm::opt::ArgList &Args);
+
+  void setTripleEnvironment(llvm::Triple::EnvironmentType Env);
+
+  virtual Tool *buildAssembler() const;
+  virtual Tool *buildLinker() const;
+  virtual Tool *getTool(Action::ActionClass AC) const;
+
+  /// \name Utilities for implementing subclasses.
+  ///@{
+  static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
+                               llvm::opt::ArgStringList &CC1Args,
+                               const Twine &Path);
+  static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs,
+                                      llvm::opt::ArgStringList &CC1Args,
+                                      const Twine &Path);
+  static void
+      addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs,
+                                      llvm::opt::ArgStringList &CC1Args,
+                                      const Twine &Path);
+  static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs,
+                                llvm::opt::ArgStringList &CC1Args,
+                                ArrayRef<StringRef> Paths);
+  ///@}
+
+public:
+  virtual ~ToolChain();
+
+  // Accessors
+
+  const Driver &getDriver() const { return D; }
+  llvm::vfs::FileSystem &getVFS() const;
+  const llvm::Triple &getTriple() const { return Triple; }
+
+  /// Get the toolchain's aux triple, if it has one.
+  ///
+  /// Exactly what the aux triple represents depends on the toolchain, but for
+  /// example when compiling CUDA code for the GPU, the triple might be NVPTX,
+  /// while the aux triple is the host (CPU) toolchain, e.g. x86-linux-gnu.
+  virtual const llvm::Triple *getAuxTriple() const { return nullptr; }
+
+  /// Some toolchains need to modify the file name, for example to replace the
+  /// extension for object files with .cubin for OpenMP offloading to Nvidia
+  /// GPUs.
+  virtual std::string getInputFilename(const InputInfo &Input) const;
+
+  llvm::Triple::ArchType getArch() const { return Triple.getArch(); }
+  StringRef getArchName() const { return Triple.getArchName(); }
+  StringRef getPlatform() const { return Triple.getVendorName(); }
+  StringRef getOS() const { return Triple.getOSName(); }
+
+  /// Provide the default architecture name (as expected by -arch) for
+  /// this toolchain.
+  StringRef getDefaultUniversalArchName() const;
+
+  std::string getTripleString() const {
+    return Triple.getTriple();
+  }
+
+  /// Get the toolchain's effective clang triple.
+  const llvm::Triple &getEffectiveTriple() const {
+    assert(!EffectiveTriple.getTriple().empty() && "No effective triple");
+    return EffectiveTriple;
+  }
+
+  path_list &getLibraryPaths() { return LibraryPaths; }
+  const path_list &getLibraryPaths() const { return LibraryPaths; }
+
+  path_list &getFilePaths() { return FilePaths; }
+  const path_list &getFilePaths() const { return FilePaths; }
+
+  path_list &getProgramPaths() { return ProgramPaths; }
+  const path_list &getProgramPaths() const { return ProgramPaths; }
+
+  const MultilibSet &getMultilibs() const { return Multilibs; }
+
+  const Multilib &getMultilib() const { return SelectedMultilib; }
+
+  const SanitizerArgs& getSanitizerArgs() const;
+
+  const XRayArgs& getXRayArgs() const;
+
+  // Returns the Arg * that explicitly turned on/off rtti, or nullptr.
+  const llvm::opt::Arg *getRTTIArg() const { return CachedRTTIArg; }
+
+  // Returns the RTTIMode for the toolchain with the current arguments.
+  RTTIMode getRTTIMode() const { return CachedRTTIMode; }
+
+  /// Return any implicit target and/or mode flag for an invocation of
+  /// the compiler driver as `ProgName`.
+  ///
+  /// For example, when called with i686-linux-android-g++, the first element
+  /// of the return value will be set to `"i686-linux-android"` and the second
+  /// will be set to "--driver-mode=g++"`.
+  /// It is OK if the target name is not registered. In this case the return
+  /// value contains false in the field TargetIsValid.
+  ///
+  /// \pre `llvm::InitializeAllTargets()` has been called.
+  /// \param ProgName The name the Clang driver was invoked with (from,
+  /// e.g., argv[0]).
+  /// \return A structure of type ParsedClangName that contains the executable
+  /// name parts.
+  static ParsedClangName getTargetAndModeFromProgramName(StringRef ProgName);
+
+  // Tool access.
+
+  /// TranslateArgs - Create a new derived argument list for any argument
+  /// translations this ToolChain may wish to perform, or 0 if no tool chain
+  /// specific translations are needed. If \p DeviceOffloadKind is specified
+  /// the translation specific for that offload kind is performed.
+  ///
+  /// \param BoundArch - The bound architecture name, or 0.
+  /// \param DeviceOffloadKind - The device offload kind used for the
+  /// translation.
+  virtual llvm::opt::DerivedArgList *
+  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
+                Action::OffloadKind DeviceOffloadKind) const {
+    return nullptr;
+  }
+
+  /// TranslateOpenMPTargetArgs - Create a new derived argument list for
+  /// that contains the OpenMP target specific flags passed via
+  /// -Xopenmp-target -opt=val OR -Xopenmp-target=<triple> -opt=val
+  virtual llvm::opt::DerivedArgList *TranslateOpenMPTargetArgs(
+      const llvm::opt::DerivedArgList &Args, bool SameTripleAsHost,
+      SmallVectorImpl<llvm::opt::Arg *> &AllocatedArgs) const;
+
+  /// Choose a tool to use to handle the action \p JA.
+  ///
+  /// This can be overridden when a particular ToolChain needs to use
+  /// a compiler other than Clang.
+  virtual Tool *SelectTool(const JobAction &JA) const;
+
+  // Helper methods
+
+  std::string GetFilePath(const char *Name) const;
+  std::string GetProgramPath(const char *Name) const;
+
+  /// Returns the linker path, respecting the -fuse-ld= argument to determine
+  /// the linker suffix or name.
+  std::string GetLinkerPath() const;
+
+  /// Dispatch to the specific toolchain for verbose printing.
+  ///
+  /// This is used when handling the verbose option to print detailed,
+  /// toolchain-specific information useful for understanding the behavior of
+  /// the driver on a specific platform.
+  virtual void printVerboseInfo(raw_ostream &OS) const {}
+
+  // Platform defaults information
+
+  /// Returns true if the toolchain is targeting a non-native
+  /// architecture.
+  virtual bool isCrossCompiling() const;
+
+  /// HasNativeLTOLinker - Check whether the linker and related tools have
+  /// native LLVM support.
+  virtual bool HasNativeLLVMSupport() const;
+
+  /// LookupTypeForExtension - Return the default language type to use for the
+  /// given extension.
+  virtual types::ID LookupTypeForExtension(StringRef Ext) const;
+
+  /// IsBlocksDefault - Does this tool chain enable -fblocks by default.
+  virtual bool IsBlocksDefault() const { return false; }
+
+  /// IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as
+  /// by default.
+  virtual bool IsIntegratedAssemblerDefault() const { return false; }
+
+  /// Check if the toolchain should use the integrated assembler.
+  virtual bool useIntegratedAs() const;
+
+  /// IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
+  virtual bool IsMathErrnoDefault() const { return true; }
+
+  /// IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable
+  /// -fencode-extended-block-signature by default.
+  virtual bool IsEncodeExtendedBlockSignatureDefault() const { return false; }
+
+  /// IsObjCNonFragileABIDefault - Does this tool chain set
+  /// -fobjc-nonfragile-abi by default.
+  virtual bool IsObjCNonFragileABIDefault() const { return false; }
+
+  /// UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the
+  /// mixed dispatch method be used?
+  virtual bool UseObjCMixedDispatch() const { return false; }
+
+  /// Check whether to enable x86 relax relocations by default.
+  virtual bool useRelaxRelocations() const;
+
+  /// GetDefaultStackProtectorLevel - Get the default stack protector level for
+  /// this tool chain (0=off, 1=on, 2=strong, 3=all).
+  virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
+    return 0;
+  }
+
+  /// Get the default trivial automatic variable initialization.
+  virtual LangOptions::TrivialAutoVarInitKind
+  GetDefaultTrivialAutoVarInit() const {
+    return LangOptions::TrivialAutoVarInitKind::Uninitialized;
+  }
+
+  /// GetDefaultLinker - Get the default linker to use.
+  virtual const char *getDefaultLinker() const { return "ld"; }
+
+  /// GetDefaultRuntimeLibType - Get the default runtime library variant to use.
+  virtual RuntimeLibType GetDefaultRuntimeLibType() const {
+    return ToolChain::RLT_Libgcc;
+  }
+
+  virtual CXXStdlibType GetDefaultCXXStdlibType() const {
+    return ToolChain::CST_Libstdcxx;
+  }
+
+  virtual std::string getCompilerRTPath() const;
+
+  virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
+                                    StringRef Component,
+                                    bool Shared = false) const;
+
+  const char *getCompilerRTArgString(const llvm::opt::ArgList &Args,
+                                     StringRef Component,
+                                     bool Shared = false) const;
+
+  // Returns <ResourceDir>/lib/<OSName>/<arch>.  This is used by runtimes (such
+  // as OpenMP) to find arch-specific libraries.
+  std::string getArchSpecificLibPath() const;
+
+  // Returns <OSname> part of above.
+  StringRef getOSLibName() const;
+
+  /// needsProfileRT - returns true if instrumentation profile is on.
+  static bool needsProfileRT(const llvm::opt::ArgList &Args);
+
+  /// Returns true if gcov instrumentation (-fprofile-arcs or --coverage) is on.
+  static bool needsGCovInstrumentation(const llvm::opt::ArgList &Args);
+
+  /// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
+  /// by default.
+  virtual bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const;
+
+  /// Test whether this toolchain defaults to PIC.
+  virtual bool isPICDefault() const = 0;
+
+  /// Test whether this toolchain defaults to PIE.
+  virtual bool isPIEDefault() const = 0;
+
+  /// Tests whether this toolchain forces its default for PIC, PIE or
+  /// non-PIC.  If this returns true, any PIC related flags should be ignored
+  /// and instead the results of \c isPICDefault() and \c isPIEDefault() are
+  /// used exclusively.
+  virtual bool isPICDefaultForced() const = 0;
+
+  /// SupportsProfiling - Does this tool chain support -pg.
+  virtual bool SupportsProfiling() const { return true; }
+
+  /// Complain if this tool chain doesn't support Objective-C ARC.
+  virtual void CheckObjCARC() const {}
+
+  /// Get the default debug info format. Typically, this is DWARF.
+  virtual codegenoptions::DebugInfoFormat getDefaultDebugFormat() const {
+    return codegenoptions::DIF_DWARF;
+  }
+
+  /// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf
+  /// compile unit information.
+  virtual bool UseDwarfDebugFlags() const { return false; }
+
+  // Return the DWARF version to emit, in the absence of arguments
+  // to the contrary.
+  virtual unsigned GetDefaultDwarfVersion() const { return 4; }
+
+  // True if the driver should assume "-fstandalone-debug"
+  // in the absence of an option specifying otherwise,
+  // provided that debugging was requested in the first place.
+  // i.e. a value of 'true' does not imply that debugging is wanted.
+  virtual bool GetDefaultStandaloneDebug() const { return false; }
+
+  // Return the default debugger "tuning."
+  virtual llvm::DebuggerKind getDefaultDebuggerTuning() const {
+    return llvm::DebuggerKind::GDB;
+  }
+
+  /// Does this toolchain supports given debug info option or not.
+  virtual bool supportsDebugInfoOption(const llvm::opt::Arg *) const {
+    return true;
+  }
+
+  /// Adjust debug information kind considering all passed options.
+  virtual void adjustDebugInfoKind(codegenoptions::DebugInfoKind &DebugInfoKind,
+                                   const llvm::opt::ArgList &Args) const {}
+
+  /// GetExceptionModel - Return the tool chain exception model.
+  virtual llvm::ExceptionHandling
+  GetExceptionModel(const llvm::opt::ArgList &Args) const;
+
+  /// SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
+  virtual bool SupportsEmbeddedBitcode() const { return false; }
+
+  /// getThreadModel() - Which thread model does this target use?
+  virtual std::string getThreadModel(const llvm::opt::ArgList &) const {
+    return "posix";
+  }
+
+  /// isThreadModelSupported() - Does this target support a thread model?
+  virtual bool isThreadModelSupported(const StringRef Model) const;
+
+  /// ComputeLLVMTriple - Return the LLVM target triple to use, after taking
+  /// command line arguments into account.
+  virtual std::string
+  ComputeLLVMTriple(const llvm::opt::ArgList &Args,
+                    types::ID InputType = types::TY_INVALID) const;
+
+  /// ComputeEffectiveClangTriple - Return the Clang triple to use for this
+  /// target, which may take into account the command line arguments. For
+  /// example, on Darwin the -mmacosx-version-min= command line argument (which
+  /// sets the deployment target) determines the version in the triple passed to
+  /// Clang.
+  virtual std::string ComputeEffectiveClangTriple(
+      const llvm::opt::ArgList &Args,
+      types::ID InputType = types::TY_INVALID) const;
+
+  /// getDefaultObjCRuntime - Return the default Objective-C runtime
+  /// for this platform.
+  ///
+  /// FIXME: this really belongs on some sort of DeploymentTarget abstraction
+  virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
+
+  /// hasBlocksRuntime - Given that the user is compiling with
+  /// -fblocks, does this tool chain guarantee the existence of a
+  /// blocks runtime?
+  ///
+  /// FIXME: this really belongs on some sort of DeploymentTarget abstraction
+  virtual bool hasBlocksRuntime() const { return true; }
+
+  /// Add the clang cc1 arguments for system include paths.
+  ///
+  /// This routine is responsible for adding the necessary cc1 arguments to
+  /// include headers from standard system header directories.
+  virtual void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &CC1Args) const;
+
+  /// Add options that need to be passed to cc1 for this target.
+  virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+                                     llvm::opt::ArgStringList &CC1Args,
+                                     Action::OffloadKind DeviceOffloadKind) const;
+
+  /// Add warning options that need to be passed to cc1 for this target.
+  virtual void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const;
+
+  // GetRuntimeLibType - Determine the runtime library type to use with the
+  // given compilation arguments.
+  virtual RuntimeLibType
+  GetRuntimeLibType(const llvm::opt::ArgList &Args) const;
+
+  // GetCXXStdlibType - Determine the C++ standard library type to use with the
+  // given compilation arguments.
+  virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
+
+  /// AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set
+  /// the include paths to use for the given C++ standard library type.
+  virtual void
+  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                               llvm::opt::ArgStringList &CC1Args) const;
+
+  /// Returns if the C++ standard library should be linked in.
+  /// Note that e.g. -lm should still be linked even if this returns false.
+  bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const;
+
+  /// AddCXXStdlibLibArgs - Add the system specific linker arguments to use
+  /// for the given C++ standard library type.
+  virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+                                   llvm::opt::ArgStringList &CmdArgs) const;
+
+  /// AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
+  void AddFilePathLibArgs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs) const;
+
+  /// AddCCKextLibArgs - Add the system specific linker arguments to use
+  /// for kernel extensions (Darwin-specific).
+  virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
+                                llvm::opt::ArgStringList &CmdArgs) const;
+
+  /// AddFastMathRuntimeIfAvailable - If a runtime library exists that sets
+  /// global flags for unsafe floating point math, add it and return true.
+  ///
+  /// This checks for presence of the -Ofast, -ffast-math or -funsafe-math flags.
+  virtual bool AddFastMathRuntimeIfAvailable(
+      const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const;
+
+  /// addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass
+  /// a suitable profile runtime library to the linker.
+  virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
+                                llvm::opt::ArgStringList &CmdArgs) const;
+
+  /// Add arguments to use system-specific CUDA includes.
+  virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                                  llvm::opt::ArgStringList &CC1Args) const;
+
+  /// Add arguments to use MCU GCC toolchain includes.
+  virtual void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                                   llvm::opt::ArgStringList &CC1Args) const;
+
+  /// On Windows, returns the MSVC compatibility version.
+  virtual VersionTuple computeMSVCVersion(const Driver *D,
+                                          const llvm::opt::ArgList &Args) const;
+
+  /// Return sanitizers which are available in this toolchain.
+  virtual SanitizerMask getSupportedSanitizers() const;
+
+  /// Return sanitizers which are enabled by default.
+  virtual SanitizerMask getDefaultSanitizers() const { return 0; }
+};
+
+/// Set a ToolChain's effective triple. Reset it when the registration object
+/// is destroyed.
+class RegisterEffectiveTriple {
+  const ToolChain &TC;
+
+public:
+  RegisterEffectiveTriple(const ToolChain &TC, llvm::Triple T) : TC(TC) {
+    TC.setEffectiveTriple(std::move(T));
+  }
+
+  ~RegisterEffectiveTriple() { TC.setEffectiveTriple(llvm::Triple()); }
+};
+
+} // namespace driver
+
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_TOOLCHAIN_H
diff --git a/clang-r353983e/include/clang/Driver/Types.def b/clang-r353983e/include/clang/Driver/Types.def
new file mode 100644
index 00000000..d2aaf58f
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Types.def
@@ -0,0 +1,104 @@
+//===--- Types.def - Driver Type info ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the driver type information. Users of this file
+// must define the TYPE macro to make use of this information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TYPE
+#error "Define TYPE prior to including this file!"
+#endif
+
+// TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS)
+
+// The first value is the type name as a string; for types which can
+// be user specified this should be the equivalent -x option.
+
+// The second value is the type id, which will result in a
+// clang::driver::types::TY_XX enum constant.
+
+// The third value is that id of the type for preprocessed inputs of
+// this type, or INVALID if this type is not preprocessed.
+
+// The fourth value is the suffix to use when creating temporary files
+// of this type, or null if unspecified.
+
+// The fifth value is a string containing option flags. Valid values:
+//  a - The type should only be assembled.
+//  p - The type should only be precompiled.
+//  u - The type can be user specified (with -x).
+//  m - Precompiling this type produces a module file.
+//  A - The type's temporary suffix should be appended when generating
+//      outputs of this type.
+
+
+// C family source language (with and without preprocessing).
+TYPE("cpp-output",               PP_C,         INVALID,         "i",     "u")
+TYPE("c",                        C,            PP_C,            "c",     "u")
+TYPE("cl",                       CL,           PP_C,            "cl",    "u")
+TYPE("cuda-cpp-output",          PP_CUDA,      INVALID,         "cui",   "u")
+TYPE("cuda",                     CUDA,         PP_CUDA,         "cu",    "u")
+TYPE("cuda",                     CUDA_DEVICE,  PP_CUDA,         "cu",    "")
+TYPE("hip-cpp-output",           PP_HIP,       INVALID,         "cui",   "u")
+TYPE("hip",                      HIP,          PP_HIP,          "cu",    "u")
+TYPE("hip",                      HIP_DEVICE,   PP_HIP,          "cu",    "")
+TYPE("objective-c-cpp-output",   PP_ObjC,      INVALID,         "mi",    "u")
+TYPE("objc-cpp-output",          PP_ObjC_Alias, INVALID,        "mi",    "u")
+TYPE("objective-c",              ObjC,         PP_ObjC,         "m",     "u")
+TYPE("c++-cpp-output",           PP_CXX,       INVALID,         "ii",    "u")
+TYPE("c++",                      CXX,          PP_CXX,          "cpp",   "u")
+TYPE("objective-c++-cpp-output", PP_ObjCXX,    INVALID,         "mii",   "u")
+TYPE("objc++-cpp-output",        PP_ObjCXX_Alias, INVALID,      "mii",   "u")
+TYPE("objective-c++",            ObjCXX,       PP_ObjCXX,       "mm",    "u")
+TYPE("renderscript",             RenderScript, PP_C,            "rs",    "u")
+
+// C family input files to precompile.
+TYPE("c-header-cpp-output",      PP_CHeader,   INVALID,         "i",     "p")
+TYPE("c-header",                 CHeader,      PP_CHeader,      "h",     "pu")
+TYPE("cl-header",                CLHeader,     PP_CHeader,      "h",     "pu")
+TYPE("objective-c-header-cpp-output", PP_ObjCHeader, INVALID,   "mi",    "p")
+TYPE("objective-c-header",       ObjCHeader,   PP_ObjCHeader,   "h",     "pu")
+TYPE("c++-header-cpp-output",    PP_CXXHeader, INVALID,         "ii",    "p")
+TYPE("c++-header",               CXXHeader,    PP_CXXHeader,    "hh",    "pu")
+TYPE("objective-c++-header-cpp-output", PP_ObjCXXHeader, INVALID, "mii", "p")
+TYPE("objective-c++-header",     ObjCXXHeader, PP_ObjCXXHeader, "h",     "pu")
+TYPE("c++-module",               CXXModule,    PP_CXXModule,    "cppm",  "mu")
+TYPE("c++-module-cpp-output",    PP_CXXModule, INVALID,         "iim",   "m")
+
+// Other languages.
+TYPE("ada",                      Ada,          INVALID,         nullptr, "u")
+TYPE("assembler",                PP_Asm,       INVALID,         "s",     "au")
+TYPE("assembler-with-cpp",       Asm,          PP_Asm,          "S",     "au")
+TYPE("f95",                      PP_Fortran,   INVALID,         nullptr, "u")
+TYPE("f95-cpp-input",            Fortran,      PP_Fortran,      nullptr, "u")
+TYPE("java",                     Java,         INVALID,         nullptr, "u")
+
+// LLVM IR/LTO types. We define separate types for IR and LTO because LTO
+// outputs should use the standard suffixes.
+TYPE("ir",                       LLVM_IR,      INVALID,         "ll",    "u")
+TYPE("ir",                       LLVM_BC,      INVALID,         "bc",    "u")
+TYPE("lto-ir",                   LTO_IR,       INVALID,         "s",     "")
+TYPE("lto-bc",                   LTO_BC,       INVALID,         "o",     "")
+
+// Misc.
+TYPE("ast",                      AST,          INVALID,         "ast",   "u")
+TYPE("pcm",                      ModuleFile,   INVALID,         "pcm",   "u")
+TYPE("plist",                    Plist,        INVALID,         "plist", "")
+TYPE("rewritten-objc",           RewrittenObjC,INVALID,         "cpp",   "")
+TYPE("rewritten-legacy-objc",    RewrittenLegacyObjC,INVALID,   "cpp",   "")
+TYPE("remap",                    Remap,        INVALID,         "remap", "")
+TYPE("precompiled-header",       PCH,          INVALID,         "gch",   "A")
+TYPE("object",                   Object,       INVALID,         "o",     "")
+TYPE("treelang",                 Treelang,     INVALID,         nullptr, "u")
+TYPE("image",                    Image,        INVALID,         "out",   "")
+TYPE("dSYM",                     dSYM,         INVALID,         "dSYM",  "A")
+TYPE("dependencies",             Dependencies, INVALID,         "d",     "")
+TYPE("cuda-fatbin",              CUDA_FATBIN,  INVALID,         "fatbin","A")
+TYPE("hip-fatbin",               HIP_FATBIN,   INVALID,         "hipfb", "A")
+TYPE("none",                     Nothing,      INVALID,         nullptr, "u")
diff --git a/clang-r353983e/include/clang/Driver/Types.h b/clang-r353983e/include/clang/Driver/Types.h
new file mode 100644
index 00000000..53afada7
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Types.h
@@ -0,0 +1,116 @@
+//===--- Types.h - Input & Temporary Driver Types ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_TYPES_H
+#define LLVM_CLANG_DRIVER_TYPES_H
+
+#include "clang/Driver/Phases.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace llvm {
+class StringRef;
+}
+namespace clang {
+namespace driver {
+namespace types {
+  enum ID {
+    TY_INVALID,
+#define TYPE(NAME, ID, PP_TYPE, TEMP_SUFFIX, FLAGS) TY_##ID,
+#include "clang/Driver/Types.def"
+#undef TYPE
+    TY_LAST
+  };
+
+  /// getTypeName - Return the name of the type for \p Id.
+  const char *getTypeName(ID Id);
+
+  /// getPreprocessedType - Get the ID of the type for this input when
+  /// it has been preprocessed, or INVALID if this input is not
+  /// preprocessed.
+  ID getPreprocessedType(ID Id);
+
+  /// getPrecompiledType - Get the ID of the type for this input when
+  /// it has been precompiled, or INVALID if this input is not
+  /// precompiled.
+  ID getPrecompiledType(ID Id);
+
+  /// getTypeTempSuffix - Return the suffix to use when creating a
+  /// temp file of this type, or null if unspecified.
+  const char *getTypeTempSuffix(ID Id, bool CLMode = false);
+
+  /// onlyAssembleType - Should this type only be assembled.
+  bool onlyAssembleType(ID Id);
+
+  /// onlyPrecompileType - Should this type only be precompiled.
+  bool onlyPrecompileType(ID Id);
+
+  /// canTypeBeUserSpecified - Can this type be specified on the
+  /// command line (by the type name); this is used when forwarding
+  /// commands to gcc.
+  bool canTypeBeUserSpecified(ID Id);
+
+  /// appendSuffixForType - When generating outputs of this type,
+  /// should the suffix be appended (instead of replacing the existing
+  /// suffix).
+  bool appendSuffixForType(ID Id);
+
+  /// canLipoType - Is this type acceptable as the output of a
+  /// universal build (currently, just the Nothing, Image, and Object
+  /// types).
+  bool canLipoType(ID Id);
+
+  /// isAcceptedByClang - Can clang handle this input type.
+  bool isAcceptedByClang(ID Id);
+
+  /// isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
+  bool isCXX(ID Id);
+
+  /// Is this LLVM IR.
+  bool isLLVMIR(ID Id);
+
+  /// isCuda - Is this a CUDA input.
+  bool isCuda(ID Id);
+
+  /// isHIP - Is this a HIP input.
+  bool isHIP(ID Id);
+
+  /// isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
+  bool isObjC(ID Id);
+
+  /// isSrcFile - Is this a source file, i.e. something that still has to be
+  /// preprocessed. The logic behind this is the same that decides if the first
+  /// compilation phase is a preprocessing one.
+  bool isSrcFile(ID Id);
+
+  /// lookupTypeForExtension - Lookup the type to use for the file
+  /// extension \p Ext.
+  ID lookupTypeForExtension(llvm::StringRef Ext);
+
+  /// lookupTypeForTypSpecifier - Lookup the type to use for a user
+  /// specified type name.
+  ID lookupTypeForTypeSpecifier(const char *Name);
+
+  /// getCompilationPhases - Get the list of compilation phases ('Phases') to be
+  /// done for type 'Id'.
+  void getCompilationPhases(
+    ID Id,
+    llvm::SmallVectorImpl<phases::ID> &Phases);
+
+  /// lookupCXXTypeForCType - Lookup CXX input type that corresponds to given
+  /// C type (used for clang++ emulation of g++ behaviour)
+  ID lookupCXXTypeForCType(ID Id);
+
+  /// Lookup header file input type that corresponds to given
+  /// source file type (used for clang-cl emulation of \Yc).
+  ID lookupHeaderTypeForSourceType(ID Id);
+
+} // end namespace types
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/Util.h b/clang-r353983e/include/clang/Driver/Util.h
new file mode 100644
index 00000000..67884209
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/Util.h
@@ -0,0 +1,31 @@
+//===--- Util.h - Common Driver Utilities -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_DRIVER_UTIL_H
+#define LLVM_CLANG_DRIVER_UTIL_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace clang {
+class DiagnosticsEngine;
+
+namespace driver {
+  class Action;
+  class JobAction;
+
+  /// ArgStringMap - Type used to map a JobAction to its result file.
+  typedef llvm::DenseMap<const JobAction*, const char*> ArgStringMap;
+
+  /// ActionList - Type used for lists of actions.
+  typedef SmallVector<Action*, 3> ActionList;
+
+} // end namespace driver
+} // end namespace clang
+
+#endif
diff --git a/clang-r353983e/include/clang/Driver/XRayArgs.h b/clang-r353983e/include/clang/Driver/XRayArgs.h
new file mode 100644
index 00000000..fa2583f4
--- /dev/null
+++ b/clang-r353983e/include/clang/Driver/XRayArgs.h
@@ -0,0 +1,48 @@
+//===--- XRayArgs.h - Arguments for XRay ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_DRIVER_XRAYARGS_H
+#define LLVM_CLANG_DRIVER_XRAYARGS_H
+
+#include "clang/Basic/XRayInstr.h"
+#include "clang/Driver/Types.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+
+namespace clang {
+namespace driver {
+
+class ToolChain;
+
+class XRayArgs {
+  std::vector<std::string> AlwaysInstrumentFiles;
+  std::vector<std::string> NeverInstrumentFiles;
+  std::vector<std::string> AttrListFiles;
+  std::vector<std::string> ExtraDeps;
+  std::vector<std::string> Modes;
+  XRayInstrSet InstrumentationBundle;
+  bool XRayInstrument = false;
+  int InstructionThreshold = 200;
+  bool XRayAlwaysEmitCustomEvents = false;
+  bool XRayAlwaysEmitTypedEvents = false;
+  bool XRayRT = true;
+
+public:
+  /// Parses the XRay arguments from an argument list.
+  XRayArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
+  void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
+               llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const;
+
+  bool needsXRayRt() const { return XRayInstrument && XRayRT; }
+  llvm::ArrayRef<std::string> modeList() const { return Modes; }
+  XRayInstrSet instrumentationBundle() const { return InstrumentationBundle; }
+};
+
+} // namespace driver
+} // namespace clang
+
+#endif // LLVM_CLANG_DRIVER_XRAYARGS_H