[TargetInfo][LangOpts] Refactor target info and language options adjustment.

[azabaznov]

Summary

• Function CreateTargetInfo() has an access to language options which makes target immutable after creation without modification of language options themselves. Target specific hook TargetInfo::adjustAccordingToLangOpts() can be used if such modification depends on certain target.

• Introduce LangOptions::adjustAccordingToTI() to apply changes to language options based on target info (also without modification of target info). This also involves adding of some hooks (hasAtomics() / hasAltivec() as this options are used in PPC and WebAssembly in original TargetInfo::adjust()) which potentially can be reused.

• Validation of OpenCL target is in CreateTargetInfo() as language options are available at that point.

[Anastasia]

Just to elaborate on the problem that is being solved. We have ended up with cycling dependencies between LangOptions and TargetInfo i.e. some language options became dependent on the target and vice versa.

The quick solution has always been to mutate the target after its creation even though it has been intended to be immutable. While mutating the target some language options are being modified too.

So the approach suggested here eliminates this design flaw by adding a special member to LangOptions to allow resetting the options after the target has been created based on the property of the target.

The approach seems reasonable to me and there are probably not so many good alternatives. In the past, we have discussed that adjusting target settings can be eliminated by adding a special triple component for OpenCL. However, it serves a similar purpose as suggested here but seems like a larger conceptual change and some redundancy too. I am also not sure whether it is going to fit the needs for OpenCL 3 features and also use cases from all other targets...

I would suggest writing an RFC into cfe-dev about this and see if there are any other opinions.

Thanks for looking into this long design issue.

clang/include/clang/Basic/LangOptions.h

 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 
+class DiagnosticsEngine;
+class TargetInfo;
+
 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
 /// this large collection of bitfields is a trivial class type.
 class LangOptionsBase {
   friend class CompilerInvocation;
 
 public:
   // Define simple language options (with no accessors).
 #define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
public:
   llvm::Optional<TargetCXXABI::Kind> CXXABI;
 
   /// Indicates whether the front-end is explicitly told that the
   /// input is a header file (i.e. -x c-header).
   bool IsHeaderFile = false;
 
   LangOptions();
 
+  /// Inform language options about target capabilities.
+  void adjustAccordingToTI(DiagnosticsEngine &Diags, const TargetInfo &TI);
+
   // Define accessors/mutators for language options of enumeration type.
 #define LANGOPT(Name, Bits, Default, Description)
 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
   Type get##Name() const { return static_cast<Type>(Name); } \
   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
 #include "clang/Basic/LangOptions.def"
 
   /// Are we compiling a module interface (.cppm or module map)?

clang/include/clang/Basic/TargetInfo.h

protected:
   void resetDataLayout(StringRef DL, const char *UserLabelPrefix = "");
 
 public:
   /// Construct a target for the given options.
   ///
   /// \param Opts - The options to use to initialize the target. The target may
   /// modify the options to canonicalize the target feature information to match
   /// what the backend expects.
+  /// \param LangOpts - Language options to adjust target information with.
   static TargetInfo *
   CreateTargetInfo(DiagnosticsEngine &Diags,
-                   const std::shared_ptr<TargetOptions> &Opts);
+                   const std::shared_ptr<TargetOptions> &Opts,
+                   const LangOptions &LangOpts);
 
   virtual ~TargetInfo();
 
   /// Retrieve the target options.
   TargetOptions &getTargetOpts() const {
     assert(TargetOpts && "Missing target options");
     return *TargetOpts;
   }
public:
   virtual bool hasBuiltinAtomic(uint64_t AtomicSizeInBits,
                                 uint64_t AlignmentInBits) const {
     return AtomicSizeInBits <= AlignmentInBits &&
            AtomicSizeInBits <= getMaxAtomicInlineWidth() &&
            (AtomicSizeInBits <= getCharWidth() ||
             llvm::isPowerOf2_64(AtomicSizeInBits / getCharWidth()));
   }
 
+  virtual bool hasAtomics() const { return false; }
+
+  virtual bool hasAltivec() const { return false; }
+
   /// Return the maximum vector alignment supported for the given target.
   unsigned getMaxVectorAlign() const { return MaxVectorAlign; }
   /// Return default simd alignment for the given target. Generally, this
   /// value is type-specific, but this alignment can be used for most of the
   /// types for the given target.
   unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; }
 
   unsigned getMaxOpenCLWorkGroupSize() const { return MaxOpenCLWorkGroupSize; }
public:
   virtual bool hasPS4DLLImportExport() const {
     return getTriple().isPS4CPU() ||
            // Windows Itanium support allows for testing the SCEI flavour of
            // dllimport/export handling on a Windows system.
            (getTriple().isWindowsItaniumEnvironment() &&
             getTriple().getVendor() == llvm::Triple::SCEI);
   }
 
-  /// Set forced language options.
-  ///
-  /// Apply changes to the target information with respect to certain
-  /// language options which change the target configuration and adjust
-  /// the language based on the target options where applicable.
-  virtual void adjust(DiagnosticsEngine &Diags, LangOptions &Opts);
-
   /// Adjust target options based on codegen options.
   virtual void adjustTargetOptions(const CodeGenOptions &CGOpts,
                                    TargetOptions &TargetOpts) const {}
 
   /// Initialize the map with the default set of target features for the
   /// CPU this should include all legal feature strings on the target.
   ///
   /// \return False on error (invalid features).
const llvm::VersionTuple &getSDKVersion() const {
     return getTargetOpts().SDKVersion;
   }
 
   /// Check the target is valid after it is fully initialized.
   virtual bool validateTarget(DiagnosticsEngine &Diags) const {
     return true;
   }
 
-  /// Check that OpenCL target has valid options setting based on OpenCL
-  /// version.
-  virtual bool validateOpenCLTarget(const LangOptions &Opts,
-                                    DiagnosticsEngine &Diags) const;
-
   virtual void setAuxTarget(const TargetInfo *Aux) {}
 
   /// Whether target allows debuginfo types for decl only variables/functions.
   virtual bool allowDebugInfoForExternalRef() const { return false; }
 
 protected:
   /// Copy type and layout related info.
   void copyAuxTarget(const TargetInfo *Aux);
   virtual uint64_t getPointerWidthV(unsigned AddrSpace) const {
     return PointerWidth;
   }
   virtual uint64_t getPointerAlignV(unsigned AddrSpace) const {
     return PointerAlign;
   }
   virtual enum IntType getPtrDiffTypeV(unsigned AddrSpace) const {
     return PtrDiffType;
   }
   virtual ArrayRef<const char *> getGCCRegNames() const = 0;
   virtual ArrayRef<GCCRegAlias> getGCCRegAliases() const = 0;
   virtual ArrayRef<AddlRegName> getGCCAddlRegNames() const {
     return None;
   }
 
- private:
+  /// Apply changes to the target information with respect to certain
+  /// language options.
+  virtual void adjustAccordingToLangOpts(const LangOptions &Opts);
+
+  /// Check that OpenCL target has valid options setting based on OpenCL
+  /// version.
+  virtual bool validateOpenCLTarget(const LangOptions &Opts,
+                                    DiagnosticsEngine &Diags) const;
+
   // Assert the values for the fractional and integral bits for each fixed point
   // type follow the restrictions given in clause 6.2.6.3 of N1169.
   void CheckFixedPointBits() const;
 };
 
 }  // end namespace clang
 
 #endif

clang/lib/Basic/LangOptions.cpp

 //===- LangOptions.cpp - C Language Family Language Options ---------------===//
 //
 // 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 LangOptions class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 
 using namespace clang;
 
 LangOptions::LangOptions() : LangStd(LangStandard::lang_unspecified) {
 #define LANGOPT(Name, Bits, Default, Description) Name = Default;
 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) set##Name(Default);

 }
 
 void LangOptions::remapPathPrefix(SmallString<256> &Path) const {
   for (const auto &Entry : MacroPrefixMap)
     if (llvm::sys::path::replace_path_prefix(Path, Entry.first, Entry.second))
       break;
 }
 
+void LangOptions::adjustAccordingToTI(DiagnosticsEngine &Diags,
+                                      const TargetInfo &TI) {
+  if (OpenCL) {
+    // OpenCL C v3.0 s6.7.5 - The generic address space requires support for
+    // OpenCL C 2.0 or OpenCL C 3.0 with the __opencl_c_generic_address_space
+    // feature
+    // OpenCL C v3.0 s6.2.1 - OpenCL pipes require support of OpenCL C 2.0
+    // or later and __opencl_c_pipes feature
+    // FIXME: These language options are also defined in setLangDefaults()
+    // for OpenCL C 2.0 but with no access to target capabilities. Target
+    // should be immutable once created and thus these language options need
+    // to be defined only once.
+    if (getOpenCLCompatibleVersion() == 300) {
+      const auto &OpenCLFeaturesMap = TI.getSupportedOpenCLOpts();
+      OpenCLGenericAddressSpace = TI.hasFeatureEnabled(
+          OpenCLFeaturesMap, "__opencl_c_generic_address_space");
+      OpenCLPipes = TI.hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_pipes");
+    }
+  }
+
+  if (ProtectParens && !TI.checkArithmeticFenceSupported()) {
+    Diags.Report(diag::err_opt_not_valid_on_target) << "-fprotect-parens";
+    ProtectParens = false;
+  }
+
+  if (TI.getTriple().isWasm() && !TI.hasAtomics()) {
+    // If the Atomics feature isn't available, turn off POSIXThreads and
+    // ThreadModel, so that we don't predefine _REENTRANT or __STDCPP_THREADS__.
+    POSIXThreads = false;
+    setThreadModel(LangOptions::ThreadModelKind::Single);
+  } else if (TI.getTriple().isPPC()) {
+    if (TI.hasAltivec())
+      AltiVec = 1;
+    IEEE128 = 1;
+  }
+}
+
 std::string LangOptions::getOpenCLVersionString() const {
   std::string Result;
   {
     llvm::raw_string_ostream Out(Result);
     Out << (OpenCLCPlusPlus ? "C++ for OpenCL" : "OpenCL C") << " version "
         << getOpenCLVersionTuple().getAsString();
   }
   return Result;

clang/lib/Basic/TargetInfo.cpp

bool TargetInfo::isTypeSigned(IntType T) {
   case UnsignedShort:
   case UnsignedInt:
   case UnsignedLong:
   case UnsignedLongLong:
     return false;
   };
 }
 
-/// adjust - Set forced language options.
-/// Apply changes to the target information with respect to certain
-/// language options which change the target configuration and adjust
-/// the language based on the target options where applicable.
-void TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
+/// adjustAccordingToLanguageOptions - Apply changes to the target
+/// information with respect to certain language options.
+void TargetInfo::adjustAccordingToLangOpts(const LangOptions &Opts) {
   if (Opts.NoBitFieldTypeAlign)
     UseBitFieldTypeAlignment = false;
 
   switch (Opts.WCharSize) {
   default: llvm_unreachable("invalid wchar_t width");
   case 0: break;
   case 1: WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar; break;
   case 2: WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort; break;
if (Opts.OpenCL) {
     IntPtrType = Is32BitArch ? SignedInt : SignedLong;
 
     IntMaxType = SignedLongLong;
     Int64Type = SignedLong;
 
     HalfFormat = &llvm::APFloat::IEEEhalf();
     FloatFormat = &llvm::APFloat::IEEEsingle();
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
-
-    // OpenCL C v3.0 s6.7.5 - The generic address space requires support for
-    // OpenCL C 2.0 or OpenCL C 3.0 with the __opencl_c_generic_address_space
-    // feature
-    // OpenCL C v3.0 s6.2.1 - OpenCL pipes require support of OpenCL C 2.0
-    // or later and __opencl_c_pipes feature
-    // FIXME: These language options are also defined in setLangDefaults()
-    // for OpenCL C 2.0 but with no access to target capabilities. Target
-    // should be immutable once created and thus these language options need
-    // to be defined only once.
-    if (Opts.getOpenCLCompatibleVersion() == 300) {
-      const auto &OpenCLFeaturesMap = getSupportedOpenCLOpts();
-      Opts.OpenCLGenericAddressSpace = hasFeatureEnabled(
-          OpenCLFeaturesMap, "__opencl_c_generic_address_space");
-      Opts.OpenCLPipes =
-          hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_pipes");
-    }
   }
 
   if (Opts.DoubleSize) {
     if (Opts.DoubleSize == 32) {
       DoubleWidth = 32;
       LongDoubleWidth = 32;
       DoubleFormat = &llvm::APFloat::IEEEsingle();
       LongDoubleFormat = &llvm::APFloat::IEEEsingle();
void TargetInfo::adjustAccordingToLangOpts(const LangOptions &Opts) {
 
   if (Opts.NewAlignOverride)
     NewAlign = Opts.NewAlignOverride * getCharWidth();
 
   // Each unsigned fixed point type has the same number of fractional bits as
   // its corresponding signed type.
   PaddingOnUnsignedFixedPoint |= Opts.PaddingOnUnsignedFixedPoint;
   CheckFixedPointBits();
-
-  if (Opts.ProtectParens && !checkArithmeticFenceSupported()) {
-    Diags.Report(diag::err_opt_not_valid_on_target) << "-fprotect-parens";
-    Opts.ProtectParens = false;
-  }
 }
 
 bool TargetInfo::initFeatureMap(
     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
     const std::vector<std::string> &FeatureVec) const {
   for (const auto &F : FeatureVec) {
     StringRef Name = F;
     // Apply the feature via the target.

clang/lib/Basic/Targets.cpp

 } // namespace targets
 } // namespace clang
 
 using namespace clang::targets;
 /// CreateTargetInfo - Return the target info object for the specified target
 /// options.
 TargetInfo *
 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
-                             const std::shared_ptr<TargetOptions> &Opts) {
+                             const std::shared_ptr<TargetOptions> &Opts,
+                             const LangOptions &LangOpts) {
   llvm::Triple Triple(Opts->Triple);
 
   // Construct the target
   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
   if (!Target) {
     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
     return nullptr;
   }
TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
 
   if (!Target->handleTargetFeatures(Opts->Features, Diags))
     return nullptr;
 
   Target->setSupportedOpenCLOpts();
   Target->setCommandLineOpenCLOpts();
   Target->setMaxAtomicWidth();
 
-  if (!Target->validateTarget(Diags))
+  Target->adjustAccordingToLangOpts(LangOpts);
+
+  if (!Target->validateTarget(Diags) ||
+      (LangOpts.OpenCL && !Target->validateOpenCLTarget(LangOpts, Diags)))
     return nullptr;
 
   Target->CheckFixedPointBits();
 
   return Target.release();
 }
 /// validateOpenCLTarget  - Check that OpenCL target has valid
 /// options setting based on OpenCL version.

clang/lib/Basic/Targets/AMDGPU.h

static bool isR600(const llvm::Triple &TT) {
     return TT.getArch() == llvm::Triple::r600;
   }
 
 public:
   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 
   void setAddressSpaceMap(bool DefaultIsPrivate);
 
-  void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override;
+  void adjustAccordingToLangOpts(const LangOptions &Opts) override;
 
   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
     if (isR600(getTriple()))
       return 32;
 
     if (AddrSpace == Private || AddrSpace == Local)
       return 32;
 

clang/lib/Basic/Targets/AMDGPU.cpp

if (getMaxPointerWidth() == 64) {
     SizeType = UnsignedLong;
     PtrDiffType = SignedLong;
     IntPtrType = SignedLong;
   }
 
   MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
 }
 
-void AMDGPUTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
-  TargetInfo::adjust(Diags, Opts);
+void AMDGPUTargetInfo::adjustAccordingToLangOpts(const LangOptions &Opts) {
+  TargetInfo::adjustAccordingToLangOpts(Opts);
   // ToDo: There are still a few places using default address space as private
   // address space in OpenCL, which needs to be cleaned up, then Opts.OpenCL
   // can be removed from the following line.
   setAddressSpaceMap(/*DefaultIsPrivate=*/Opts.OpenCL ||
                      !isAMDGCN(getTriple()));
 }
 
 ArrayRef<Builtin::Info> AMDGPUTargetInfo::getTargetBuiltins() const {

clang/lib/Basic/Targets/PPC.h

PPCTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
     SuitableAlign = 128;
     SimdDefaultAlign = 128;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
     HasStrictFP = true;
     HasIbm128 = true;
   }
 
-  // Set the language option for altivec based on our value.
-  void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override;
+  void adjustAccordingToLangOpts(const LangOptions &Opts) override;
 
   // Note: GCC recognizes the following additional cpus:
   //  401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
   //  821, 823, 8540, e300c2, e300c3, e500mc64, e6500, 860, cell, titan, rs64.
   bool isValidCPUName(StringRef Name) const override;
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
 
   bool setCPU(const std::string &Name) override {
public:
   const char *getFloat128Mangling() const override { return "u9__ieee128"; }
   const char *getIbm128Mangling() const override { return "g"; }
 
   bool hasExtIntType() const override { return true; }
 
   bool isSPRegName(StringRef RegName) const override {
     return RegName.equals("r1") || RegName.equals("x1");
   }
+
+  bool hasAltivec() const override { return HasAltivec; }
 };
 
 class LLVM_LIBRARY_VISIBILITY PPC32TargetInfo : public PPCTargetInfo {
 public:
   PPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : PPCTargetInfo(Triple, Opts) {
     if (Triple.isOSAIX())
       resetDataLayout("E-m:a-p:32:32-i64:64-n32");

clang/lib/Basic/Targets/PPC.cpp

 bool PPCTargetInfo::isValidCPUName(StringRef Name) const {
   return llvm::find(ValidCPUNames, Name) != std::end(ValidCPUNames);
 }
 
 void PPCTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
   Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
 }
 
-void PPCTargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
-  if (HasAltivec)
-    Opts.AltiVec = 1;
-  TargetInfo::adjust(Diags, Opts);
+void PPCTargetInfo::adjustAccordingToLangOpts(const LangOptions &Opts) {
+  TargetInfo::adjustAccordingToLangOpts(Opts);
   if (LongDoubleFormat != &llvm::APFloat::IEEEdouble())
     LongDoubleFormat = Opts.PPCIEEELongDouble
                            ? &llvm::APFloat::IEEEquad()
                            : &llvm::APFloat::PPCDoubleDouble();
-  Opts.IEEE128 = 1;
 }
 
 ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const {
   return llvm::makeArrayRef(BuiltinInfo, clang::PPC::LastTSBuiltin -
                                              Builtin::FirstTSBuiltin);
 }

clang/lib/Basic/Targets/SPIR.h

public:
   CallingConv getDefaultCallingConv() const override {
     return CC_SpirFunction;
   }
 
   void setAddressSpaceMap(bool DefaultIsGeneric) {
     AddrSpaceMap = DefaultIsGeneric ? &SPIRDefIsGenMap : &SPIRDefIsPrivMap;
   }
 
-  void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override {
-    TargetInfo::adjust(Diags, Opts);
+  void adjustAccordingToLangOpts(const LangOptions &Opts) override {
+    TargetInfo::adjustAccordingToLangOpts(Opts);
     // FIXME: SYCL specification considers unannotated pointers and references
     // to be pointing to the generic address space. See section 5.9.3 of
     // SYCL 2020 specification.
     // Currently, there is no way of representing SYCL's default address space
     // language semantic along with the semantics of embedded C's default
     // address space in the same address space map. Hence the map needs to be
     // reset to allow mapping to the desired value of 'Default' entry for SYCL.
     setAddressSpaceMap(/*DefaultIsGeneric=*/Opts.SYCLIsDevice);

clang/lib/Basic/Targets/WebAssembly.h

default:
       return CCCR_Warning;
     }
   }
 
   bool hasExtIntType() const override { return true; }
 
   bool hasProtectedVisibility() const override { return false; }
 
-  void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override;
+  bool hasAtomics() const override { return HasAtomics; }
 };
 
 class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo
     : public WebAssemblyTargetInfo {
 public:
   explicit WebAssembly32TargetInfo(const llvm::Triple &T,
                                    const TargetOptions &Opts)
       : WebAssemblyTargetInfo(T, Opts) {

clang/lib/Basic/Targets/WebAssembly.cpp

bool WebAssemblyTargetInfo::handleTargetFeatures(
   return true;
 }
 
 ArrayRef<Builtin::Info> WebAssemblyTargetInfo::getTargetBuiltins() const {
   return llvm::makeArrayRef(BuiltinInfo, clang::WebAssembly::LastTSBuiltin -
                                              Builtin::FirstTSBuiltin);
 }
 
-void WebAssemblyTargetInfo::adjust(DiagnosticsEngine &Diags,
-                                   LangOptions &Opts) {
-  // If the Atomics feature isn't available, turn off POSIXThreads and
-  // ThreadModel, so that we don't predefine _REENTRANT or __STDCPP_THREADS__.
-  if (!HasAtomics) {
-    Opts.POSIXThreads = false;
-    Opts.setThreadModel(LangOptions::ThreadModelKind::Single);
-  }
-}
-
 void WebAssembly32TargetInfo::getTargetDefines(const LangOptions &Opts,
                                                MacroBuilder &Builder) const {
   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
   defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
 }
 
 void WebAssembly64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                                MacroBuilder &Builder) const {
   WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
   defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
 }

clang/lib/Frontend/ASTUnit.cpp

public:
 
   bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
                          bool AllowCompatibleDifferences) override {
     // If we've already initialized the target, don't do it again.
     if (Target)
       return false;
 
     this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts);
-    Target =
-        TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts,
+                                          LangOpt);
 
     updated();
     return false;
   }
 
   void ReadCounter(const serialization::ModuleFile &M,
                    unsigned Value) override {
     Counter = Value;
   }
 
 private:
   void updated() {
     if (!Target || !InitializedLanguage)
       return;
 
-    // Inform the target of the language options.
-    //
-    // FIXME: We shouldn't need to do this, the target should be immutable once
-    // created. This complexity should be lifted elsewhere.
-    Target->adjust(PP.getDiagnostics(), LangOpt);
+    LangOpt.adjustAccordingToTI(PP.getDiagnostics(), *Target);
 
     // Initialize the preprocessor.
     PP.Initialize(*Target);
 
     if (!Context)
       return;
 
     // Initialize the ASTContext

clang/lib/Frontend/ChainedIncludesSource.cpp

for (unsigned i = 0, e = includes.size(); i != e; ++i) {
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
         new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient));
 
     std::unique_ptr<CompilerInstance> Clang(
         new CompilerInstance(CI.getPCHContainerOperations()));
     Clang->setInvocation(std::move(CInvok));
     Clang->setDiagnostics(Diags.get());
     Clang->setTarget(TargetInfo::CreateTargetInfo(
-        Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
+        Clang->getDiagnostics(), Clang->getInvocation().TargetOpts,
+        Clang->getLangOpts()));
     Clang->createFileManager();
     Clang->createSourceManager(Clang->getFileManager());
     Clang->createPreprocessor(TU_Prefix);
     Clang->getDiagnosticClient().BeginSourceFile(Clang->getLangOpts(),
                                                  &Clang->getPreprocessor());
     Clang->createASTContext();
 
     auto Buffer = std::make_shared<PCHBuffer>();

clang/lib/Frontend/CompilerInstance.cpp

void CompilerInstance::setVerboseOutputStream(std::unique_ptr<raw_ostream> Value) {
   VerboseOutputStream = OwnedVerboseOutputStream.get();
 }
 
 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
 
 bool CompilerInstance::createTarget() {
   // Create the target instance.
-  setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
-                                         getInvocation().TargetOpts));
+  setTarget(TargetInfo::CreateTargetInfo(
+      getDiagnostics(), getInvocation().TargetOpts, getLangOpts()));
   if (!hasTarget())
     return false;
 
   // Check whether AuxTarget exists, if not, then create TargetInfo for the
   // other side of CUDA/OpenMP/SYCL compilation.
   if (!getAuxTarget() &&
       (getLangOpts().CUDA || getLangOpts().OpenMPIsDevice ||
        getLangOpts().SYCLIsDevice) &&
       !getFrontendOpts().AuxTriple.empty()) {
     auto TO = std::make_shared<TargetOptions>();
     TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
     if (getFrontendOpts().AuxTargetCPU)
       TO->CPU = getFrontendOpts().AuxTargetCPU.getValue();
     if (getFrontendOpts().AuxTargetFeatures)
       TO->FeaturesAsWritten = getFrontendOpts().AuxTargetFeatures.getValue();
     TO->HostTriple = getTarget().getTriple().str();
-    setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
+    setAuxTarget(
+        TargetInfo::CreateTargetInfo(getDiagnostics(), TO, getLangOpts()));
   }
 
   if (!getTarget().hasStrictFP() && !getLangOpts().ExpStrictFP) {
     if (getLangOpts().getFPRoundingMode() !=
         llvm::RoundingMode::NearestTiesToEven) {
       getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_rounding);
       getLangOpts().setFPRoundingMode(llvm::RoundingMode::NearestTiesToEven);
     }
     if (getLangOpts().getFPExceptionMode() != LangOptions::FPE_Ignore) {
       getDiagnostics().Report(diag::warn_fe_backend_unsupported_fp_exceptions);
       getLangOpts().setFPExceptionMode(LangOptions::FPE_Ignore);
     }
     // FIXME: can we disable FEnvAccess?
   }
 
-  // We should do it here because target knows nothing about
-  // language options when it's being created.
-  if (getLangOpts().OpenCL &&
-      !getTarget().validateOpenCLTarget(getLangOpts(), getDiagnostics()))
-    return false;
-
-  // Inform the target of the language options.
-  // FIXME: We shouldn't need to do this, the target should be immutable once
-  // created. This complexity should be lifted elsewhere.
-  getTarget().adjust(getDiagnostics(), getLangOpts());
+  getLangOpts().adjustAccordingToTI(getDiagnostics(), getTarget());
 
   // Adjust target options based on codegen options.
   getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
 
   if (auto *Aux = getAuxTarget())
     getTarget().setAuxTarget(Aux);
 
   return true;
void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
   HeaderSearch *HeaderInfo =
       new HeaderSearch(getHeaderSearchOptsPtr(), getSourceManager(),
                        getDiagnostics(), getLangOpts(), &getTarget());
   PP = std::make_shared<Preprocessor>(Invocation->getPreprocessorOptsPtr(),
                                       getDiagnostics(), getLangOpts(),
                                       getSourceManager(), *HeaderInfo, *this,
                                       /*IdentifierInfoLookup=*/nullptr,
                                       /*OwnsHeaderSearch=*/true, TUKind);
-  getTarget().adjust(getDiagnostics(), getLangOpts());
+  getLangOpts().adjustAccordingToTI(getDiagnostics(), getTarget());
   PP->Initialize(getTarget(), getAuxTarget());
 
   if (PPOpts.DetailedRecord)
     PP->createPreprocessingRecord();
 
   // Apply remappings to the source manager.
   InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
                           PP->getFileManager(), PPOpts);

clang/lib/Interpreter/Interpreter.cpp

return llvm::createStringError(std::errc::state_not_recoverable,
                                    "Initialization failed. "
                                    "Unable to flush diagnostics");
 
   // FIXME: Merge with CompilerInstance::ExecuteAction.
   llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release();
   Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB);
 
   Clang->setTarget(TargetInfo::CreateTargetInfo(
-      Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
+      Clang->getDiagnostics(), Clang->getInvocation().TargetOpts,
+      Clang->getLangOpts()));
   if (!Clang->hasTarget())
     return llvm::createStringError(std::errc::state_not_recoverable,
                                    "Initialization failed. "
                                    "Target is missing");
 
-  Clang->getTarget().adjust(Clang->getDiagnostics(), Clang->getLangOpts());
+  Clang->getLangOpts().adjustAccordingToTI(Clang->getDiagnostics(),
+                                           Clang->getTarget());
 
   return std::move(Clang);
 }
 
 } // anonymous namespace
 
 llvm::Expected<std::unique_ptr<CompilerInstance>>
 IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) {

clang/tools/clang-import-test/clang-import-test.cpp

std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
   Inv->getLangOpts()->CXXExceptions = true;
   // Needed for testing dynamic_cast.
   Inv->getLangOpts()->RTTI = true;
   Inv->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
   Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
 
   Ins->setInvocation(std::move(Inv));
 
-  TargetInfo *TI = TargetInfo::CreateTargetInfo(
-      Ins->getDiagnostics(), Ins->getInvocation().TargetOpts);
+  TargetInfo *TI = TargetInfo::CreateTargetInfo(Ins->getDiagnostics(),
+                                                Ins->getInvocation().TargetOpts,
+                                                *Ins->getInvocation().LangOpts);
   Ins->setTarget(TI);
-  Ins->getTarget().adjust(Ins->getDiagnostics(), Ins->getLangOpts());
+  Ins->getLangOpts().adjustAccordingToTI(Ins->getDiagnostics(),
+                                         Ins->getTarget());
   Ins->createFileManager();
   Ins->createSourceManager(Ins->getFileManager());
   Ins->createPreprocessor(TU_Complete);
 
   return Ins;
 }
 
 std::unique_ptr<ASTContext>

clang/unittests/Analysis/MacroExpansionContextTest.cpp

 protected:
   MacroExpansionContextTest()
       : InMemoryFileSystem(new llvm::vfs::InMemoryFileSystem),
         FileMgr(FileSystemOptions(), InMemoryFileSystem),
         DiagID(new DiagnosticIDs()), DiagOpts(new DiagnosticOptions()),
         Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
     TargetOpts->Triple = "x86_64-pc-linux-unknown";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
     LangOpts.CPlusPlus20 = 1; // For __VA_OPT__
   }
 
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   DiagnosticsEngine Diags;

clang/unittests/Basic/SourceManagerTest.cpp

 protected:
   SourceManagerTest()
     : FileMgr(FileMgrOpts),
       DiagID(new DiagnosticIDs()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
   }
 
   FileSystemOptions FileMgrOpts;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   LangOptions LangOpts;

clang/unittests/CodeGen/TestCompiler.h

TestCompiler(clang::LangOptions LO,
     std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
     llvm::Triple Tr(TrStr);
     Tr.setOS(Triple::Linux);
     Tr.setVendor(Triple::VendorType::UnknownVendor);
     Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);
     compiler.getTargetOpts().Triple = Tr.getTriple();
     compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
         compiler.getDiagnostics(),
-        std::make_shared<clang::TargetOptions>(compiler.getTargetOpts())));
+        std::make_shared<clang::TargetOptions>(compiler.getTargetOpts()),
+        compiler.getLangOpts()));
 
     const clang::TargetInfo &TInfo = compiler.getTarget();
     PtrSize = TInfo.getPointerWidth(0) / 8;
 
     compiler.createFileManager();
     compiler.createSourceManager(compiler.getFileManager());
     compiler.createPreprocessor(clang::TU_Prefix);
 

clang/unittests/Lex/HeaderSearchTest.cpp

protected:
   HeaderSearchTest()
       : VFS(new llvm::vfs::InMemoryFileSystem), FileMgr(FileMgrOpts, VFS),
         DiagID(new DiagnosticIDs()),
         Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions),
         Search(std::make_shared<HeaderSearchOptions>(), SourceMgr, Diags,
                LangOpts, Target.get()) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
   }
 
   void addSearchDir(llvm::StringRef Dir) {
     VFS->addFile(Dir, 0, llvm::MemoryBuffer::getMemBuffer(""), /*User=*/None,
                  /*Group=*/None, llvm::sys::fs::file_type::directory_file);
     auto DE = FileMgr.getOptionalDirectoryRef(Dir);
     assert(DE);
     auto DL = DirectoryLookup(*DE, SrcMgr::C_User, /*isFramework=*/false);

clang/unittests/Lex/LexerTest.cpp

protected:
   LexerTest()
     : FileMgr(FileMgrOpts),
       DiagID(new DiagnosticIDs()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions)
   {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
   }
 
   std::unique_ptr<Preprocessor> CreatePP(StringRef Source,
                                          TrivialModuleLoader &ModLoader) {
     std::unique_ptr<llvm::MemoryBuffer> Buf =
         llvm::MemoryBuffer::getMemBuffer(Source);
     SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
 

clang/unittests/Lex/PPCallbacksTest.cpp

 protected:
   PPCallbacksTest()
       : InMemoryFileSystem(new llvm::vfs::InMemoryFileSystem),
         FileMgr(FileSystemOptions(), InMemoryFileSystem),
         DiagID(new DiagnosticIDs()), DiagOpts(new DiagnosticOptions()),
         Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
   }
 
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;

clang/unittests/Lex/PPConditionalDirectiveRecordTest.cpp

protected:
   PPConditionalDirectiveRecordTest()
     : FileMgr(FileMgrOpts),
       DiagID(new DiagnosticIDs()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions)
   {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
-    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts, LangOpts);
   }
 
   FileSystemOptions FileMgrOpts;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   LangOptions LangOpts;