diff options
Diffstat (limited to 'contrib/llvm-project/clang/include')
21 files changed, 249 insertions, 94 deletions
diff --git a/contrib/llvm-project/clang/include/clang/AST/ASTContext.h b/contrib/llvm-project/clang/include/clang/AST/ASTContext.h index f39ce14bc82c..63c11e237d6c 100644 --- a/contrib/llvm-project/clang/include/clang/AST/ASTContext.h +++ b/contrib/llvm-project/clang/include/clang/AST/ASTContext.h @@ -653,6 +653,20 @@ public: /// Returns the clang bytecode interpreter context. interp::Context &getInterpContext(); + struct CUDAConstantEvalContext { + /// Do not allow wrong-sided variables in constant expressions. + bool NoWrongSidedVars = false; + } CUDAConstantEvalCtx; + struct CUDAConstantEvalContextRAII { + ASTContext &Ctx; + CUDAConstantEvalContext SavedCtx; + CUDAConstantEvalContextRAII(ASTContext &Ctx_, bool NoWrongSidedVars) + : Ctx(Ctx_), SavedCtx(Ctx_.CUDAConstantEvalCtx) { + Ctx_.CUDAConstantEvalCtx.NoWrongSidedVars = NoWrongSidedVars; + } + ~CUDAConstantEvalContextRAII() { Ctx.CUDAConstantEvalCtx = SavedCtx; } + }; + /// Returns the dynamic AST node parent map context. ParentMapContext &getParentMapContext(); @@ -2616,23 +2630,32 @@ public: /// template name uses the shortest form of the dependent /// nested-name-specifier, which itself contains all canonical /// types, values, and templates. - TemplateName getCanonicalTemplateName(TemplateName Name) const; + TemplateName getCanonicalTemplateName(const TemplateName &Name) const; /// Determine whether the given template names refer to the same /// template. - bool hasSameTemplateName(TemplateName X, TemplateName Y); + bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const; /// Determine whether the two declarations refer to the same entity. - bool isSameEntity(NamedDecl *X, NamedDecl *Y); + /// + /// FIXME: isSameEntity is not const due to its implementation calls + /// hasSameFunctionTypeIgnoringExceptionSpec which may alter this. + bool isSameEntity(const NamedDecl *X, const NamedDecl *Y); /// Determine whether two template parameter lists are similar enough /// that they may be used in declarations of the same template. - bool isSameTemplateParameterList(TemplateParameterList *X, - TemplateParameterList *Y); + /// + /// FIXME: isSameTemplateParameterList is not const since it calls + /// isSameTemplateParameter. + bool isSameTemplateParameterList(const TemplateParameterList *X, + const TemplateParameterList *Y); /// Determine whether two template parameters are similar enough /// that they may be used in declarations of the same template. - bool isSameTemplateParameter(NamedDecl *X, NamedDecl *Y); + /// + /// FIXME: isSameTemplateParameterList is not const since it calls + /// isSameEntity. + bool isSameTemplateParameter(const NamedDecl *X, const NamedDecl *Y); /// Retrieve the "canonical" template argument. /// diff --git a/contrib/llvm-project/clang/include/clang/Analysis/Analyses/Dominators.h b/contrib/llvm-project/clang/include/clang/Analysis/Analyses/Dominators.h index f588a5c7d1d7..9ac9cbe7d3ec 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/Analyses/Dominators.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/Analyses/Dominators.h @@ -193,7 +193,7 @@ namespace IDFCalculatorDetail { /// Specialize ChildrenGetterTy to skip nullpointer successors. template <bool IsPostDom> struct ChildrenGetterTy<clang::CFGBlock, IsPostDom> { - using NodeRef = typename GraphTraits<clang::CFGBlock>::NodeRef; + using NodeRef = typename GraphTraits<clang::CFGBlock *>::NodeRef; using ChildrenTy = SmallVector<NodeRef, 8>; ChildrenTy get(const NodeRef &N) { diff --git a/contrib/llvm-project/clang/include/clang/Analysis/CFG.h b/contrib/llvm-project/clang/include/clang/Analysis/CFG.h index c5512a7e1499..d8e7e1e43d81 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/CFG.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/CFG.h @@ -1494,9 +1494,6 @@ template <> struct GraphTraits< ::clang::CFGBlock *> { static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); } }; -template <> struct GraphTraits<clang::CFGBlock> - : GraphTraits<clang::CFGBlock *> {}; - template <> struct GraphTraits< const ::clang::CFGBlock *> { using NodeRef = const ::clang::CFGBlock *; using ChildIteratorType = ::clang::CFGBlock::const_succ_iterator; @@ -1506,9 +1503,6 @@ template <> struct GraphTraits< const ::clang::CFGBlock *> { static ChildIteratorType child_end(NodeRef N) { return N->succ_end(); } }; -template <> struct GraphTraits<const clang::CFGBlock> - : GraphTraits<clang::CFGBlock *> {}; - template <> struct GraphTraits<Inverse< ::clang::CFGBlock *>> { using NodeRef = ::clang::CFGBlock *; using ChildIteratorType = ::clang::CFGBlock::const_pred_iterator; @@ -1521,9 +1515,6 @@ template <> struct GraphTraits<Inverse< ::clang::CFGBlock *>> { static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); } }; -template <> struct GraphTraits<Inverse<clang::CFGBlock>> - : GraphTraits<clang::CFGBlock *> {}; - template <> struct GraphTraits<Inverse<const ::clang::CFGBlock *>> { using NodeRef = const ::clang::CFGBlock *; using ChildIteratorType = ::clang::CFGBlock::const_pred_iterator; @@ -1536,9 +1527,6 @@ template <> struct GraphTraits<Inverse<const ::clang::CFGBlock *>> { static ChildIteratorType child_end(NodeRef N) { return N->pred_end(); } }; -template <> struct GraphTraits<const Inverse<clang::CFGBlock>> - : GraphTraits<clang::CFGBlock *> {}; - // Traits for: CFG template <> struct GraphTraits< ::clang::CFG* > diff --git a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h index f327abe63751..b5a7c061e17b 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h @@ -27,6 +27,7 @@ #include "llvm/ADT/Any.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/Support/Error.h" namespace clang { namespace dataflow { @@ -106,18 +107,24 @@ template <typename LatticeT> struct DataflowAnalysisState { /// Performs dataflow analysis and returns a mapping from basic block IDs to /// dataflow analysis states that model the respective basic blocks. Indices -/// of the returned vector correspond to basic block IDs. +/// of the returned vector correspond to basic block IDs. Returns an error if +/// the dataflow analysis cannot be performed successfully. template <typename AnalysisT> -std::vector<llvm::Optional<DataflowAnalysisState<typename AnalysisT::Lattice>>> +llvm::Expected<std::vector< + llvm::Optional<DataflowAnalysisState<typename AnalysisT::Lattice>>>> runDataflowAnalysis(const ControlFlowContext &CFCtx, AnalysisT &Analysis, const Environment &InitEnv) { auto TypeErasedBlockStates = runTypeErasedDataflowAnalysis(CFCtx, Analysis, InitEnv); + if (!TypeErasedBlockStates) + return TypeErasedBlockStates.takeError(); + std::vector< llvm::Optional<DataflowAnalysisState<typename AnalysisT::Lattice>>> BlockStates; - BlockStates.reserve(TypeErasedBlockStates.size()); - llvm::transform(std::move(TypeErasedBlockStates), + BlockStates.reserve(TypeErasedBlockStates->size()); + + llvm::transform(std::move(*TypeErasedBlockStates), std::back_inserter(BlockStates), [](auto &OptState) { return std::move(OptState).map([](auto &&State) { return DataflowAnalysisState<typename AnalysisT::Lattice>{ diff --git a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h index e560305cf5ca..cebfb66ef242 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h @@ -51,19 +51,36 @@ enum class SkipPast { /// Holds the state of the program (store and heap) at a given program point. class Environment { public: - /// Supplements `Environment` with non-standard join operations. - class Merger { + /// Supplements `Environment` with non-standard comparison and join + /// operations. + class ValueModel { public: - virtual ~Merger() = default; + virtual ~ValueModel() = default; - /// Given distinct `Val1` and `Val2`, modifies `MergedVal` to approximate - /// both `Val1` and `Val2`. This could be a strict lattice join or a more - /// general widening operation. If this function returns true, `MergedVal` - /// will be assigned to a storage location of type `Type` in `Env`. + /// Returns true if and only if `Val1` is equivalent to `Val2`. /// /// Requirements: /// /// `Val1` and `Val2` must be distinct. + /// + /// `Val1` and `Val2` must model values of type `Type`. + virtual bool compareEquivalent(QualType Type, const Value &Val1, + const Value &Val2) { + // FIXME: Consider adding QualType to StructValue and removing the Type + // argument here. + return false; + } + + /// Modifies `MergedVal` to approximate both `Val1` and `Val2`. This could + /// be a strict lattice join or a more general widening operation. If this + /// function returns true, `MergedVal` will be assigned to a storage + /// location of type `Type` in `Env`. + /// + /// Requirements: + /// + /// `Val1` and `Val2` must be distinct. + /// + /// `Val1`, `Val2`, and `MergedVal` must model values of type `Type`. virtual bool merge(QualType Type, const Value &Val1, const Value &Val2, Value &MergedVal, Environment &Env) { return false; @@ -84,9 +101,29 @@ public: /// with a symbolic representation of the `this` pointee. Environment(DataflowAnalysisContext &DACtx, const DeclContext &DeclCtx); - bool operator==(const Environment &) const; - - LatticeJoinEffect join(const Environment &, Environment::Merger &); + /// Returns true if and only if the environment is equivalent to `Other`, i.e + /// the two environments: + /// - have the same mappings from declarations to storage locations, + /// - have the same mappings from expressions to storage locations, + /// - have the same or equivalent (according to `Model`) values assigned to + /// the same storage locations. + /// + /// Requirements: + /// + /// `Other` and `this` must use the same `DataflowAnalysisContext`. + bool equivalentTo(const Environment &Other, + Environment::ValueModel &Model) const; + + /// Joins the environment with `Other` by taking the intersection of storage + /// locations and values that are stored in them. Distinct values that are + /// assigned to the same storage locations in the environment and `Other` are + /// merged using `Model`. + /// + /// Requirements: + /// + /// `Other` and `this` must use the same `DataflowAnalysisContext`. + LatticeJoinEffect join(const Environment &Other, + Environment::ValueModel &Model); // FIXME: Rename `createOrGetStorageLocation` to `getOrCreateStorageLocation`, // `getStableStorageLocation`, or something more appropriate. diff --git a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/MapLattice.h b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/MapLattice.h index ff403f68b7c5..014cd60841ee 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/MapLattice.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/MapLattice.h @@ -112,7 +112,7 @@ template <typename Key, typename ElementLattice> std::ostream & operator<<(std::ostream &Os, const clang::dataflow::MapLattice<Key, ElementLattice> &M) { - std::string Separator = ""; + std::string Separator; Os << "{"; for (const auto &E : M) { Os << std::exchange(Separator, ", ") << E.first << " => " << E.second; @@ -125,7 +125,7 @@ template <typename ElementLattice> std::ostream & operator<<(std::ostream &Os, const clang::dataflow::VarMapLattice<ElementLattice> &M) { - std::string Separator = ""; + std::string Separator; Os << "{"; for (const auto &E : M) { Os << std::exchange(Separator, ", ") << E.first->getName().str() << " => " diff --git a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h index 9f44475b14ba..2d3a9e456370 100644 --- a/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h +++ b/contrib/llvm-project/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h @@ -25,6 +25,7 @@ #include "clang/Analysis/FlowSensitive/DataflowLattice.h" #include "llvm/ADT/Any.h" #include "llvm/ADT/Optional.h" +#include "llvm/Support/Error.h" namespace clang { namespace dataflow { @@ -40,7 +41,7 @@ struct TypeErasedLattice { }; /// Type-erased base class for dataflow analyses built on a single lattice type. -class TypeErasedDataflowAnalysis : public Environment::Merger { +class TypeErasedDataflowAnalysis : public Environment::ValueModel { /// Determines whether to apply the built-in transfer functions. // FIXME: Remove this option once the framework supports composing analyses // (at which point the built-in transfer functions can be simply a standalone @@ -115,8 +116,9 @@ TypeErasedDataflowAnalysisState transferBlock( /// Performs dataflow analysis and returns a mapping from basic block IDs to /// dataflow analysis states that model the respective basic blocks. Indices -/// of the returned vector correspond to basic block IDs. -std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>> +/// of the returned vector correspond to basic block IDs. Returns an error if +/// the dataflow analysis cannot be performed successfully. +llvm::Expected<std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>>> runTypeErasedDataflowAnalysis(const ControlFlowContext &CFCtx, TypeErasedDataflowAnalysis &Analysis, const Environment &InitEnv); diff --git a/contrib/llvm-project/clang/include/clang/Basic/AttrDocs.td b/contrib/llvm-project/clang/include/clang/Basic/AttrDocs.td index 18fac924b114..efd2af1ab1df 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/AttrDocs.td +++ b/contrib/llvm-project/clang/include/clang/Basic/AttrDocs.td @@ -432,45 +432,45 @@ implementation detail and not intended to be used by external users. The syntax of the attribute is as follows: -.. code-block:: c++ +.. code-block:: text - class __attribute__((sycl_special_class)) accessor {}; - class [[clang::sycl_special_class]] accessor {}; + class __attribute__((sycl_special_class)) accessor {}; + class [[clang::sycl_special_class]] accessor {}; This is a code example that illustrates the use of the attribute: .. code-block:: c++ - class __attribute__((sycl_special_class)) SpecialType { - int F1; - int F2; - void __init(int f1) { - F1 = f1; - F2 = f1; - } - void __finalize() {} - public: - SpecialType() = default; - int getF2() const { return F2; } - }; - - int main () { - SpecialType T; - cgh.single_task([=] { - T.getF2(); - }); -} + class __attribute__((sycl_special_class)) SpecialType { + int F1; + int F2; + void __init(int f1) { + F1 = f1; + F2 = f1; + } + void __finalize() {} + public: + SpecialType() = default; + int getF2() const { return F2; } + }; + + int main () { + SpecialType T; + cgh.single_task([=] { + T.getF2(); + }); + } This would trigger the following kernel entry point in the AST: .. code-block:: c++ - void __sycl_kernel(int f1) { - SpecialType T; - T.__init(f1); - ... - T.__finalize() - } + void __sycl_kernel(int f1) { + SpecialType T; + T.__init(f1); + ... + T.__finalize() + } }]; } diff --git a/contrib/llvm-project/clang/include/clang/Basic/BuiltinsAArch64.def b/contrib/llvm-project/clang/include/clang/Basic/BuiltinsAArch64.def index 634bcaed20a6..0869b87e32fb 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/BuiltinsAArch64.def +++ b/contrib/llvm-project/clang/include/clang/Basic/BuiltinsAArch64.def @@ -62,6 +62,9 @@ BUILTIN(__builtin_arm_ldg, "v*v*", "t") BUILTIN(__builtin_arm_stg, "vv*", "t") BUILTIN(__builtin_arm_subp, "Uiv*v*", "t") +// Memory Operations +BUILTIN(__builtin_arm_mops_memset_tag, "v*v*iz", "") + // Memory barrier BUILTIN(__builtin_arm_dmb, "vUi", "nc") BUILTIN(__builtin_arm_dsb, "vUi", "nc") diff --git a/contrib/llvm-project/clang/include/clang/Basic/CodeGenOptions.h b/contrib/llvm-project/clang/include/clang/Basic/CodeGenOptions.h index 5a5c2689c689..128ca2f5df3c 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/CodeGenOptions.h +++ b/contrib/llvm-project/clang/include/clang/Basic/CodeGenOptions.h @@ -276,6 +276,11 @@ public: /// CUDA runtime back-end for incorporating them into host-side object file. std::string CudaGpuBinaryFileName; + /// List of filenames and section name pairs passed in using the + /// -fembed-offload-object option to embed device-side offloading objects into + /// the host as a named section. Input passed in as '<filename>,<section>' + std::vector<std::string> OffloadObjects; + /// The name of the file to which the backend should save YAML optimization /// records. std::string OptRecordFile; diff --git a/contrib/llvm-project/clang/include/clang/Basic/DiagnosticCommonKinds.td b/contrib/llvm-project/clang/include/clang/Basic/DiagnosticCommonKinds.td index fe4ac5ed6cb0..5ea55b0fd31b 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/DiagnosticCommonKinds.td +++ b/contrib/llvm-project/clang/include/clang/Basic/DiagnosticCommonKinds.td @@ -145,6 +145,13 @@ def warn_conflicting_nullability_attr_overriding_param_types : Warning< def err_nullability_conflicting : Error< "nullability specifier %0 conflicts with existing specifier %1">; +def warn_target_unsupported_branch_protection_option: Warning < + "ignoring '-mbranch-protection=' option because the '%0' architecture does not support it">, + InGroup<BranchProtection>; + +def warn_target_unsupported_branch_protection_attribute: Warning < + "ignoring the 'branch-protection' attribute because the '%0' architecture does not support it">, + InGroup<BranchProtection>; } // OpenCL Section 6.8.g diff --git a/contrib/llvm-project/clang/include/clang/Basic/DiagnosticDriverKinds.td b/contrib/llvm-project/clang/include/clang/Basic/DiagnosticDriverKinds.td index e635be6b6d1b..3efedbe0f642 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/contrib/llvm-project/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -627,8 +627,10 @@ def err_cc1_unbounded_vscale_min : Error< def err_drv_ssp_missing_offset_argument : Error< "'%0' is used without '-mstack-protector-guard-offset', and there is no default">; -def err_drv_only_one_offload_target_supported_in : Error< - "Only one offload target is supported in %0.">; +def err_drv_only_one_offload_target_supported : Error< + "only one offload target is supported">; def err_drv_invalid_or_unsupported_offload_target : Error< - "Invalid or unsupported offload target: '%0'.">; + "invalid or unsupported offload target: '%0'">; +def err_drv_cuda_offload_only_emit_bc : Error< + "CUDA offload target is supported only along with --emit-llvm">; } diff --git a/contrib/llvm-project/clang/include/clang/Basic/LangOptions.h b/contrib/llvm-project/clang/include/clang/Basic/LangOptions.h index 09afa641acf9..50c7f038fc6b 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/LangOptions.h +++ b/contrib/llvm-project/clang/include/clang/Basic/LangOptions.h @@ -181,6 +181,10 @@ public: /// global-scope inline variables incorrectly. Ver12, + /// Attempt to be ABI-compatible with code generated by Clang 13.0.x. + /// This causes clang to not pack non-POD members of packed structs. + Ver13, + /// Conform to the underlying platform's C and C++ ABIs as closely /// as we can. Latest diff --git a/contrib/llvm-project/clang/include/clang/Basic/TargetInfo.h b/contrib/llvm-project/clang/include/clang/Basic/TargetInfo.h index 686a365b8c12..a49342a34f3e 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/TargetInfo.h +++ b/contrib/llvm-project/clang/include/clang/Basic/TargetInfo.h @@ -590,6 +590,17 @@ public: return false; } + // Different targets may support a different maximum width for the _BitInt + // type, depending on what operations are supported. + virtual size_t getMaxBitIntWidth() const { + // FIXME: this value should be llvm::IntegerType::MAX_INT_BITS, which is + // maximum bit width that LLVM claims its IR can support. However, most + // backends currently have a bug where they only support division + // operations on types that are <= 128 bits and crash otherwise. We're + // setting the max supported value to 128 to be conservative. + return 128; + } + /// Determine whether _Float16 is supported on this target. virtual bool hasLegalHalfType() const { return HasLegalHalfType; } @@ -1289,9 +1300,15 @@ public: bool BranchTargetEnforcement = false; }; + /// Determine if the Architecture in this TargetInfo supports branch + /// protection + virtual bool isBranchProtectionSupportedArch(StringRef Arch) const { + return false; + } + /// Determine if this TargetInfo supports the given branch protection /// specification - virtual bool validateBranchProtection(StringRef Spec, + virtual bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const { Err = ""; diff --git a/contrib/llvm-project/clang/include/clang/CodeGen/BackendUtil.h b/contrib/llvm-project/clang/include/clang/CodeGen/BackendUtil.h index 77d500079f01..d97af65a3d01 100644 --- a/contrib/llvm-project/clang/include/clang/CodeGen/BackendUtil.h +++ b/contrib/llvm-project/clang/include/clang/CodeGen/BackendUtil.h @@ -44,6 +44,9 @@ namespace clang { void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf); + + void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, + DiagnosticsEngine &Diags); } #endif diff --git a/contrib/llvm-project/clang/include/clang/Driver/Action.h b/contrib/llvm-project/clang/include/clang/Driver/Action.h index ba84d886a6cf..3b6c9e31faa3 100644 --- a/contrib/llvm-project/clang/include/clang/Driver/Action.h +++ b/contrib/llvm-project/clang/include/clang/Driver/Action.h @@ -73,6 +73,7 @@ public: OffloadBundlingJobClass, OffloadUnbundlingJobClass, OffloadWrapperJobClass, + LinkerWrapperJobClass, StaticLibJobClass, JobClassFirst = PreprocessJobClass, @@ -642,6 +643,17 @@ public: } }; +class LinkerWrapperJobAction : public JobAction { + void anchor() override; + +public: + LinkerWrapperJobAction(ActionList &Inputs, types::ID Type); + + static bool classof(const Action *A) { + return A->getKind() == LinkerWrapperJobClass; + } +}; + class StaticLibJobAction : public JobAction { void anchor() override; diff --git a/contrib/llvm-project/clang/include/clang/Driver/Driver.h b/contrib/llvm-project/clang/include/clang/Driver/Driver.h index 9ae34a2eaf01..93e1eca6a981 100644 --- a/contrib/llvm-project/clang/include/clang/Driver/Driver.h +++ b/contrib/llvm-project/clang/include/clang/Driver/Driver.h @@ -12,6 +12,7 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/LLVM.h" #include "clang/Driver/Action.h" +#include "clang/Driver/InputInfo.h" #include "clang/Driver/Options.h" #include "clang/Driver/Phases.h" #include "clang/Driver/ToolChain.h" @@ -38,13 +39,14 @@ namespace clang { namespace driver { - class Command; - class Compilation; - class InputInfo; - class JobList; - class JobAction; - class SanitizerArgs; - class ToolChain; +typedef SmallVector<InputInfo, 4> InputInfoList; + +class Command; +class Compilation; +class JobList; +class JobAction; +class SanitizerArgs; +class ToolChain; /// Describes the kind of LTO mode selected via -f(no-)?lto(=.*)? options. enum LTOKind { @@ -171,9 +173,11 @@ public: /// The file to log CC_LOG_DIAGNOSTICS output to, if enabled. std::string CCLogDiagnosticsFilename; + /// An input type and its arguments. + using InputTy = std::pair<types::ID, const llvm::opt::Arg *>; + /// A list of inputs and their types for the given arguments. - typedef SmallVector<std::pair<types::ID, const llvm::opt::Arg *>, 16> - InputList; + using InputList = SmallVector<InputTy, 16>; /// Whether the driver should follow g++ like behavior. bool CCCIsCXX() const { return Mode == GXXMode; } @@ -413,6 +417,18 @@ public: void BuildUniversalActions(Compilation &C, const ToolChain &TC, const InputList &BAInputs) const; + /// BuildOffloadingActions - Construct the list of actions to perform for the + /// offloading toolchain that will be embedded in the host. + /// + /// \param C - The compilation that is being built. + /// \param Args - The input arguments. + /// \param Input - The input type and arguments + /// \param HostAction - The host action used in the offloading toolchain. + Action *BuildOffloadingActions(Compilation &C, + llvm::opt::DerivedArgList &Args, + const InputTy &Input, + Action *HostAction) const; + /// Check that the file referenced by Value exists. If it doesn't, /// issue a diagnostic and return false. /// If TypoCorrect is true and the file does not exist, see if it looks @@ -503,13 +519,12 @@ public: /// 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; + InputInfoList 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>, InputInfoList> + &CachedResults, + Action::OffloadKind TargetDeviceOffloadKind) const; /// Returns the default name for linked images (e.g., "a.out"). const char *getDefaultImageName() const; @@ -617,10 +632,10 @@ private: /// 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( + InputInfoList 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> + std::map<std::pair<const Action *, std::string>, InputInfoList> &CachedResults, Action::OffloadKind TargetDeviceOffloadKind) const; diff --git a/contrib/llvm-project/clang/include/clang/Driver/Job.h b/contrib/llvm-project/clang/include/clang/Driver/Job.h index 6e3b51f2a799..ae9337f3c2d0 100644 --- a/contrib/llvm-project/clang/include/clang/Driver/Job.h +++ b/contrib/llvm-project/clang/include/clang/Driver/Job.h @@ -208,6 +208,8 @@ public: Arguments = std::move(List); } + void replaceExecutable(const char *Exe) { Executable = Exe; } + const char *getExecutable() const { return Executable; } const llvm::opt::ArgStringList &getArguments() const { return Arguments; } diff --git a/contrib/llvm-project/clang/include/clang/Driver/Options.td b/contrib/llvm-project/clang/include/clang/Driver/Options.td index b3de12e8c7b5..53e68ed2cef9 100644 --- a/contrib/llvm-project/clang/include/clang/Driver/Options.td +++ b/contrib/llvm-project/clang/include/clang/Driver/Options.td @@ -638,8 +638,8 @@ def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>, Flags<[NoXarchOption, CoreOption]>; def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>, Group<gfortran_Group>; def B : JoinedOrSeparate<["-"], "B">, MetaVarName<"<prefix>">, - HelpText<"Search $prefix/$triple-$file and $prefix$file for executables, libraries, " - "includes, and data files used by the compiler. $prefix may or may not be a directory">; + HelpText<"Search $prefix$file for executables, libraries, and data files. " + "If $prefix is a directory, search $prefix/$file">; def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[NoXarchOption]>, HelpText<"Search for GCC installation in the specified directory on targets which commonly use GCC. " "The directory usually contains 'lib{,32,64}/gcc{,-cross}/$triple' and 'include'. If specified, " @@ -1143,8 +1143,7 @@ defm autolink : BoolFOption<"autolink", // languages and accept other values such as CPU/GPU architectures, // offload kinds and target aliases. def offload_EQ : CommaJoined<["--"], "offload=">, Flags<[NoXarchOption]>, - HelpText<"Specify comma-separated list of offloading target triples" - " (HIP only)">; + HelpText<"Specify comma-separated list of offloading target triples (CUDA and HIP only)">; // C++ Coroutines TS defm coroutines_ts : BoolFOption<"coroutines-ts", @@ -1152,6 +1151,10 @@ defm coroutines_ts : BoolFOption<"coroutines-ts", PosFlag<SetTrue, [CC1Option], "Enable support for the C++ Coroutines TS">, NegFlag<SetFalse>>; +def fembed_offload_object_EQ : Joined<["-"], "fembed-offload-object=">, + Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, + HelpText<"Embed Offloading device-side binary into host object file as a section.">, + MarshallingInfoStringVector<CodeGenOpts<"OffloadObjects">>; def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">, Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">, HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">, @@ -1907,7 +1910,7 @@ defm legacy_pass_manager : BoolOption<"f", "legacy-pass-manager", def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">, Group<f_clang_Group>, Flags<[CC1Option]>, Alias<fno_legacy_pass_manager>; def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">, - Group<f_clang_Group>, Flags<[CC1Option]>, Alias<flegacy_pass_manager>; + Group<f_clang_Group>, Flags<[CC1Option,NoDriverOption]>, Alias<flegacy_pass_manager>; def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floating-point">, Group<f_clang_Group>, Flags<[CC1Option]>, HelpText<"Enables experimental strict floating point in LLVM.">, @@ -2473,6 +2476,8 @@ defm openmp_optimistic_collapse : BoolFOption<"openmp-optimistic-collapse", PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>, BothFlags<[NoArgumentUnused, HelpHidden]>>; def static_openmp: Flag<["-"], "static-openmp">, HelpText<"Use the static host OpenMP runtime while linking.">; +def fopenmp_new_driver : Flag<["-"], "fopenmp-new-driver">, Flags<[CC1Option]>, Group<Action_Group>, + HelpText<"Use the new driver for OpenMP offloading.">; def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>; def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>; defm escaping_block_tail_calls : BoolFOption<"escaping-block-tail-calls", @@ -3895,6 +3900,11 @@ def frtlib_add_rpath: Flag<["-"], "frtlib-add-rpath">, Flags<[NoArgumentUnused]> HelpText<"Add -rpath with architecture-specific resource directory to the linker flags">; def fno_rtlib_add_rpath: Flag<["-"], "fno-rtlib-add-rpath">, Flags<[NoArgumentUnused]>, HelpText<"Do not add -rpath with architecture-specific resource directory to the linker flags">; +defm openmp_implicit_rpath: BoolFOption<"openmp-implicit-rpath", + LangOpts<"OpenMP">, + DefaultTrue, + PosFlag<SetTrue, [], "Set rpath on OpenMP executables">, + NegFlag<SetFalse>>; def r : Flag<["-"], "r">, Flags<[LinkerInput,NoArgumentUnused]>, Group<Link_Group>; def save_temps_EQ : Joined<["-", "--"], "save-temps=">, Flags<[CC1Option, NoXarchOption]>, diff --git a/contrib/llvm-project/clang/include/clang/Driver/ToolChain.h b/contrib/llvm-project/clang/include/clang/Driver/ToolChain.h index 329833bb13be..bfc46af00265 100644 --- a/contrib/llvm-project/clang/include/clang/Driver/ToolChain.h +++ b/contrib/llvm-project/clang/include/clang/Driver/ToolChain.h @@ -151,6 +151,7 @@ private: mutable std::unique_ptr<Tool> IfsMerge; mutable std::unique_ptr<Tool> OffloadBundler; mutable std::unique_ptr<Tool> OffloadWrapper; + mutable std::unique_ptr<Tool> LinkerWrapper; Tool *getClang() const; Tool *getFlang() const; @@ -161,6 +162,7 @@ private: Tool *getClangAs() const; Tool *getOffloadBundler() const; Tool *getOffloadWrapper() const; + Tool *getLinkerWrapper() const; mutable bool SanitizerArgsChecked = false; mutable std::unique_ptr<XRayArgs> XRayArguments; @@ -711,6 +713,22 @@ public: const llvm::fltSemantics *FPType = nullptr) const { return llvm::DenormalMode::getIEEE(); } + + // We want to expand the shortened versions of the triples passed in to + // the values used for the bitcode libraries. + static llvm::Triple getOpenMPTriple(StringRef TripleStr) { + llvm::Triple TT(TripleStr); + if (TT.getVendor() == llvm::Triple::UnknownVendor || + TT.getOS() == llvm::Triple::UnknownOS) { + if (TT.getArch() == llvm::Triple::nvptx) + return llvm::Triple("nvptx-nvidia-cuda"); + if (TT.getArch() == llvm::Triple::nvptx64) + return llvm::Triple("nvptx64-nvidia-cuda"); + if (TT.getArch() == llvm::Triple::amdgcn) + return llvm::Triple("amdgcn-amd-amdhsa"); + } + return TT; + } }; /// Set a ToolChain's effective triple. Reset it when the registration object diff --git a/contrib/llvm-project/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td b/contrib/llvm-project/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td index bd21d7778f93..f037c33a1304 100644 --- a/contrib/llvm-project/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td +++ b/contrib/llvm-project/clang/include/clang/StaticAnalyzer/Checkers/Checkers.td @@ -552,7 +552,7 @@ def StdCLibraryFunctionArgsChecker : Checker<"StdCLibraryFunctionArgs">, "or is EOF.">, Dependencies<[StdCLibraryFunctionsChecker]>, WeakDependencies<[CallAndMessageChecker, NonNullParamChecker, StreamChecker]>, - Documentation<NotDocumented>; + Documentation<HasAlphaDocumentation>; } // end "alpha.unix" |