diff options
Diffstat (limited to 'include/clang/Basic')
72 files changed, 5523 insertions, 2856 deletions
diff --git a/include/clang/Basic/AlignedAllocation.h b/include/clang/Basic/AlignedAllocation.h index 9751f4118447..c995f47a7d74 100644 --- a/include/clang/Basic/AlignedAllocation.h +++ b/include/clang/Basic/AlignedAllocation.h @@ -27,8 +27,8 @@ inline llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS) { default: break; case llvm::Triple::Darwin: - case llvm::Triple::MacOSX: // Earliest supporting version is 10.13. - return llvm::VersionTuple(10U, 13U); + case llvm::Triple::MacOSX: // Earliest supporting version is 10.14. + return llvm::VersionTuple(10U, 14U); case llvm::Triple::IOS: case llvm::Triple::TvOS: // Earliest supporting version is 11.0.0. return llvm::VersionTuple(11U); diff --git a/include/clang/Basic/AllDiagnostics.h b/include/clang/Basic/AllDiagnostics.h index afec2d7e0f2f..6c7f95658970 100644 --- a/include/clang/Basic/AllDiagnostics.h +++ b/include/clang/Basic/AllDiagnostics.h @@ -15,17 +15,17 @@ #ifndef LLVM_CLANG_BASIC_ALLDIAGNOSTICS_H #define LLVM_CLANG_BASIC_ALLDIAGNOSTICS_H -#include "clang/AST/ASTDiagnostic.h" -#include "clang/AST/CommentDiagnostic.h" -#include "clang/Analysis/AnalysisDiagnostic.h" -#include "clang/CrossTU/CrossTUDiagnostic.h" -#include "clang/Driver/DriverDiagnostic.h" -#include "clang/Frontend/FrontendDiagnostic.h" -#include "clang/Lex/LexDiagnostic.h" -#include "clang/Parse/ParseDiagnostic.h" -#include "clang/Sema/SemaDiagnostic.h" -#include "clang/Serialization/SerializationDiagnostic.h" -#include "clang/Tooling/Refactoring/RefactoringDiagnostic.h" +#include "clang/Basic/DiagnosticAST.h" +#include "clang/Basic/DiagnosticAnalysis.h" +#include "clang/Basic/DiagnosticComment.h" +#include "clang/Basic/DiagnosticCrossTU.h" +#include "clang/Basic/DiagnosticDriver.h" +#include "clang/Basic/DiagnosticFrontend.h" +#include "clang/Basic/DiagnosticLex.h" +#include "clang/Basic/DiagnosticParse.h" +#include "clang/Basic/DiagnosticSema.h" +#include "clang/Basic/DiagnosticSerialization.h" +#include "clang/Basic/DiagnosticRefactoring.h" namespace clang { template <size_t SizeOfStr, typename FieldType> diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index fea8e129d7da..1fe1dd39948a 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -90,6 +90,15 @@ def NonBitField : SubsetSubject<Field, [{!S->isBitField()}], "non-bit-field non-static data members">; +def NonStaticCXXMethod : SubsetSubject<CXXMethod, + [{!S->isStatic()}], + "non-static member functions">; + +def NonStaticNonConstCXXMethod + : SubsetSubject<CXXMethod, + [{!S->isStatic() && !S->isConst()}], + "non-static non-const member functions">; + def ObjCInstanceMethod : SubsetSubject<ObjCMethod, [{S->isInstanceMethod()}], "Objective-C instance methods">; @@ -145,8 +154,9 @@ def HasFunctionProto : SubsetSubject<DeclBase, // function. Accepted as a function type attribute on the type of such a // member function. // FIXME: This does not actually ever match currently. -def ImplicitObjectParameter : SubsetSubject<Function, [{false}], - "implicit object parameters">; +def ImplicitObjectParameter + : SubsetSubject<Function, [{static_cast<void>(S), false}], + "implicit object parameters">; // A single argument to an attribute class Argument<string name, bit optional, bit fake = 0> { @@ -288,8 +298,9 @@ def COnly : LangOpt<"CPlusPlus", 1>; def CPlusPlus : LangOpt<"CPlusPlus">; def OpenCL : LangOpt<"OpenCL">; def RenderScript : LangOpt<"RenderScript">; -def ObjC : LangOpt<"ObjC1">; +def ObjC : LangOpt<"ObjC">; def BlocksSupported : LangOpt<"Blocks">; +def ObjCAutoRefCount : LangOpt<"ObjCAutoRefCount">; // Defines targets for target-specific attributes. Empty lists are unchecked. class TargetSpec { @@ -467,13 +478,12 @@ class Attr { // in a class template definition. bit MeaningfulToClassTemplateDefinition = 0; // Set to true if this attribute can be used with '#pragma clang attribute'. - // By default, when this value is false, an attribute is supported by the - // '#pragma clang attribute' only when: - // - It has documentation. + // By default, an attribute is supported by the '#pragma clang attribute' + // only when: // - It has a subject list whose subjects can be represented using subject // match rules. // - It has GNU/CXX11 spelling and doesn't require delayed parsing. - bit ForcePragmaAttributeSupport = 0; + bit PragmaAttributeSupport; // Lists language options, one of which is required to be true for the // attribute to be applicable. If empty, no language options are required. list<LangOpt> LangOpts = []; @@ -488,10 +498,7 @@ class Attr { } /// A type attribute is not processed on a declaration or a statement. -class TypeAttr : Attr { - // By default, type attributes do not get an AST node. - let ASTNode = 0; -} +class TypeAttr : Attr; /// A stmt attribute is not processed on a declaration or a type. class StmtAttr : Attr; @@ -657,6 +664,7 @@ def AnalyzerNoReturn : InheritableAttr { // vendor namespace, or should it use a vendor namespace specific to the // analyzer? let Spellings = [GNU<"analyzer_noreturn">]; + // TODO: Add subject list. let Documentation = [Undocumented]; } @@ -665,7 +673,7 @@ def Annotate : InheritableParamAttr { let Args = [StringArgument<"Annotation">]; // Ensure that the annotate attribute can be used with // '#pragma clang attribute' even though it has no subject list. - let ForcePragmaAttributeSupport = 1; + let PragmaAttributeSupport = 1; let Documentation = [Undocumented]; } @@ -720,6 +728,7 @@ def Availability : InheritableAttr { .Case("macos_app_extension", "macOS (App Extension)") .Case("tvos_app_extension", "tvOS (App Extension)") .Case("watchos_app_extension", "watchOS (App Extension)") + .Case("swift", "Swift") .Default(llvm::StringRef()); } static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { @@ -808,19 +817,56 @@ def CFUnknownTransfer : InheritableAttr { def CFReturnsRetained : InheritableAttr { let Spellings = [Clang<"cf_returns_retained">]; // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def CFReturnsNotRetained : InheritableAttr { let Spellings = [Clang<"cf_returns_not_retained">]; // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def CFConsumed : InheritableParamAttr { let Spellings = [Clang<"cf_consumed">]; let Subjects = SubjectList<[ParmVar]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; +} + +// OSObject-based attributes. +def OSConsumed : InheritableParamAttr { + let Spellings = [Clang<"os_consumed">]; + let Subjects = SubjectList<[ParmVar]>; + let Documentation = [RetainBehaviorDocs]; +} + +def OSReturnsRetained : InheritableAttr { + let Spellings = [Clang<"os_returns_retained">]; + let Subjects = SubjectList<[Function, ObjCMethod, ObjCProperty, ParmVar]>; + let Documentation = [RetainBehaviorDocs]; +} + +def OSReturnsNotRetained : InheritableAttr { + let Spellings = [Clang<"os_returns_not_retained">]; + let Subjects = SubjectList<[Function, ObjCMethod, ObjCProperty, ParmVar]>; + let Documentation = [RetainBehaviorDocs]; +} + +def OSReturnsRetainedOnZero : InheritableAttr { + let Spellings = [Clang<"os_returns_retained_on_zero">]; + let Subjects = SubjectList<[ParmVar]>; + let Documentation = [RetainBehaviorDocs]; +} + +def OSReturnsRetainedOnNonZero : InheritableAttr { + let Spellings = [Clang<"os_returns_retained_on_non_zero">]; + let Subjects = SubjectList<[ParmVar]>; + let Documentation = [RetainBehaviorDocs]; +} + +def OSConsumesThis : InheritableAttr { + let Spellings = [Clang<"os_consumes_this">]; + let Subjects = SubjectList<[NonStaticCXXMethod]>; + let Documentation = [RetainBehaviorDocs]; } def Cleanup : InheritableAttr { @@ -855,21 +901,19 @@ def Constructor : InheritableAttr { } def CPUSpecific : InheritableAttr { - let Spellings = [Clang<"cpu_specific">]; + let Spellings = [Clang<"cpu_specific">, Declspec<"cpu_specific">]; let Args = [VariadicIdentifierArgument<"Cpus">]; let Subjects = SubjectList<[Function]>; let Documentation = [CPUSpecificCPUDispatchDocs]; let AdditionalMembers = [{ - unsigned ActiveArgIndex = 0; - - IdentifierInfo *getCurCPUName() const { - return *(cpus_begin() + ActiveArgIndex); + IdentifierInfo *getCPUName(unsigned Index) const { + return *(cpus_begin() + Index); } }]; } def CPUDispatch : InheritableAttr { - let Spellings = [Clang<"cpu_dispatch">]; + let Spellings = [Clang<"cpu_dispatch">, Declspec<"cpu_dispatch">]; let Args = [VariadicIdentifierArgument<"Cpus">]; let Subjects = SubjectList<[Function]>; let Documentation = [CPUSpecificCPUDispatchDocs]; @@ -1089,10 +1133,14 @@ def EnableIf : InheritableAttr { def ExtVectorType : Attr { // This is an OpenCL-related attribute and does not receive a [[]] spelling. let Spellings = [GNU<"ext_vector_type">]; + // FIXME: This subject list is wrong; this is a type attribute. let Subjects = SubjectList<[TypedefName], ErrorDiag>; let Args = [ExprArgument<"NumElements">]; let ASTNode = 0; let Documentation = [Undocumented]; + // This is a type attribute with an incorrect subject list, so should not be + // permitted by #pragma clang attribute. + let PragmaAttributeSupport = 0; } def FallThrough : StmtAttr { @@ -1165,7 +1213,7 @@ def FormatArg : InheritableAttr { def GNUInline : InheritableAttr { let Spellings = [GCC<"gnu_inline">]; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [GnuInlineDocs]; } def Hot : InheritableAttr { @@ -1218,7 +1266,7 @@ def LayoutVersion : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> { let Documentation = [LayoutVersionDocs]; } -def LifetimeBound : InheritableAttr { +def LifetimeBound : DeclOrTypeAttr { let Spellings = [Clang<"lifetimebound", 0>]; let Subjects = SubjectList<[ParmVar, ImplicitObjectParameter], ErrorDiag>; let Documentation = [LifetimeBoundDocs]; @@ -1309,6 +1357,9 @@ def Mode : Attr { let Subjects = SubjectList<[Var, Enum, TypedefName, Field], ErrorDiag>; let Args = [IdentifierArgument<"Mode">]; let Documentation = [Undocumented]; + // This is notionally a type attribute, which #pragma clang attribute + // generally does not support. + let PragmaAttributeSupport = 0; } def Naked : InheritableAttr { @@ -1321,12 +1372,16 @@ def NeonPolyVectorType : TypeAttr { let Spellings = [Clang<"neon_polyvector_type">]; let Args = [IntArgument<"NumElements">]; let Documentation = [Undocumented]; + // Represented as VectorType instead. + let ASTNode = 0; } def NeonVectorType : TypeAttr { let Spellings = [Clang<"neon_vector_type">]; let Args = [IntArgument<"NumElements">]; let Documentation = [Undocumented]; + // Represented as VectorType instead. + let ASTNode = 0; } def ReturnsTwice : InheritableAttr { @@ -1501,6 +1556,14 @@ def TypeNullUnspecified : TypeAttr { let Documentation = [TypeNullUnspecifiedDocs]; } +// This is a marker used to indicate that an __unsafe_unretained qualifier was +// ignored because ARC is not enabled. The usual representation for this +// qualifier is as an ObjCOwnership attribute with Kind == "none". +def ObjCInertUnsafeUnretained : TypeAttr { + let Spellings = [Keyword<"__unsafe_unretained">]; + let Documentation = [Undocumented]; +} + def ObjCKindOf : TypeAttr { let Spellings = [Keyword<"__kindof">]; let Documentation = [Undocumented]; @@ -1588,34 +1651,34 @@ def ObjCBridgeRelated : InheritableAttr { let Documentation = [Undocumented]; } -def NSReturnsRetained : InheritableAttr { +def NSReturnsRetained : DeclOrTypeAttr { let Spellings = [Clang<"ns_returns_retained">]; // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def NSReturnsNotRetained : InheritableAttr { let Spellings = [Clang<"ns_returns_not_retained">]; // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def NSReturnsAutoreleased : InheritableAttr { let Spellings = [Clang<"ns_returns_autoreleased">]; // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def NSConsumesSelf : InheritableAttr { let Spellings = [Clang<"ns_consumes_self">]; let Subjects = SubjectList<[ObjCMethod]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def NSConsumed : InheritableParamAttr { let Spellings = [Clang<"ns_consumed">]; let Subjects = SubjectList<[ParmVar]>; - let Documentation = [Undocumented]; + let Documentation = [RetainBehaviorDocs]; } def ObjCException : InheritableAttr { @@ -1764,6 +1827,11 @@ def Pcs : DeclOrTypeAttr { let Documentation = [PcsDocs]; } +def AArch64VectorPcs: DeclOrTypeAttr { + let Spellings = [Clang<"aarch64_vector_pcs">]; + let Documentation = [AArch64VectorPcsDocs]; +} + def Pure : InheritableAttr { let Spellings = [GCC<"pure">]; let Documentation = [Undocumented]; @@ -1773,6 +1841,13 @@ def Regparm : TypeAttr { let Spellings = [GCC<"regparm">]; let Args = [UnsignedArgument<"NumParams">]; let Documentation = [RegparmDocs]; + // Represented as part of the enclosing function type. + let ASTNode = 0; +} + +def NoDeref : TypeAttr { + let Spellings = [Clang<"noderef">]; + let Documentation = [NoDerefDocs]; } def ReqdWorkGroupSize : InheritableAttr { @@ -1953,6 +2028,39 @@ def Target : InheritableAttr { return parse(getFeaturesStr()); } + StringRef getArchitecture() const { + StringRef Features = getFeaturesStr(); + if (Features == "default") return {}; + + SmallVector<StringRef, 1> AttrFeatures; + Features.split(AttrFeatures, ","); + + for (auto &Feature : AttrFeatures) { + Feature = Feature.trim(); + if (Feature.startswith("arch=")) + return Feature.drop_front(sizeof("arch=") - 1); + } + return ""; + } + + // Gets the list of features as simple string-refs with no +/- or 'no-'. + // Only adds the items to 'Out' that are additions. + void getAddedFeatures(llvm::SmallVectorImpl<StringRef> &Out) const { + StringRef Features = getFeaturesStr(); + if (Features == "default") return; + + SmallVector<StringRef, 1> AttrFeatures; + Features.split(AttrFeatures, ","); + + for (auto &Feature : AttrFeatures) { + Feature = Feature.trim(); + + if (!Feature.startswith("no-") && !Feature.startswith("arch=") && + !Feature.startswith("fpmath=") && !Feature.startswith("tune=")) + Out.push_back(Feature); + } + } + template<class Compare> ParsedTargetAttr parse(Compare cmp) const { ParsedTargetAttr Attrs = parse(); @@ -2061,10 +2169,9 @@ def ObjCGC : TypeAttr { let Documentation = [Undocumented]; } -def ObjCOwnership : InheritableAttr { +def ObjCOwnership : DeclOrTypeAttr { let Spellings = [Clang<"objc_ownership">]; let Args = [IdentifierArgument<"Kind">]; - let ASTNode = 0; let Documentation = [Undocumented]; } @@ -2102,6 +2209,8 @@ def VectorSize : TypeAttr { let Spellings = [GCC<"vector_size">]; let Args = [ExprArgument<"NumBytes">]; let Documentation = [Undocumented]; + // Represented as VectorType instead. + let ASTNode = 0; } def VecTypeHint : InheritableAttr { @@ -2196,7 +2305,7 @@ def AnyX86NoCallerSavedRegisters : InheritableAttr, let Documentation = [AnyX86NoCallerSavedRegistersDocs]; } -def AnyX86NoCfCheck : InheritableAttr, TargetSpecificAttr<TargetAnyX86>{ +def AnyX86NoCfCheck : DeclOrTypeAttr, TargetSpecificAttr<TargetAnyX86>{ let Spellings = [GCC<"nocf_check">]; let Subjects = SubjectList<[FunctionLike]>; let Documentation = [AnyX86NoCfCheckDocs]; @@ -2625,6 +2734,17 @@ def DLLExport : InheritableAttr, TargetSpecificAttr<TargetWindows> { let Documentation = [DLLExportDocs]; } +def DLLExportStaticLocal : InheritableAttr, TargetSpecificAttr<TargetWindows> { + // This attribute is used internally only when -fno-dllexport-inlines is + // passed. This attribute is added to inline function of class having + // dllexport attribute. And if the function has static local variables, this + // attribute is used to whether the variables are exported or not. Also if + // function has local static variables, the function is dllexported too. + let Spellings = []; + let Subjects = SubjectList<[Function]>; + let Documentation = [Undocumented]; +} + def DLLImport : InheritableAttr, TargetSpecificAttr<TargetWindows> { let Spellings = [Declspec<"dllimport">, GCC<"dllimport">]; let Subjects = SubjectList<[Function, Var, CXXRecord, ObjCInterface]>; @@ -2641,6 +2761,16 @@ public: }]; } +def DLLImportStaticLocal : InheritableAttr, TargetSpecificAttr<TargetWindows> { + // This attribute is used internally only when -fno-dllexport-inlines is + // passed. This attribute is added to inline function of class having + // dllimport attribute. And if the function has static local variables, this + // attribute is used to whether the variables are imported or not. + let Spellings = []; + let Subjects = SubjectList<[Function]>; + let Documentation = [Undocumented]; +} + def SelectAny : InheritableAttr { let Spellings = [Declspec<"selectany">, GCC<"selectany">]; let Documentation = [SelectAnyDocs]; @@ -2748,7 +2878,11 @@ def LoopHint : Attr { /// interleave_count: interleaves 'Value' loop iterations. /// unroll: fully unroll loop if State == Enable. /// unroll_count: unrolls loop 'Value' times. - /// distribute: attempt to distribute loop if State == Enable + /// unroll_and_jam: attempt to unroll and jam loop if State == Enable. + /// unroll_and_jam_count: unroll and jams loop 'Value' times. + /// distribute: attempt to distribute loop if State == Enable. + /// pipeline: disable pipelining loop if State == Disable. + /// pipeline_initiation_interval: create loop schedule with initiation interval equal to 'Value'. /// #pragma unroll <argument> directive /// <no arg>: fully unrolls loop. @@ -2756,14 +2890,17 @@ def LoopHint : Attr { /// expression: unrolls loop 'Value' times. let Spellings = [Pragma<"clang", "loop">, Pragma<"", "unroll">, - Pragma<"", "nounroll">]; + Pragma<"", "nounroll">, Pragma<"", "unroll_and_jam">, + Pragma<"", "nounroll_and_jam">]; /// State of the loop optimization specified by the spelling. let Args = [EnumArgument<"Option", "OptionType", ["vectorize", "vectorize_width", "interleave", "interleave_count", - "unroll", "unroll_count", "distribute"], + "unroll", "unroll_count", "unroll_and_jam", "unroll_and_jam_count", + "pipeline", "pipeline_initiation_interval", "distribute"], ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount", - "Unroll", "UnrollCount", "Distribute"]>, + "Unroll", "UnrollCount", "UnrollAndJam", "UnrollAndJamCount", + "PipelineDisabled", "PipelineInitiationInterval", "Distribute"]>, EnumArgument<"State", "LoopHintState", ["enable", "disable", "numeric", "assume_safety", "full"], ["Enable", "Disable", "Numeric", "AssumeSafety", "Full"]>, @@ -2778,6 +2915,10 @@ def LoopHint : Attr { case InterleaveCount: return "interleave_count"; case Unroll: return "unroll"; case UnrollCount: return "unroll_count"; + case UnrollAndJam: return "unroll_and_jam"; + case UnrollAndJamCount: return "unroll_and_jam_count"; + case PipelineDisabled: return "pipeline"; + case PipelineInitiationInterval: return "pipeline_initiation_interval"; case Distribute: return "distribute"; } llvm_unreachable("Unhandled LoopHint option."); @@ -2787,9 +2928,9 @@ def LoopHint : Attr { unsigned SpellingIndex = getSpellingListIndex(); // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or // "nounroll" is already emitted as the pragma name. - if (SpellingIndex == Pragma_nounroll) + if (SpellingIndex == Pragma_nounroll || SpellingIndex == Pragma_nounroll_and_jam) return; - else if (SpellingIndex == Pragma_unroll) { + else if (SpellingIndex == Pragma_unroll || SpellingIndex == Pragma_unroll_and_jam) { OS << ' ' << getValueString(Policy); return; } @@ -2825,6 +2966,11 @@ def LoopHint : Attr { return "#pragma nounroll"; else if (SpellingIndex == Pragma_unroll) return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : ""); + else if (SpellingIndex == Pragma_nounroll_and_jam) + return "#pragma nounroll_and_jam"; + else if (SpellingIndex == Pragma_unroll_and_jam) + return "#pragma unroll_and_jam" + + (option == UnrollAndJamCount ? getValueString(Policy) : ""); assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling"); return getOptionName(option) + getValueString(Policy); @@ -2938,9 +3084,10 @@ def OMPDeclareSimdDecl : Attr { }]; } -def OMPDeclareTargetDecl : Attr { +def OMPDeclareTargetDecl : InheritableAttr { let Spellings = [Pragma<"omp", "declare target">]; let SemaHandler = 0; + let Subjects = SubjectList<[Function, SharedVar]>; let Documentation = [OMPDeclareTargetDocs]; let Args = [ EnumArgument<"MapType", "MapTypeTy", @@ -2953,6 +3100,15 @@ def OMPDeclareTargetDecl : Attr { if (getMapType() != MT_To) OS << ' ' << ConvertMapTypeTyToStr(getMapType()); } + static llvm::Optional<MapTypeTy> + isDeclareTargetDeclaration(const ValueDecl *VD) { + if (!VD->hasAttrs()) + return llvm::None; + if (const auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>()) + return Attr->getMapType(); + + return llvm::None; + } }]; } @@ -2961,3 +3117,47 @@ def InternalLinkage : InheritableAttr { let Subjects = SubjectList<[Var, Function, CXXRecord]>; let Documentation = [InternalLinkageDocs]; } + +def ExcludeFromExplicitInstantiation : InheritableAttr { + let Spellings = [Clang<"exclude_from_explicit_instantiation">]; + let Subjects = SubjectList<[Var, Function, CXXRecord]>; + let Documentation = [ExcludeFromExplicitInstantiationDocs]; + let MeaningfulToClassTemplateDefinition = 1; +} + +def Reinitializes : InheritableAttr { + let Spellings = [Clang<"reinitializes", 0>]; + let Subjects = SubjectList<[NonStaticNonConstCXXMethod], ErrorDiag>; + let Documentation = [ReinitializesDocs]; +} + +def NoDestroy : InheritableAttr { + let Spellings = [Clang<"no_destroy", 0>]; + let Subjects = SubjectList<[Var]>; + let Documentation = [NoDestroyDocs]; +} + +def AlwaysDestroy : InheritableAttr { + let Spellings = [Clang<"always_destroy", 0>]; + let Subjects = SubjectList<[Var]>; + let Documentation = [AlwaysDestroyDocs]; +} + +def SpeculativeLoadHardening : InheritableAttr { + let Spellings = [Clang<"speculative_load_hardening">]; + let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>; + let Documentation = [SpeculativeLoadHardeningDocs]; +} + +def Uninitialized : InheritableAttr { + let Spellings = [Clang<"uninitialized", 0>]; + let Subjects = SubjectList<[LocalVar]>; + let Documentation = [UninitializedDocs]; +} + +def ObjCExternallyRetained : InheritableAttr { + let LangOpts = [ObjCAutoRefCount]; + let Spellings = [Clang<"objc_externally_retained">]; + let Subjects = SubjectList<[NonParmVar, Function, Block, ObjCMethod]>; + let Documentation = [ObjCExternallyRetainedDocs]; +} diff --git a/include/clang/Basic/AttrDocs.td b/include/clang/Basic/AttrDocs.td index bb2993eab4bc..5773a92c9c15 100644 --- a/include/clang/Basic/AttrDocs.td +++ b/include/clang/Basic/AttrDocs.td @@ -38,6 +38,10 @@ Attributes in Clang .. contents:: :local: +.. |br| raw:: html + + <br/> + Introduction ============ @@ -51,7 +55,7 @@ def SectionDocs : Documentation { The ``section`` attribute allows you to specify a specific section a global variable or function should be in after translation. }]; - let Heading = "section (gnu::section, __declspec(allocate))"; + let Heading = "section, __declspec(allocate)"; } def InitSegDocs : Documentation { @@ -270,7 +274,7 @@ that appears to be capable of returning to its caller. def AssertCapabilityDocs : Documentation { let Category = DocCatFunction; - let Heading = "assert_capability (assert_shared_capability, clang::assert_capability, clang::assert_shared_capability)"; + let Heading = "assert_capability, assert_shared_capability"; let Content = [{ Marks a function that dynamically tests whether a capability is held, and halts the program if it is not held. @@ -279,7 +283,7 @@ the program if it is not held. def AcquireCapabilityDocs : Documentation { let Category = DocCatFunction; - let Heading = "acquire_capability (acquire_shared_capability, clang::acquire_capability, clang::acquire_shared_capability)"; + let Heading = "acquire_capability, acquire_shared_capability"; let Content = [{ Marks a function as acquiring a capability. }]; @@ -287,7 +291,7 @@ Marks a function as acquiring a capability. def TryAcquireCapabilityDocs : Documentation { let Category = DocCatFunction; - let Heading = "try_acquire_capability (try_acquire_shared_capability, clang::try_acquire_capability, clang::try_acquire_shared_capability)"; + let Heading = "try_acquire_capability, try_acquire_shared_capability"; let Content = [{ Marks a function that attempts to acquire a capability. This function may fail to actually acquire the capability; they accept a Boolean value determining @@ -298,7 +302,7 @@ the capability means success (false). def ReleaseCapabilityDocs : Documentation { let Category = DocCatFunction; - let Heading = "release_capability (release_shared_capability, clang::release_capability, clang::release_shared_capability)"; + let Heading = "release_capability, release_shared_capability"; let Content = [{ Marks a function as releasing a capability. }]; @@ -550,9 +554,9 @@ certain user-defined criteria. For example: .. code-block:: c - void abs(int a) + int abs(int a) __attribute__((diagnose_if(a >= 0, "Redundant abs call", "warning"))); - void must_abs(int a) + int must_abs(int a) __attribute__((diagnose_if(a >= 0, "Redundant abs call", "error"))); int val = abs(1); // warning: Redundant abs call @@ -843,6 +847,73 @@ Query for this feature with ``__has_attribute(objc_method_family)``. }]; } +def RetainBehaviorDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The behavior of a function with respect to reference counting for Foundation +(Objective-C), CoreFoundation (C) and OSObject (C++) is determined by a naming +convention (e.g. functions starting with "get" are assumed to return at +``+0``). + +It can be overriden using a family of the following attributes. In +Objective-C, the annotation ``__attribute__((ns_returns_retained))`` applied to +a function communicates that the object is returned at ``+1``, and the caller +is responsible for freeing it. +Similiarly, the annotation ``__attribute__((ns_returns_not_retained))`` +specifies that the object is returned at ``+0`` and the ownership remains with +the callee. +The annotation ``__attribute__((ns_consumes_self))`` specifies that +the Objective-C method call consumes the reference to ``self``, e.g. by +attaching it to a supplied parameter. +Additionally, parameters can have an annotation +``__attribute__((ns_consumed))``, which specifies that passing an owned object +as that parameter effectively transfers the ownership, and the caller is no +longer responsible for it. +These attributes affect code generation when interacting with ARC code, and +they are used by the Clang Static Analyzer. + +In C programs using CoreFoundation, a similar set of attributes: +``__attribute__((cf_returns_not_retained))``, +``__attribute__((cf_returns_retained))`` and ``__attribute__((cf_consumed))`` +have the same respective semantics when applied to CoreFoundation objects. +These attributes affect code generation when interacting with ARC code, and +they are used by the Clang Static Analyzer. + +Finally, in C++ interacting with XNU kernel (objects inheriting from OSObject), +the same attribute family is present: +``__attribute__((os_returns_not_retained))``, +``__attribute__((os_returns_retained))`` and ``__attribute__((os_consumed))``, +with the same respective semantics. +Similar to ``__attribute__((ns_consumes_self))``, +``__attribute__((os_consumes_this))`` specifies that the method call consumes +the reference to "this" (e.g., when attaching it to a different object supplied +as a parameter). +Out parameters (parameters the function is meant to write into, +either via pointers-to-pointers or references-to-pointers) +may be annotated with ``__attribute__((os_returns_retained))`` +or ``__attribute__((os_returns_not_retained))`` which specifies that the object +written into the out parameter should (or respectively should not) be released +after use. +Since often out parameters may or may not be written depending on the exit +code of the function, +annotations ``__attribute__((os_returns_retained_on_zero))`` +and ``__attribute__((os_returns_retained_on_non_zero))`` specify that +an out parameter at ``+1`` is written if and only if the function returns a zero +(respectively non-zero) error code. +Observe that return-code-dependent out parameter annotations are only +available for retained out parameters, as non-retained object do not have to be +released by the callee. +These attributes are only used by the Clang Static Analyzer. + +The family of attributes ``X_returns_X_retained`` can be added to functions, +C++ methods, and Objective-C methods and properties. +Attributes ``X_consumed`` can be added to parameters of methods, functions, +and Objective-C methods. + }]; +} + + + def NoDebugDocs : Documentation { let Category = DocCatVariable; let Content = [{ @@ -1261,7 +1332,7 @@ of silently falling back on dynamic initialization. def WarnMaybeUnusedDocs : Documentation { let Category = DocCatVariable; - let Heading = "maybe_unused, unused, gnu::unused"; + let Heading = "maybe_unused, unused"; let Content = [{ When passing the ``-Wunused`` flag to Clang, entities that are unused by the program may be diagnosed. The ``[[maybe_unused]]`` (or @@ -1287,7 +1358,7 @@ enumerator, a non-static data member, or a label. def WarnUnusedResultsDocs : Documentation { let Category = DocCatFunction; - let Heading = "nodiscard, warn_unused_result, clang::warn_unused_result, gnu::warn_unused_result"; + let Heading = "nodiscard, warn_unused_result"; let Content = [{ Clang supports the ability to diagnose when the results of a function call expression are discarded under suspicious circumstances. A diagnostic is @@ -1312,7 +1383,7 @@ potentially-evaluated discarded-value expression that is not explicitly cast to def FallthroughDocs : Documentation { let Category = DocCatStmt; - let Heading = "fallthrough, clang::fallthrough"; + let Heading = "fallthrough"; let Content = [{ The ``fallthrough`` (or ``clang::fallthrough``) attribute is used to annotate intentional fall-through @@ -1460,7 +1531,7 @@ on the command line. def MipsLongCallStyleDocs : Documentation { let Category = DocCatFunction; - let Heading = "long_call (gnu::long_call, gnu::far)"; + let Heading = "long_call, far"; let Content = [{ Clang supports the ``__attribute__((long_call))``, ``__attribute__((far))``, and ``__attribute__((near))`` attributes on MIPS targets. These attributes may @@ -1481,7 +1552,7 @@ as ``-mlong-calls`` and ``-mno-long-calls``. def MipsShortCallStyleDocs : Documentation { let Category = DocCatFunction; - let Heading = "short_call (gnu::short_call, gnu::near)"; + let Heading = "short_call, near"; let Content = [{ Clang supports the ``__attribute__((long_call))``, ``__attribute__((far))``, ``__attribute__((short__call))``, and ``__attribute__((near))`` attributes @@ -1738,6 +1809,31 @@ similar to ``stdcall`` on x86. Valid parameter values are "aapcs" and }]; } +def AArch64VectorPcsDocs : Documentation { + let Category = DocCatCallingConvs; + let Content = [{ +On AArch64 targets, this attribute changes the calling convention of a +function to preserve additional floating-point and Advanced SIMD registers +relative to the default calling convention used for AArch64. + +This means it is more efficient to call such functions from code that performs +extensive floating-point and vector calculations, because fewer live SIMD and FP +registers need to be saved. This property makes it well-suited for e.g. +floating-point or vector math library functions, which are typically leaf +functions that require a small number of registers. + +However, using this attribute also means that it is more expensive to call +a function that adheres to the default calling convention from within such +a function. Therefore, it is recommended that this attribute is only used +for leaf functions. + +For more information, see the documentation for `aarch64_vector_pcs`_ on +the Arm Developer website. + +.. _`aarch64_vector_pcs`: https://developer.arm.com/products/software-development-tools/hpc/arm-compiler-for-hpc/vector-function-abi + }]; +} + def RegparmDocs : Documentation { let Category = DocCatCallingConvs; let Content = [{ @@ -1940,7 +2036,7 @@ def NoSanitizeAddressDocs : Documentation { let Category = DocCatFunction; // This function has multiple distinct spellings, and so it requires a custom // heading to be specified. The most common spelling is sufficient. - let Heading = "no_sanitize_address (no_address_safety_analysis, gnu::no_address_safety_analysis, gnu::no_sanitize_address)"; + let Heading = "no_sanitize_address, no_address_safety_analysis"; let Content = [{ .. _langext-address_sanitizer: @@ -2497,10 +2593,10 @@ def LoopHintDocs : Documentation { let Heading = "#pragma clang loop"; let Content = [{ The ``#pragma clang loop`` directive allows loop optimization hints to be -specified for the subsequent loop. The directive allows vectorization, -interleaving, and unrolling to be enabled or disabled. Vector width as well -as interleave and unrolling count can be manually specified. See -`language extensions +specified for the subsequent loop. The directive allows pipelining to be +disabled, or vectorization, interleaving, and unrolling to be enabled or disabled. +Vector width, interleave count, unrolling count, and the initiation interval +for pipelining can be explicitly specified. See `language extensions <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_ for details. }]; @@ -2561,9 +2657,58 @@ for further details including limitations of the unroll hints. }]; } +def PipelineHintDocs : Documentation { + let Category = DocCatStmt; + let Heading = "#pragma clang loop pipeline, #pragma clang loop pipeline_initiation_interval"; + let Content = [{ + Software Pipelining optimization is a technique used to optimize loops by + utilizing instruction-level parallelism. It reorders loop instructions to + overlap iterations. As a result, the next iteration starts before the previous + iteration has finished. The module scheduling technique creates a schedule for + one iteration such that when repeating at regular intervals, no inter-iteration + dependencies are violated. This constant interval(in cycles) between the start + of iterations is called the initiation interval. i.e. The initiation interval + is the number of cycles between two iterations of an unoptimized loop in the + newly created schedule. A new, optimized loop is created such that a single iteration + of the loop executes in the same number of cycles as the initiation interval. + For further details see <https://llvm.org/pubs/2005-06-17-LattnerMSThesis-book.pdf>. + + ``#pragma clang loop pipeline and #pragma loop pipeline_initiation_interval`` + could be used as hints for the software pipelining optimization. The pragma is + placed immediately before a for, while, do-while, or a C++11 range-based for + loop. + + Using ``#pragma clang loop pipeline(disable)`` avoids the software pipelining + optimization. The disable state can only be specified: + + .. code-block:: c++ + + #pragma clang loop pipeline(disable) + for (...) { + ... + } + + Using ``#pragma loop pipeline_initiation_interval`` instructs + the software pipeliner to try the specified initiation interval. + If a schedule was found then the resulting loop iteration would have + the specified cycle count. If a schedule was not found then loop + remains unchanged. The initiation interval must be a positive number + greater than zero: + + .. code-block:: c++ + + #pragma loop pipeline_initiation_interval(10) + for (...) { + ... + } + + }]; +} + + + def OpenCLUnrollHintDocs : Documentation { let Category = DocCatStmt; - let Heading = "__attribute__((opencl_unroll_hint))"; let Content = [{ The opencl_unroll_hint attribute qualifier can be used to specify that a loop (for, while and do loops) can be unrolled. This attribute qualifier can be @@ -2576,7 +2721,6 @@ s6.11.5 for details. def OpenCLIntelReqdSubGroupSizeDocs : Documentation { let Category = DocCatStmt; - let Heading = "__attribute__((intel_reqd_sub_group_size))"; let Content = [{ The optional attribute intel_reqd_sub_group_size can be used to indicate that the kernel must be compiled and executed with the specified subgroup size. When @@ -2973,6 +3117,68 @@ This can be used to contain the ABI of a C++ library by excluding unwanted class }]; } +def ExcludeFromExplicitInstantiationDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The ``exclude_from_explicit_instantiation`` attribute opts-out a member of a +class template from being part of explicit template instantiations of that +class template. This means that an explicit instantiation will not instantiate +members of the class template marked with the attribute, but also that code +where an extern template declaration of the enclosing class template is visible +will not take for granted that an external instantiation of the class template +would provide those members (which would otherwise be a link error, since the +explicit instantiation won't provide those members). For example, let's say we +don't want the ``data()`` method to be part of libc++'s ABI. To make sure it +is not exported from the dylib, we give it hidden visibility: + + .. code-block:: c++ + + // in <string> + template <class CharT> + class basic_string { + public: + __attribute__((__visibility__("hidden"))) + const value_type* data() const noexcept { ... } + }; + + template class basic_string<char>; + +Since an explicit template instantiation declaration for ``basic_string<char>`` +is provided, the compiler is free to assume that ``basic_string<char>::data()`` +will be provided by another translation unit, and it is free to produce an +external call to this function. However, since ``data()`` has hidden visibility +and the explicit template instantiation is provided in a shared library (as +opposed to simply another translation unit), ``basic_string<char>::data()`` +won't be found and a link error will ensue. This happens because the compiler +assumes that ``basic_string<char>::data()`` is part of the explicit template +instantiation declaration, when it really isn't. To tell the compiler that +``data()`` is not part of the explicit template instantiation declaration, the +``exclude_from_explicit_instantiation`` attribute can be used: + + .. code-block:: c++ + + // in <string> + template <class CharT> + class basic_string { + public: + __attribute__((__visibility__("hidden"))) + __attribute__((exclude_from_explicit_instantiation)) + const value_type* data() const noexcept { ... } + }; + + template class basic_string<char>; + +Now, the compiler won't assume that ``basic_string<char>::data()`` is provided +externally despite there being an explicit template instantiation declaration: +the compiler will implicitly instantiate ``basic_string<char>::data()`` in the +TUs where it is used. + +This attribute can be used on static and non-static member functions of class +templates, static data members of class templates and member classes of class +templates. + }]; +} + def DisableTailCallsDocs : Documentation { let Category = DocCatFunction; let Content = [{ @@ -3364,11 +3570,11 @@ def IFuncDocs : Documentation { let Content = [{ ``__attribute__((ifunc("resolver")))`` is used to mark that the address of a declaration should be resolved at runtime by calling a resolver function. -The symbol name of the resolver function is given in quotes. A function with this name (after mangling) must be defined in the current translation unit; it may be ``static``. The resolver function should take no arguments and return a pointer. +The symbol name of the resolver function is given in quotes. A function with this name (after mangling) must be defined in the current translation unit; it may be ``static``. The resolver function should return a pointer. The ``ifunc`` attribute may only be used on a function declaration. A function declaration with an ``ifunc`` attribute is considered to be a definition of the declared entity. The entity must not have weak linkage; for example, in C++, it cannot be applied to a declaration if a definition at that location would be considered inline. -Not all targets support this attribute. ELF targets support this attribute when using binutils v2.20.1 or higher and glibc v2.11.1 or higher. Non-ELF targets currently do not support this attribute. +Not all targets support this attribute. ELF target support depends on both the linker and runtime linker, and is available in at least lld 4.0 and later, binutils 2.20.1 and later, glibc v2.11.1 and later, and FreeBSD 9.1 and later. Non-ELF targets currently do not support this attribute. }]; } @@ -3396,7 +3602,7 @@ See the RenderScript_ documentation for more information. def XRayDocs : Documentation { let Category = DocCatFunction; - let Heading = "xray_always_instrument (clang::xray_always_instrument), xray_never_instrument (clang::xray_never_instrument), xray_log_args (clang::xray_log_args)"; + let Heading = "xray_always_instrument, xray_never_instrument, xray_log_args"; let Content = [{ ``__attribute__((xray_always_instrument))`` or ``[[clang::xray_always_instrument]]`` is used to mark member functions (in C++), methods (in Objective C), and free functions (in C, C++, and Objective C) to be instrumented with XRay. This will cause the function to always have space at the beginning and exit points to allow for runtime patching. @@ -3458,3 +3664,206 @@ the resulting instructions with the call site, rather than with the corresponding line within the inlined callee. }]; } + +def NoDerefDocs : Documentation { + let Category = DocCatType; + let Content = [{ +The ``noderef`` attribute causes clang to diagnose dereferences of annotated pointer types. +This is ideally used with pointers that point to special memory which cannot be read +from or written to, but allowing for the pointer to be used in pointer arithmetic. +The following are examples of valid expressions where dereferences are diagnosed: + +.. code-block:: c + + int __attribute__((noderef)) *p; + int x = *p; // warning + + int __attribute__((noderef)) **p2; + x = **p2; // warning + + int * __attribute__((noderef)) *p3; + p = *p3; // warning + + struct S { + int a; + }; + struct S __attribute__((noderef)) *s; + x = s->a; // warning + x = (*s).a; // warning + +Not all dereferences may diagnose a warning if the value directed by the pointer may not be +accessed. The following are examples of valid expressions where may not be diagnosed: + +.. code-block:: c + + int *q; + int __attribute__((noderef)) *p; + q = &*p; + q = *&p; + + struct S { + int a; + }; + struct S __attribute__((noderef)) *s; + p = &s->a; + p = &(*s).a; + +``noderef`` is currently only supported for pointers and arrays and not usable for +references or Objective-C object pointers. + +.. code-block: c++ + + int x = 2; + int __attribute__((noderef)) &y = x; // warning: 'noderef' can only be used on an array or pointer type + +.. code-block: objc + + id __attribute__((noderef)) obj = [NSObject new]; // warning: 'noderef' can only be used on an array or pointer type +}]; +} + +def ReinitializesDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The ``reinitializes`` attribute can be applied to a non-static, non-const C++ +member function to indicate that this member function reinitializes the entire +object to a known state, independent of the previous state of the object. + +This attribute can be interpreted by static analyzers that warn about uses of an +object that has been left in an indeterminate state by a move operation. If a +member function marked with the ``reinitializes`` attribute is called on a +moved-from object, the analyzer can conclude that the object is no longer in an +indeterminate state. + +A typical example where this attribute would be used is on functions that clear +a container class: + +.. code-block:: c++ + + template <class T> + class Container { + public: + ... + [[clang::reinitializes]] void Clear(); + ... + }; + }]; +} + +def AlwaysDestroyDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``always_destroy`` attribute specifies that a variable with static or thread +storage duration should have its exit-time destructor run. This attribute is the +default unless clang was invoked with -fno-c++-static-destructors. + }]; +} + +def NoDestroyDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``no_destroy`` attribute specifies that a variable with static or thread +storage duration shouldn't have its exit-time destructor run. Annotating every +static and thread duration variable with this attribute is equivalent to +invoking clang with -fno-c++-static-destructors. + }]; +} + +def UninitializedDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The command-line parameter ``-ftrivial-auto-var-init=*`` can be used to +initialize trivial automatic stack variables. By default, trivial automatic +stack variables are uninitialized. This attribute is used to override the +command-line parameter, forcing variables to remain uninitialized. It has no +semantic meaning in that using uninitialized values is undefined behavior, +it rather documents the programmer's intent. + }]; +} + +def GnuInlineDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The ``gnu_inline`` changes the meaning of ``extern inline`` to use GNU inline +semantics, meaning: + +* If any declaration that is declared ``inline`` is not declared ``extern``, +then the ``inline`` keyword is just a hint. In particular, an out-of-line +definition is still emitted for a function with external linkage, even if all +call sites are inlined, unlike in C99 and C++ inline semantics. + +* If all declarations that are declared ``inline`` are also declared +``extern``, then the function body is present only for inlining and no +out-of-line version is emitted. + +Some important consequences: ``static inline`` emits an out-of-line +version if needed, a plain ``inline`` definition emits an out-of-line version +always, and an ``extern inline`` definition (in a header) followed by a +(non-``extern``) ``inline`` declaration in a source file emits an out-of-line +version of the function in that source file but provides the function body for +inlining to all includers of the header. + +Either ``__GNUC_GNU_INLINE__`` (GNU inline semantics) or +``__GNUC_STDC_INLINE__`` (C99 semantics) will be defined (they are mutually +exclusive). If ``__GNUC_STDC_INLINE__`` is defined, then the ``gnu_inline`` +function attribute can be used to get GNU inline semantics on a per function +basis. If ``__GNUC_GNU_INLINE__`` is defined, then the translation unit is +already being compiled with GNU inline semantics as the implied default. It is +unspecified which macro is defined in a C++ compilation. + +GNU inline semantics are the default behavior with ``-std=gnu89``, +``-std=c89``, ``-std=c94``, or ``-fgnu89-inline``. + }]; +} + +def SpeculativeLoadHardeningDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ + This attribute can be applied to a function declaration in order to indicate + that `Speculative Load Hardening <https://llvm.org/docs/SpeculativeLoadHardening.html>`_ + should be enabled for the function body. This can also be applied to a method + in Objective C. + + Speculative Load Hardening is a best-effort mitigation against + information leak attacks that make use of control flow + miss-speculation - specifically miss-speculation of whether a branch + is taken or not. Typically vulnerabilities enabling such attacks are + classified as "Spectre variant #1". Notably, this does not attempt to + mitigate against miss-speculation of branch target, classified as + "Spectre variant #2" vulnerabilities. + + When inlining, the attribute is sticky. Inlining a function that + carries this attribute will cause the caller to gain the + attribute. This is intended to provide a maximally conservative model + where the code in a function annotated with this attribute will always + (even after inlining) end up hardened. + }]; +} + +def ObjCExternallyRetainedDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``objc_externally_retained`` attribute can be applied to strong local +variables, functions, methods, or blocks to opt into +`externally-retained semantics +<https://clang.llvm.org/docs/AutomaticReferenceCounting.html#externally-retained-variables>`_. + +When applied to the definition of a function, method, or block, every parameter +of the function with implicit strong retainable object pointer type is +considered externally-retained, and becomes ``const``. By explicitly annotating +a parameter with ``__strong``, you can opt back into the default +non-externally-retained behaviour for that parameter. For instance, +``first_param`` is externally-retained below, but not ``second_param``: + +.. code-block:: objc + + __attribute__((objc_externally_retained)) + void f(NSArray *first_param, __strong NSArray *second_param) { + // ... + } + +Likewise, when applied to a strong local variable, that variable becomes +``const`` and is considered externally-retained. + +When compiled without ``-fobjc-arc``, this attribute is ignored. +}]; } diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index c4d11cd827c1..fa031ce09f6b 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -413,6 +413,9 @@ BUILTIN(__builtin_parityll, "iULLi", "nc") BUILTIN(__builtin_popcount , "iUi" , "nc") BUILTIN(__builtin_popcountl , "iULi" , "nc") BUILTIN(__builtin_popcountll, "iULLi", "nc") +BUILTIN(__builtin_clrsb , "ii" , "nc") +BUILTIN(__builtin_clrsbl , "iLi" , "nc") +BUILTIN(__builtin_clrsbll, "iLLi", "nc") // FIXME: These type signatures are not correct for targets with int != 32-bits // or with ULL != 64-bits. @@ -425,6 +428,15 @@ BUILTIN(__builtin_bitreverse16, "UsUs", "nc") BUILTIN(__builtin_bitreverse32, "UiUi", "nc") BUILTIN(__builtin_bitreverse64, "ULLiULLi", "nc") +BUILTIN(__builtin_rotateleft8, "UcUcUc", "nc") +BUILTIN(__builtin_rotateleft16, "UsUsUs", "nc") +BUILTIN(__builtin_rotateleft32, "UiUiUi", "nc") +BUILTIN(__builtin_rotateleft64, "ULLiULLiULLi", "nc") +BUILTIN(__builtin_rotateright8, "UcUcUc", "nc") +BUILTIN(__builtin_rotateright16, "UsUsUs", "nc") +BUILTIN(__builtin_rotateright32, "UiUiUi", "nc") +BUILTIN(__builtin_rotateright64, "ULLiULLiULLi", "nc") + // Random GCC builtins BUILTIN(__builtin_constant_p, "i.", "nctu") BUILTIN(__builtin_classify_type, "i.", "nctu") @@ -486,6 +498,7 @@ BUILTIN(__builtin_snprintf, "ic*zcC*.", "nFp:2:") BUILTIN(__builtin_vsprintf, "ic*cC*a", "nFP:1:") BUILTIN(__builtin_vsnprintf, "ic*zcC*a", "nFP:2:") BUILTIN(__builtin_thread_pointer, "v*", "nc") +BUILTIN(__builtin_launder, "v*v*", "nt") // GCC exception builtins BUILTIN(__builtin_eh_return, "vzv*", "r") // FIXME: Takes intptr_t, not size_t! @@ -526,7 +539,7 @@ BUILTIN(__builtin_readcyclecounter, "ULLi", "n") BUILTIN(__builtin_trap, "v", "nr") BUILTIN(__builtin_debugtrap, "v", "n") BUILTIN(__builtin_unreachable, "v", "nr") -BUILTIN(__builtin_shufflevector, "v." , "nc") +BUILTIN(__builtin_shufflevector, "v." , "nct") BUILTIN(__builtin_convertvector, "v." , "nct") BUILTIN(__builtin_alloca, "v*z" , "Fn") BUILTIN(__builtin_alloca_with_align, "v*zIz", "Fn") @@ -774,6 +787,7 @@ LANGBUILTIN(_InterlockedCompareExchange16, "ssD*ss", "n", ALL_MS_LANGUA LANGBUILTIN(_InterlockedCompareExchange, "NiNiD*NiNi", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_InterlockedCompareExchange64, "LLiLLiD*LLiLLi", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_InterlockedCompareExchangePointer, "v*v*D*v*v*", "n", ALL_MS_LANGUAGES) +LANGBUILTIN(_InterlockedCompareExchangePointer_nf, "v*v*D*v*v*", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_InterlockedDecrement16, "ssD*", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_InterlockedDecrement, "NiNiD*", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_InterlockedExchange, "NiNiD*Ni", "n", ALL_MS_LANGUAGES) @@ -805,20 +819,23 @@ LANGBUILTIN(_interlockedbittestandset_acq, "UcNiD*Ni", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_interlockedbittestandset_nf, "UcNiD*Ni", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_interlockedbittestandset_rel, "UcNiD*Ni", "n", ALL_MS_LANGUAGES) LANGBUILTIN(__noop, "i.", "n", ALL_MS_LANGUAGES) -LANGBUILTIN(__popcnt16, "UsUs", "nc", ALL_MS_LANGUAGES) -LANGBUILTIN(__popcnt, "UiUi", "nc", ALL_MS_LANGUAGES) -LANGBUILTIN(__popcnt64, "ULLiULLi", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__lzcnt16, "UsUs", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__lzcnt, "UiUi", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__lzcnt64, "UWiUWi", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__popcnt16, "UsUs", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__popcnt, "UiUi", "nc", ALL_MS_LANGUAGES) +LANGBUILTIN(__popcnt64, "UWiUWi", "nc", ALL_MS_LANGUAGES) LANGBUILTIN(_ReturnAddress, "v*", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotl8, "UcUcUc", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotl16, "UsUsUc", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotl, "UiUii", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_lrotl, "UNiUNii", "n", ALL_MS_LANGUAGES) -LANGBUILTIN(_rotl64, "ULLiULLii", "n", ALL_MS_LANGUAGES) +LANGBUILTIN(_rotl64, "UWiUWii", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotr8, "UcUcUc", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotr16, "UsUsUc", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_rotr, "UiUii", "n", ALL_MS_LANGUAGES) LANGBUILTIN(_lrotr, "UNiUNii", "n", ALL_MS_LANGUAGES) -LANGBUILTIN(_rotr64, "ULLiULLii", "n", ALL_MS_LANGUAGES) +LANGBUILTIN(_rotr64, "UWiUWii", "n", ALL_MS_LANGUAGES) LANGBUILTIN(__va_start, "vc**.", "nt", ALL_MS_LANGUAGES) LANGBUILTIN(__fastfail, "vUi", "nr", ALL_MS_LANGUAGES) @@ -1385,9 +1402,9 @@ BUILTIN(__builtin_subcl, "ULiULiCULiCULiCULi*", "n") BUILTIN(__builtin_subcll, "ULLiULLiCULLiCULLiCULLi*", "n") // Checked Arithmetic Builtins for Security. -BUILTIN(__builtin_add_overflow, "v.", "nt") -BUILTIN(__builtin_sub_overflow, "v.", "nt") -BUILTIN(__builtin_mul_overflow, "v.", "nt") +BUILTIN(__builtin_add_overflow, "b.", "nt") +BUILTIN(__builtin_sub_overflow, "b.", "nt") +BUILTIN(__builtin_mul_overflow, "b.", "nt") BUILTIN(__builtin_uadd_overflow, "bUiCUiCUi*", "n") BUILTIN(__builtin_uaddl_overflow, "bULiCULiCULi*", "n") BUILTIN(__builtin_uaddll_overflow, "bULLiCULLiCULLi*", "n") diff --git a/include/clang/Basic/BuiltinsAArch64.def b/include/clang/Basic/BuiltinsAArch64.def index b5d971d0bc6e..1892ff11a31d 100644 --- a/include/clang/Basic/BuiltinsAArch64.def +++ b/include/clang/Basic/BuiltinsAArch64.def @@ -94,6 +94,7 @@ TARGET_HEADER_BUILTIN(_BitScanReverse, "UcUNi*UNi", "nh", "intrin.h", ALL_MS_LAN TARGET_HEADER_BUILTIN(_BitScanForward64, "UcUNi*ULLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_BitScanReverse64, "UcUNi*ULLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAdd, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedAnd64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedDecrement64, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedExchange64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") @@ -103,6 +104,110 @@ TARGET_HEADER_BUILTIN(_InterlockedIncrement64, "LLiLLiD*", "nh", "intrin.h" TARGET_HEADER_BUILTIN(_InterlockedOr64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedXor64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedExchange8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_acq, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_nf, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_rel, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_acq, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_nf, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_rel, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_acq, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_nf, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_rel, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_acq, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_nf, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_rel, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedOr8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedXor8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedAnd8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_acq, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_nf, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_rel, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_acq, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_nf, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_rel, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_acq, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_nf, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_rel, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_acq, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_nf, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_rel, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_acq, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_nf, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_rel, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_acq, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_nf, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_rel, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_ReadWriteBarrier, "v", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(__getReg, "ULLii", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_ReadStatusReg, "ii", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_WriteStatusReg, "vii", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_AddressOfReturnAddress, "v*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + #undef BUILTIN #undef LANGBUILTIN #undef TARGET_HEADER_BUILTIN diff --git a/include/clang/Basic/BuiltinsAMDGPU.def b/include/clang/Basic/BuiltinsAMDGPU.def index 4a447eb9f6a8..a25e45fe3fb8 100644 --- a/include/clang/Basic/BuiltinsAMDGPU.def +++ b/include/clang/Basic/BuiltinsAMDGPU.def @@ -21,9 +21,10 @@ // SI+ only builtins. //===----------------------------------------------------------------------===// -BUILTIN(__builtin_amdgcn_dispatch_ptr, "Uc*4", "nc") -BUILTIN(__builtin_amdgcn_kernarg_segment_ptr, "Uc*4", "nc") -BUILTIN(__builtin_amdgcn_implicitarg_ptr, "Uc*4", "nc") +BUILTIN(__builtin_amdgcn_dispatch_ptr, "v*4", "nc") +BUILTIN(__builtin_amdgcn_kernarg_segment_ptr, "v*4", "nc") +BUILTIN(__builtin_amdgcn_implicitarg_ptr, "v*4", "nc") +BUILTIN(__builtin_amdgcn_queue_ptr, "v*4", "nc") BUILTIN(__builtin_amdgcn_workgroup_id_x, "Ui", "nc") BUILTIN(__builtin_amdgcn_workgroup_id_y, "Ui", "nc") @@ -45,6 +46,8 @@ BUILTIN(__builtin_amdgcn_s_barrier, "v", "n") BUILTIN(__builtin_amdgcn_wave_barrier, "v", "n") BUILTIN(__builtin_amdgcn_s_dcache_inv, "v", "n") BUILTIN(__builtin_amdgcn_buffer_wbinvl1, "v", "n") + +// FIXME: Need to disallow constant address space. BUILTIN(__builtin_amdgcn_div_scale, "dddbb*", "n") BUILTIN(__builtin_amdgcn_div_scalef, "fffbb*", "n") BUILTIN(__builtin_amdgcn_div_fmas, "ddddb", "nc") @@ -93,9 +96,15 @@ BUILTIN(__builtin_amdgcn_ds_bpermute, "iii", "nc") BUILTIN(__builtin_amdgcn_readfirstlane, "ii", "nc") BUILTIN(__builtin_amdgcn_readlane, "iii", "nc") BUILTIN(__builtin_amdgcn_fmed3f, "ffff", "nc") -BUILTIN(__builtin_amdgcn_ds_faddf, "ff*fIiIiIb", "n") -BUILTIN(__builtin_amdgcn_ds_fminf, "ff*fIiIiIb", "n") -BUILTIN(__builtin_amdgcn_ds_fmaxf, "ff*fIiIiIb", "n") +BUILTIN(__builtin_amdgcn_ds_faddf, "ff*3fIiIiIb", "n") +BUILTIN(__builtin_amdgcn_ds_fminf, "ff*3fIiIiIb", "n") +BUILTIN(__builtin_amdgcn_ds_fmaxf, "ff*3fIiIiIb", "n") + +//===----------------------------------------------------------------------===// +// CI+ only builtins. +//===----------------------------------------------------------------------===// +TARGET_BUILTIN(__builtin_amdgcn_s_dcache_inv_vol, "v", "n", "ci-insts") +TARGET_BUILTIN(__builtin_amdgcn_buffer_wbinvl1_vol, "v", "n", "ci-insts") //===----------------------------------------------------------------------===// // VI+ only builtins. @@ -113,6 +122,8 @@ TARGET_BUILTIN(__builtin_amdgcn_fracth, "hh", "nc", "16-bit-insts") TARGET_BUILTIN(__builtin_amdgcn_classh, "bhi", "nc", "16-bit-insts") TARGET_BUILTIN(__builtin_amdgcn_s_memrealtime, "LUi", "n", "s-memrealtime") TARGET_BUILTIN(__builtin_amdgcn_mov_dpp, "iiIiIiIiIb", "nc", "dpp") +TARGET_BUILTIN(__builtin_amdgcn_update_dpp, "iiiIiIiIiIb", "nc", "dpp") +TARGET_BUILTIN(__builtin_amdgcn_s_dcache_wb, "v", "n", "vi-insts") //===----------------------------------------------------------------------===// // GFX9+ only builtins. @@ -124,13 +135,13 @@ TARGET_BUILTIN(__builtin_amdgcn_fmed3h, "hhhh", "nc", "gfx9-insts") // Deep learning builtins. //===----------------------------------------------------------------------===// -TARGET_BUILTIN(__builtin_amdgcn_fdot2, "fV2hV2hfIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_sdot2, "SiV2SsV2SsSiIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_udot2, "UiV2UsV2UsUiIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_sdot4, "SiSiSiSiIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_udot4, "UiUiUiUiIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_sdot8, "SiSiSiSiIb", "nc", "dl-insts") -TARGET_BUILTIN(__builtin_amdgcn_udot8, "UiUiUiUiIb", "nc", "dl-insts") +TARGET_BUILTIN(__builtin_amdgcn_fdot2, "fV2hV2hfIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_sdot2, "SiV2SsV2SsSiIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_udot2, "UiV2UsV2UsUiIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_sdot4, "SiSiSiSiIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_udot4, "UiUiUiUiIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_sdot8, "SiSiSiSiIb", "nc", "dot-insts") +TARGET_BUILTIN(__builtin_amdgcn_udot8, "UiUiUiUiIb", "nc", "dot-insts") //===----------------------------------------------------------------------===// // Special builtins. diff --git a/include/clang/Basic/BuiltinsARM.def b/include/clang/Basic/BuiltinsARM.def index 941d320d729f..ad778527b212 100644 --- a/include/clang/Basic/BuiltinsARM.def +++ b/include/clang/Basic/BuiltinsARM.def @@ -230,6 +230,104 @@ TARGET_HEADER_BUILTIN(_InterlockedIncrement64, "LLiLLiD*", "nh", "intrin.h" TARGET_HEADER_BUILTIN(_InterlockedOr64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedXor64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchangeAdd64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedExchange8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedExchange64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_acq, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_nf, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange8_rel, "ccD*cc", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_acq, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_nf, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange16_rel, "ssD*ss", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_acq, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_nf, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange_rel, "LiLiD*LiLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_acq, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_nf, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedCompareExchange64_rel, "LLiLLiD*LLiLLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedOr8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedOr64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedXor8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedXor64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedAnd8_acq, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd8_nf, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd8_rel, "ccD*c", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_acq, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_nf, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd16_rel, "ssD*s", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_acq, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_nf, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd_rel, "LiLiD*Li", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_acq, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_nf, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedAnd64_rel, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_acq, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_nf, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement16_rel, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_acq, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_nf, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement_rel, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_acq, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_nf, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedIncrement64_rel, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_acq, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_nf, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement16_rel, "ssD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_acq, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_nf, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement_rel, "LiLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_acq, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_nf, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(_InterlockedDecrement64_rel, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") + #undef BUILTIN #undef LANGBUILTIN #undef TARGET_HEADER_BUILTIN diff --git a/include/clang/Basic/BuiltinsHexagon.def b/include/clang/Basic/BuiltinsHexagon.def index f976720d116d..bb040c06fd07 100644 --- a/include/clang/Basic/BuiltinsHexagon.def +++ b/include/clang/Basic/BuiltinsHexagon.def @@ -63,1676 +63,1756 @@ BUILTIN(__builtin_HEXAGON_S2_storerf_pcr, "vv*iivC*", "") BUILTIN(__builtin_HEXAGON_S2_storeri_pcr, "vv*iivC*", "") BUILTIN(__builtin_HEXAGON_S2_storerd_pcr, "vv*iLLivC*", "") -// The builtins above are not autogenerated from iset.py. -// Make sure you do not overwrite these. +BUILTIN(__builtin_HEXAGON_prefetch,"vv*","") +BUILTIN(__builtin_HEXAGON_Y2_dccleana,"vv*","") +BUILTIN(__builtin_HEXAGON_Y2_dccleaninva,"vv*","") +BUILTIN(__builtin_HEXAGON_Y2_dcinva,"vv*","") +BUILTIN(__builtin_HEXAGON_Y2_dczeroa,"vv*","") +BUILTIN(__builtin_HEXAGON_Y4_l2fetch,"vv*Ui","") +BUILTIN(__builtin_HEXAGON_Y5_l2fetch,"vv*LLUi","") -BUILTIN(__builtin_HEXAGON_C2_cmpeq,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgt,"iii","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_qpred_ai,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nqpred_ai,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_qpred_ai,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_nqpred_ai,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_qpred_ai_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nqpred_ai_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_qpred_ai_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_nqpred_ai_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstoreq,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorenq,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentq,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentnq,"vV16iv*V16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstoreq_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorenq_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentq_128B,"vV32iv*V32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentnq_128B,"vV32iv*V32i","") + +BUILTIN(__builtin_HEXAGON_V6_vgathermw,"vv*iiV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermw_128B,"vv*iiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermh,"vv*iiV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermh_128B,"vv*iiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhw,"vv*iiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhw_128B,"vv*iiV64i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermwq,"vv*V16iiiV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermwq_128B,"vv*V32iiiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhq,"vv*V16iiiV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhq_128B,"vv*V32iiiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhwq,"vv*V16iiiV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgathermhwq_128B,"vv*V32iiiV64i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermw,"viiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermw_128B,"viiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermh,"viiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermh_128B,"viiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermw_add,"viiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermw_add_128B,"viiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermh_add,"viiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermh_add_128B,"viiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermwq,"vV16iiiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermwq_128B,"vV32iiiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhq,"vV16iiiV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhq_128B,"vV32iiiV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhw,"viiV32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhw_128B,"viiV64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhwq,"vV16iiiV32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhwq_128B,"vV32iiiV64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhw_add,"viiV32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vscattermhw_add_128B,"viiV64iV32i","") + +// --------------------------------------------------------------------- +// Auto-generated definitions. + +// V5 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_S2_asr_r_p_or,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_vsatwh,"iLLi","") +BUILTIN(__builtin_HEXAGON_S2_tableidxd_goodsyntax,"iiiUIiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpysu_up,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_cmpysc_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_cmpysc_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_M4_cmpyi_whc,"iLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_S2_tableidxb_goodsyntax,"iiiUIiUIi","") +BUILTIN(__builtin_HEXAGON_S2_shuffoh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_sfmax,"fff","") +BUILTIN(__builtin_HEXAGON_A2_vabswsat,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_combineri,"LLiiIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hl_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M4_vpmpyh_acc,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_i,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_notp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s0,"iii","") +BUILTIN(__builtin_HEXAGON_C4_or_and,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2s_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2s_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_brevp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_pmpyw_acc,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_cl1,"ii","") +BUILTIN(__builtin_HEXAGON_C4_cmplte,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyul_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vaddws,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_maxup,"ULLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_vcmphgti,"iLLiIi","") +BUILTIN(__builtin_HEXAGON_S2_interleave,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_abssat,"ii","") +BUILTIN(__builtin_HEXAGON_A2_vcmpwgtu,"iLLiLLi","") BUILTIN(__builtin_HEXAGON_C2_cmpgtu,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpeqp,"iLLiLLi","") BUILTIN(__builtin_HEXAGON_C2_cmpgtp,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtup,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_rcmpeqi,"iii","") -BUILTIN(__builtin_HEXAGON_A4_rcmpneqi,"iii","") -BUILTIN(__builtin_HEXAGON_A4_rcmpeq,"iii","") -BUILTIN(__builtin_HEXAGON_A4_rcmpneq,"iii","") -BUILTIN(__builtin_HEXAGON_C2_bitsset,"iii","") -BUILTIN(__builtin_HEXAGON_C2_bitsclr,"iii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsset,"iii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsclr,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpeqi,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgti,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtui,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgei,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgeui,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmplt,"iii","") -BUILTIN(__builtin_HEXAGON_C2_cmpltu,"iii","") -BUILTIN(__builtin_HEXAGON_C2_bitsclri,"iii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsclri,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmpneqi,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmpltei,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmplteui,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmpneq,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmplte,"iii","") -BUILTIN(__builtin_HEXAGON_C4_cmplteu,"iii","") -BUILTIN(__builtin_HEXAGON_C2_and,"iii","") -BUILTIN(__builtin_HEXAGON_C2_or,"iii","") -BUILTIN(__builtin_HEXAGON_C2_xor,"iii","") -BUILTIN(__builtin_HEXAGON_C2_andn,"iii","") +BUILTIN(__builtin_HEXAGON_A4_cmphgtui,"iiUIi","") +BUILTIN(__builtin_HEXAGON_C2_cmpgti,"iiIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyi,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2uw_chop,"id","") +BUILTIN(__builtin_HEXAGON_A4_cmpheq,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_xacc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vrcnegh,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_extractup,"LLiLLiUIiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S4_ntstbit_r,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_w2sf,"fi","") BUILTIN(__builtin_HEXAGON_C2_not,"ii","") -BUILTIN(__builtin_HEXAGON_C2_orn,"iii","") -BUILTIN(__builtin_HEXAGON_C4_and_and,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_and_or,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_or_and,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_or_or,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_and_andn,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_and_orn,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_or_andn,"iiii","") -BUILTIN(__builtin_HEXAGON_C4_or_orn,"iiii","") -BUILTIN(__builtin_HEXAGON_C2_pxfer_map,"ii","") -BUILTIN(__builtin_HEXAGON_C2_any8,"ii","") -BUILTIN(__builtin_HEXAGON_C2_all8,"ii","") -BUILTIN(__builtin_HEXAGON_C2_vitpack,"iii","") -BUILTIN(__builtin_HEXAGON_C2_mux,"iiii","") -BUILTIN(__builtin_HEXAGON_C2_muxii,"iiii","") -BUILTIN(__builtin_HEXAGON_C2_muxir,"iiii","") -BUILTIN(__builtin_HEXAGON_C2_muxri,"iiii","") -BUILTIN(__builtin_HEXAGON_C2_vmux,"LLiiLLiLLi","") -BUILTIN(__builtin_HEXAGON_C2_mask,"LLii","") -BUILTIN(__builtin_HEXAGON_A2_vcmpbeq,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbeqi,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbeq_any,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpbgtu,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgtui,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgt,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgti,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbeq,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbeqi,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgtu,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgtui,"iii","") +BUILTIN(__builtin_HEXAGON_C2_tfrpr,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s0,"iii","") BUILTIN(__builtin_HEXAGON_A4_cmpbgt,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgti,"iii","") -BUILTIN(__builtin_HEXAGON_A2_vcmpheq,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmphgt,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmphgtu,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpheqi,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmphgti,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmphgtui,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_cmpheq,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgt,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgtu,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmpheqi,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgti,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgtui,"iii","") -BUILTIN(__builtin_HEXAGON_A2_vcmpweq,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpwgt,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpwgtu,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpweqi,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpwgti,"iLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpwgtui,"iLLii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_r_and,"iiii","") +BUILTIN(__builtin_HEXAGON_A4_rcmpneqi,"iiIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_nac,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_subacc,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_orp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_up,"Uiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_vh,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_vw,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_cmpbgtu,"iii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpbeq_any,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_cmpbgti,"iiIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p_nac,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_nac,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_addsp,"LLiiLLi","") +BUILTIN(__builtin_HEXAGON_S4_vxsubaddw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_vcmpheqi,"iLLiIi","") +BUILTIN(__builtin_HEXAGON_S4_vxsubaddh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_pmpyw,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_vsathb,"iLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_p_and,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_acc,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_pxorf,"iiii","") +BUILTIN(__builtin_HEXAGON_C2_cmpgei,"iiIi","") +BUILTIN(__builtin_HEXAGON_A2_vsubub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A4_vrminuw,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_F2_sffma,"ffff","") +BUILTIN(__builtin_HEXAGON_A2_absp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_all8,"ii","") +BUILTIN(__builtin_HEXAGON_A4_vrminuh,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_F2_sffma_lib,"ffff","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_bitsset,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpysip,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpysin,"iiUIi","") BUILTIN(__builtin_HEXAGON_A4_boundscheck,"iiLLi","") -BUILTIN(__builtin_HEXAGON_A4_tlbmatch,"iLLii","") -BUILTIN(__builtin_HEXAGON_C2_tfrpr,"ii","") -BUILTIN(__builtin_HEXAGON_C2_tfrrp,"ii","") +BUILTIN(__builtin_HEXAGON_M5_vrmpybuu,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_C4_fastcorner9,"iii","") -BUILTIN(__builtin_HEXAGON_C4_fastcorner9_not,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1rp,"iLLii","") +BUILTIN(__builtin_HEXAGON_A2_neg,"ii","") +BUILTIN(__builtin_HEXAGON_A2_subsat,"iii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r,"iii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_vnavgh,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_ud2df,"dLLi","") +BUILTIN(__builtin_HEXAGON_A2_vnavgw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_acc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S4_subi_lsr_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vzxthw,"LLii","") +BUILTIN(__builtin_HEXAGON_F2_sfadd,"fff","") +BUILTIN(__builtin_HEXAGON_A2_sub,"iii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2su_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2su_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyss_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_insert,"iiiUIiUIi","") +BUILTIN(__builtin_HEXAGON_S2_packhl,"LLiii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpwgti,"iLLiIi","") +BUILTIN(__builtin_HEXAGON_A2_vavguwr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r_and,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_svsubhs,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_l16_hl,"iii","") +BUILTIN(__builtin_HEXAGON_M4_and_and,"iiii","") +BUILTIN(__builtin_HEXAGON_F2_conv_d2df,"dLLi","") +BUILTIN(__builtin_HEXAGON_C2_cmpgtui,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A2_vconj,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_vw,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_vh,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_subh_l16_hl,"iii","") +BUILTIN(__builtin_HEXAGON_S4_vxsubaddhr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_clbp,"iLLi","") +BUILTIN(__builtin_HEXAGON_S2_deinterleave,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_any8,"ii","") +BUILTIN(__builtin_HEXAGON_S2_togglebit_r,"iii","") +BUILTIN(__builtin_HEXAGON_S2_togglebit_i,"iiUIi","") +BUILTIN(__builtin_HEXAGON_F2_conv_uw2sf,"fi","") +BUILTIN(__builtin_HEXAGON_S2_vsathb_nopack,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_cmacs_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_cmacs_s1,"LLiLLiii","") BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hh_s0,"iii","") BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_clrbit_r,"iii","") +BUILTIN(__builtin_HEXAGON_C4_or_andn,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r_nac,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p_acc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_vcmpwgtui,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_acc_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_acc_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_vrmaxh,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_vcmpbeq,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vcmphgt,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vnavgwcr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0c,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vavgwcr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p_xacc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_vrmaxw,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_vnavghr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_cmpyi_wh,"iLLii","") +BUILTIN(__builtin_HEXAGON_A2_tfrsi,"iIi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_acc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_svnavgh,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M2_vmac2,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A4_vcmphgtui,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_A2_svavgh,"iii","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_acc_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_acc_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A2_combine_hl,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_up,"iii","") +BUILTIN(__builtin_HEXAGON_A2_combine_hh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_negsat,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_A4_bitsplit,"LLiii","") +BUILTIN(__builtin_HEXAGON_A2_vabshsat,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyui,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_ll,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_and,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyul_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_nac,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_C2_cmplt,"iii","") +BUILTIN(__builtin_HEXAGON_M2_cmacr_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M4_or_and,"iiii","") +BUILTIN(__builtin_HEXAGON_M4_mpyrr_addi,"iUIiii","") +BUILTIN(__builtin_HEXAGON_S4_or_andi,"iiiIi","") BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hl_s0,"iii","") BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hl_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M4_mpyrr_addr,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mmachs_rs0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmachs_rs1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0c,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_F2_sffixupn,"fff","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s1,"LLiLLiii","") BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hh_s0,"iii","") BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vadduhs,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vsubuhs,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_hl,"iii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_hh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_xorp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_tfrpcp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_lh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hl,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_ll,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_zxtb,"ii","") +BUILTIN(__builtin_HEXAGON_A2_zxth,"ii","") +BUILTIN(__builtin_HEXAGON_A2_vnavgwr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_or_xor,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M5_vmacbsu,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_acc_s0,"LLiLLiii","") BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hl_s0,"iii","") BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hl_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_lh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_F2_sffms_lib,"ffff","") +BUILTIN(__builtin_HEXAGON_C4_cmpneqi,"iiIi","") +BUILTIN(__builtin_HEXAGON_M4_and_xor,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_sat,"iLLi","") BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_lh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s0,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_lh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A2_addsat,"iii","") +BUILTIN(__builtin_HEXAGON_A2_svavghs,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vrsadub_acc,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_bitsclri,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hl,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vradduh,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_addp_c,"LLiLLiLLiv*","") +BUILTIN(__builtin_HEXAGON_C2_xor,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_acc,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2ud_chop,"LLid","") +BUILTIN(__builtin_HEXAGON_C4_or_or,"iiii","") +BUILTIN(__builtin_HEXAGON_S4_vxaddsubhr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_vsathub,"iLLi","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2sf,"fd","") +BUILTIN(__builtin_HEXAGON_M2_hmmpyh_rs1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_hmmpyh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vavgwr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_tableidxh_goodsyntax,"iiiUIiUIi","") +BUILTIN(__builtin_HEXAGON_A2_sxth,"ii","") +BUILTIN(__builtin_HEXAGON_A2_sxtb,"ii","") +BUILTIN(__builtin_HEXAGON_C4_or_orn,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0c,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_sxtw,"LLii","") +BUILTIN(__builtin_HEXAGON_M2_vabsdiffh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_hmmpyl_s1,"iii","") +BUILTIN(__builtin_HEXAGON_S2_cl1p,"iLLi","") +BUILTIN(__builtin_HEXAGON_M2_vabsdiffw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_andnp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_vmux,"LLiiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_parityp,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_and,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_or,"iiiUIi","") BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_ll_s0,"iiii","") BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_ll_s1,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s0,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s1,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s0,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s1,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s0,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s1,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s0,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s1,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hl_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_F2_sfcmpeq,"iff","") +BUILTIN(__builtin_HEXAGON_A2_vaddb_map,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_nac,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_vcmpheq,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_clbnorm,"ii","") +BUILTIN(__builtin_HEXAGON_M2_cnacsc_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_cnacsc_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S4_subaddi,"iiIii","") BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hl_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s0,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s1,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s0,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s1,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s0,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s1,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s0,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s1,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpysmi,"iii","") -BUILTIN(__builtin_HEXAGON_M2_macsip,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_macsin,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyss_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyss_acc_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyss_nac_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_s0,"ULLiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_acc_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_nac_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_up,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hl_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_tstbit_r,"iii","") +BUILTIN(__builtin_HEXAGON_S4_vrcrotate,"LLiLLiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mmachs_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmachs_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_tstbit_i,"iiUIi","") BUILTIN(__builtin_HEXAGON_M2_mpy_up_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpy_up_s1_sat,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpyu_up,"Uiii","") -BUILTIN(__builtin_HEXAGON_M2_mpysu_up,"iii","") -BUILTIN(__builtin_HEXAGON_M2_dpmpyss_rnd_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M4_mac_up_s1_sat,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_nac_up_s1_sat,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_mpyi,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mpyui,"iii","") -BUILTIN(__builtin_HEXAGON_M2_maci,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_acci,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_accii,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_nacci,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_naccii,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_subacc,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_mpyrr_addr,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_mpyri_addr_u2,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_mpyri_addr,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_mpyri_addi,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_mpyrr_addi,"iiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmac2s_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmac2s_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2su_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2su_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmac2su_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmac2su_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0pack,"iii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1pack,"iii","") -BUILTIN(__builtin_HEXAGON_M2_vmac2,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vmac2es_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vmac2es_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vmac2es,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrmac_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrmpy_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_extractu_rp,"iiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmpyuh_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_vw,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s0,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M4_or_or,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s1,"Uiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s0,"Uiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p_acc,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s0,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_w2df,"di","") +BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_hl,"iii","") +BUILTIN(__builtin_HEXAGON_C2_cmpeqi,"iiIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_and,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vcnegh,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpweqi,"iLLiIi","") BUILTIN(__builtin_HEXAGON_M2_vdmpyrs_s0,"iLLiLLi","") BUILTIN(__builtin_HEXAGON_M2_vdmpyrs_s1,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vrmpybuu,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vrmacbuu,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vrmpybsu,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vrmacbsu,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vmpybuu,"LLiii","") -BUILTIN(__builtin_HEXAGON_M5_vmpybsu,"LLiii","") -BUILTIN(__builtin_HEXAGON_M5_vmacbuu,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M5_vmacbsu,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M5_vdmpybsu,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M5_vdmacbsu,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vdmacs_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vdmacs_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vdmpys_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_xor_xacc,"LLiLLiLLiLLi","") BUILTIN(__builtin_HEXAGON_M2_vdmpys_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s0,"iii","") -BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_cmacs_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmacs_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_vdmpys_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vavgubr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s1,"Uiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s0,"Uiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r_acc,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_cl0p,"iLLi","") +BUILTIN(__builtin_HEXAGON_S2_valignib,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_F2_sffixupd,"fff","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s0,"iii","") BUILTIN(__builtin_HEXAGON_M2_cmacsc_s0,"LLiLLiii","") BUILTIN(__builtin_HEXAGON_M2_cmacsc_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmpys_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmpys_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmpysc_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmpysc_s1,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_cnacs_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cnacs_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cnacsc_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cnacsc_s1,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpys_acc_s1,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1rp,"iLLii","") -BUILTIN(__builtin_HEXAGON_M2_mmacls_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacls_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmachs_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmachs_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyl_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyl_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyh_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyh_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacls_rs0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacls_rs1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmachs_rs0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmachs_rs1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_acc_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_acc_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_acc_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M4_vrmpyoh_acc_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_hmmpyl_rs1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_hmmpyh_rs1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_hmmpyl_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_hmmpyh_s1,"iii","") -BUILTIN(__builtin_HEXAGON_M2_mmaculs_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmaculs_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyul_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyul_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs1,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyul_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_ct1,"ii","") +BUILTIN(__builtin_HEXAGON_S2_ct0,"ii","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_nac_s0,"LLiLLiii","") BUILTIN(__builtin_HEXAGON_M2_mmpyul_rs1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_mmpyuh_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S4_ntstbit_i,"iiUIi","") +BUILTIN(__builtin_HEXAGON_F2_sffixupr,"ff","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_p_xor,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A2_vcmphgtu,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_andn,"iii","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0pack,"iii","") +BUILTIN(__builtin_HEXAGON_S4_addaddi,"iiiIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_A4_rcmpeqi,"iiIi","") +BUILTIN(__builtin_HEXAGON_M4_xor_and,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p_and,"LLiLLiLLiUIi","") BUILTIN(__builtin_HEXAGON_M2_mmpyuh_rs1,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0c,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0c,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_cmaci_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmacr_s0,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0c,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0c,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_cmpyi_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M2_cmpyr_s0,"LLiii","") -BUILTIN(__builtin_HEXAGON_M4_cmpyi_wh,"iLLii","") -BUILTIN(__builtin_HEXAGON_M4_cmpyr_wh,"iLLii","") -BUILTIN(__builtin_HEXAGON_M4_cmpyi_whc,"iLLii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_r_or,"iiii","") +BUILTIN(__builtin_HEXAGON_A4_round_ri,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A2_max,"iii","") +BUILTIN(__builtin_HEXAGON_A4_round_rr,"iii","") +BUILTIN(__builtin_HEXAGON_A4_combineii,"LLiIiUIi","") +BUILTIN(__builtin_HEXAGON_A4_combineir,"LLiIii","") +BUILTIN(__builtin_HEXAGON_C4_and_orn,"iiii","") +BUILTIN(__builtin_HEXAGON_M5_vmacbuu,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A4_rcmpeq,"iii","") BUILTIN(__builtin_HEXAGON_M4_cmpyr_whc,"iLLii","") -BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_i,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_r,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_i,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_r,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_i,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_r,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_vcrotate,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S4_vrcrotate_acc,"LLiLLiLLiii","") -BUILTIN(__builtin_HEXAGON_S4_vrcrotate,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_S2_vcnegh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_vrcnegh,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_M4_pmpyw,"LLiii","") -BUILTIN(__builtin_HEXAGON_M4_vpmpyh,"LLiii","") -BUILTIN(__builtin_HEXAGON_M4_pmpyw_acc,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_M4_vpmpyh_acc,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_A2_add,"iii","") -BUILTIN(__builtin_HEXAGON_A2_sub,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addsat,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subsat,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addi,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_acc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vzxtbh,"LLii","") +BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_r_sat,"iii","") +BUILTIN(__builtin_HEXAGON_A2_combinew,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_cmpyi_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p_or,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S4_ori_asl_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_C4_nbitsset,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s1,"Uiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s0,"Uiii","") BUILTIN(__builtin_HEXAGON_A2_addh_l16_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_l16_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_l16_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_l16_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_lh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_hh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_lh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_lh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_hh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_lh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_aslh,"ii","") -BUILTIN(__builtin_HEXAGON_A2_asrh,"ii","") -BUILTIN(__builtin_HEXAGON_A2_addp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_addpsat,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_addsp,"LLiiLLi","") -BUILTIN(__builtin_HEXAGON_A2_subp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_neg,"ii","") -BUILTIN(__builtin_HEXAGON_A2_negsat,"ii","") -BUILTIN(__builtin_HEXAGON_A2_abs,"ii","") -BUILTIN(__builtin_HEXAGON_A2_abssat,"ii","") -BUILTIN(__builtin_HEXAGON_A2_vconj,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_negp,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_absp,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_max,"iii","") -BUILTIN(__builtin_HEXAGON_A2_maxu,"Uiii","") -BUILTIN(__builtin_HEXAGON_A2_min,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_and,"iiii","") +BUILTIN(__builtin_HEXAGON_A4_modwrapu,"iii","") +BUILTIN(__builtin_HEXAGON_A4_rcmpneq,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_F2_sfimm_p,"fUIi","") +BUILTIN(__builtin_HEXAGON_F2_sfimm_n,"fUIi","") +BUILTIN(__builtin_HEXAGON_M4_cmpyr_wh,"iLLii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_and,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_vavgub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_conv_d2sf,"fLLi","") +BUILTIN(__builtin_HEXAGON_A2_vavguh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_cmpbeqi,"iiUIi","") +BUILTIN(__builtin_HEXAGON_F2_sfcmpuo,"iff","") +BUILTIN(__builtin_HEXAGON_A2_vavguw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_nac,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vsatwh_nopack,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_or,"LLiLLiLLii","") BUILTIN(__builtin_HEXAGON_A2_minu,"Uiii","") -BUILTIN(__builtin_HEXAGON_A2_maxp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_maxup,"ULLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_minp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_minup,"ULLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_tfr,"ii","") -BUILTIN(__builtin_HEXAGON_A2_tfrsi,"ii","") -BUILTIN(__builtin_HEXAGON_A2_tfrp,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_tfrpi,"LLii","") -BUILTIN(__builtin_HEXAGON_A2_zxtb,"ii","") -BUILTIN(__builtin_HEXAGON_A2_sxtb,"ii","") -BUILTIN(__builtin_HEXAGON_A2_zxth,"ii","") -BUILTIN(__builtin_HEXAGON_A2_sxth,"ii","") -BUILTIN(__builtin_HEXAGON_A2_combinew,"LLiii","") -BUILTIN(__builtin_HEXAGON_A4_combineri,"LLiii","") -BUILTIN(__builtin_HEXAGON_A4_combineir,"LLiii","") -BUILTIN(__builtin_HEXAGON_A2_combineii,"LLiii","") -BUILTIN(__builtin_HEXAGON_A2_combine_hh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_combine_hl,"iii","") -BUILTIN(__builtin_HEXAGON_A2_combine_lh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_combine_ll,"iii","") -BUILTIN(__builtin_HEXAGON_A2_tfril,"iii","") -BUILTIN(__builtin_HEXAGON_A2_tfrih,"iii","") -BUILTIN(__builtin_HEXAGON_A2_and,"iii","") -BUILTIN(__builtin_HEXAGON_A2_or,"iii","") -BUILTIN(__builtin_HEXAGON_A2_xor,"iii","") -BUILTIN(__builtin_HEXAGON_A2_not,"ii","") -BUILTIN(__builtin_HEXAGON_M2_xor_xacc,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_xor_xacc,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_andn,"iii","") -BUILTIN(__builtin_HEXAGON_A4_orn,"iii","") -BUILTIN(__builtin_HEXAGON_A4_andnp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_ornp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_addaddi,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_subaddi,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_and_and,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_and_andn,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_and_or,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_and_xor,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_or_and,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s1,"iii","") BUILTIN(__builtin_HEXAGON_M4_or_andn,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_or_or,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_or_xor,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_or_andix,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_or_andi,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_or_ori,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_xor_and,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_xor_or,"iiii","") -BUILTIN(__builtin_HEXAGON_M4_xor_andn,"iiii","") -BUILTIN(__builtin_HEXAGON_A2_subri,"iii","") -BUILTIN(__builtin_HEXAGON_A2_andir,"iii","") -BUILTIN(__builtin_HEXAGON_A2_orir,"iii","") -BUILTIN(__builtin_HEXAGON_A2_andp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_orp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_xorp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_notp,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_sxtw,"LLii","") -BUILTIN(__builtin_HEXAGON_A2_sat,"iLLi","") +BUILTIN(__builtin_HEXAGON_A2_minp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S4_or_andix,"iiiIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_F2_sfcmpge,"iff","") +BUILTIN(__builtin_HEXAGON_F2_sfmin,"fff","") +BUILTIN(__builtin_HEXAGON_F2_sfcmpgt,"iff","") +BUILTIN(__builtin_HEXAGON_M4_vpmpyh,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s0,"LLiii","") BUILTIN(__builtin_HEXAGON_A2_roundsat,"iLLi","") +BUILTIN(__builtin_HEXAGON_S2_ct1p,"iLLi","") +BUILTIN(__builtin_HEXAGON_S4_extract_rp,"iiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_or,"iiii","") +BUILTIN(__builtin_HEXAGON_C4_cmplteui,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S4_addi_lsr_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_A4_tfrcpp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_svw_trun,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_cmphgti,"iiIi","") +BUILTIN(__builtin_HEXAGON_A4_vrminh,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A4_vrminw,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A4_cmphgtu,"iii","") +BUILTIN(__builtin_HEXAGON_S2_insertp_rp,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vnavghcr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S4_subi_asl_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_vh,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vsubws,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_A2_sath,"ii","") -BUILTIN(__builtin_HEXAGON_A2_satuh,"ii","") -BUILTIN(__builtin_HEXAGON_A2_satub,"ii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p_xor,"LLiLLiLLii","") BUILTIN(__builtin_HEXAGON_A2_satb,"ii","") -BUILTIN(__builtin_HEXAGON_A2_vaddub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddb_map,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddubs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddhs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vadduhs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A5_vaddhubs,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vaddws,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_cmpltu,"iii","") +BUILTIN(__builtin_HEXAGON_S2_insertp,"LLiLLiLLiUIiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_nac,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_extractup_rp,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_S4_vxaddsubw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_vxsubaddw,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_S4_vxaddsubh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_vxsubaddh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_vxaddsubhr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_vxsubaddhr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_svavgh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svavghs,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svnavgh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svaddh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svaddhs,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svadduhs,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svsubh,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svsubhs,"iii","") -BUILTIN(__builtin_HEXAGON_A2_svsubuhs,"iii","") -BUILTIN(__builtin_HEXAGON_A2_vraddub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vraddub_acc,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vraddh,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vradduh,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubb_map,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_asrh,"ii","") +BUILTIN(__builtin_HEXAGON_S4_extractp_rp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_acc,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_C2_or,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyul_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_xor,"iii","") +BUILTIN(__builtin_HEXAGON_A2_add,"iii","") BUILTIN(__builtin_HEXAGON_A2_vsububs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubhs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubuhs,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vsubws,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vabsh,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vabshsat,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vabsw,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vabswsat,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vabsdiffw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_M2_vabsdiffh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_A2_vraddub_acc,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_sfinvsqrta,"ff","") +BUILTIN(__builtin_HEXAGON_S2_ct0p,"iLLi","") +BUILTIN(__builtin_HEXAGON_A2_svaddh,"iii","") +BUILTIN(__builtin_HEXAGON_S2_vcrotate,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_aslh,"ii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_lh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_ll,"iii","") +BUILTIN(__builtin_HEXAGON_M2_hmmpyl_rs1,"iii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_p,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_vsplatrh,"LLii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_r,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_hl,"iii","") +BUILTIN(__builtin_HEXAGON_S2_vsplatrb,"ii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_hh,"iii","") +BUILTIN(__builtin_HEXAGON_M2_cmpyr_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyss_rnd_s0,"iii","") +BUILTIN(__builtin_HEXAGON_C2_muxri,"iiIii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2es_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vmac2es_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_pxfer_map,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s1,"Uiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s0,"Uiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_or,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_p_nac,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_vaddw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_and,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_vaddh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_C2_cmpeqp,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_mpyri_addi,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_not,"ii","") +BUILTIN(__builtin_HEXAGON_S4_andi_lsr_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_macsip,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_tfrcrr,"ii","") +BUILTIN(__builtin_HEXAGON_M2_macsin,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_C2_orn,"iii","") +BUILTIN(__builtin_HEXAGON_M4_and_andn,"iiii","") +BUILTIN(__builtin_HEXAGON_F2_sfmpy,"fff","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_acc,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_vw,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_M4_and_or,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_vh,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_C2_mask,"LLii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_up_s1_sat,"iii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpbgt,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_M5_vrmacbsu,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_tableidxw_goodsyntax,"iiiUIiUIi","") BUILTIN(__builtin_HEXAGON_A2_vrsadub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vrsadub_acc,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavguh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavgh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavgw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgwr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavgwr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgwcr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavgwcr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavghcr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavghcr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavguw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavguwr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavgubr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavguhr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vavghr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vnavghr,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_round_ri,"iii","") -BUILTIN(__builtin_HEXAGON_A4_round_rr,"iii","") -BUILTIN(__builtin_HEXAGON_A4_round_ri_sat,"iii","") -BUILTIN(__builtin_HEXAGON_A4_round_rr_sat,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cround_ri,"iii","") -BUILTIN(__builtin_HEXAGON_A4_cround_rr,"iii","") -BUILTIN(__builtin_HEXAGON_A4_vrminh,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrmaxh,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrminuh,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrmaxuh,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrminw,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrmaxw,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrminuw,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A4_vrmaxuw,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_A2_vminb,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_tfrrcr,"ii","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpys_acc_s1,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_F2_dfcmpge,"idd","") +BUILTIN(__builtin_HEXAGON_M2_accii,"iiiIi","") +BUILTIN(__builtin_HEXAGON_A5_vaddhubs,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vmaxw,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_A2_vmaxb,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vminub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vmaxub,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vminh,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_A2_vmaxh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vminuh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vmaxuh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vminw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vmaxw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vminuw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vmaxuw,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_modwrapu,"iii","") -BUILTIN(__builtin_HEXAGON_F2_sfadd,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sfsub,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sfmpy,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sffma,"ffff","") -BUILTIN(__builtin_HEXAGON_F2_sffma_sc,"ffffi","") -BUILTIN(__builtin_HEXAGON_F2_sffms,"ffff","") -BUILTIN(__builtin_HEXAGON_F2_sffma_lib,"ffff","") -BUILTIN(__builtin_HEXAGON_F2_sffms_lib,"ffff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpeq,"iff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpgt,"iff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpge,"iff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpuo,"iff","") -BUILTIN(__builtin_HEXAGON_F2_sfmax,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sfmin,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sfclass,"ifi","") -BUILTIN(__builtin_HEXAGON_F2_sfimm_p,"fi","") -BUILTIN(__builtin_HEXAGON_F2_sfimm_n,"fi","") -BUILTIN(__builtin_HEXAGON_F2_sffixupn,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sffixupd,"fff","") -BUILTIN(__builtin_HEXAGON_F2_sffixupr,"ff","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpeq,"idd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpgt,"idd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpge,"idd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpuo,"idd","") -BUILTIN(__builtin_HEXAGON_F2_dfclass,"idi","") -BUILTIN(__builtin_HEXAGON_F2_dfimm_p,"di","") -BUILTIN(__builtin_HEXAGON_F2_dfimm_n,"di","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2df,"df","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2sf,"fd","") -BUILTIN(__builtin_HEXAGON_F2_conv_uw2sf,"fi","") -BUILTIN(__builtin_HEXAGON_F2_conv_uw2df,"di","") -BUILTIN(__builtin_HEXAGON_F2_conv_w2sf,"fi","") -BUILTIN(__builtin_HEXAGON_F2_conv_w2df,"di","") -BUILTIN(__builtin_HEXAGON_F2_conv_ud2sf,"fLLi","") -BUILTIN(__builtin_HEXAGON_F2_conv_ud2df,"dLLi","") -BUILTIN(__builtin_HEXAGON_F2_conv_d2sf,"fLLi","") -BUILTIN(__builtin_HEXAGON_F2_conv_d2df,"dLLi","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2uw,"if","") +BUILTIN(__builtin_HEXAGON_S2_vsxthw,"LLii","") +BUILTIN(__builtin_HEXAGON_S4_andi_asl_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p_nac,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_xor,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_C2_cmpgt,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2d_chop,"LLid","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s1,"iiii","") BUILTIN(__builtin_HEXAGON_F2_conv_sf2w,"if","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_or,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_F2_sfclass,"ifUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M4_xor_andn,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_addasl_rrri,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_M5_vdmpybsu,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_addi,"iiIi","") +BUILTIN(__builtin_HEXAGON_A2_addp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1pack,"iii","") +BUILTIN(__builtin_HEXAGON_S4_clbpnorm,"iLLi","") +BUILTIN(__builtin_HEXAGON_A4_round_rr_sat,"iii","") +BUILTIN(__builtin_HEXAGON_M2_nacci,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_shuffeh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_and,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2uw,"if","") +BUILTIN(__builtin_HEXAGON_A2_vsubh,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_F2_conv_sf2ud,"LLif","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2d,"LLif","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2uw,"id","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2w,"id","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2ud,"LLid","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2d,"LLid","") +BUILTIN(__builtin_HEXAGON_A2_vsubw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vcmpwgt,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_xor_or,"iiii","") BUILTIN(__builtin_HEXAGON_F2_conv_sf2uw_chop,"if","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2w_chop,"if","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2ud_chop,"LLif","") -BUILTIN(__builtin_HEXAGON_F2_conv_sf2d_chop,"LLif","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2uw_chop,"id","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2w_chop,"id","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2ud_chop,"LLid","") -BUILTIN(__builtin_HEXAGON_F2_conv_df2d_chop,"LLid","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_vw,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_vsatwuh_nopack,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_vh,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_svsubuhs,"iii","") +BUILTIN(__builtin_HEXAGON_M5_vmpybsu,"LLiii","") +BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_ll,"iii","") +BUILTIN(__builtin_HEXAGON_C4_and_and,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s0,"iiii","") BUILTIN(__builtin_HEXAGON_S2_lsr_r_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_acc,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_r,"iii","") +BUILTIN(__builtin_HEXAGON_A4_subp_c,"LLiLLiLLiv*","") +BUILTIN(__builtin_HEXAGON_A2_vsubhs,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_vitpack,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vavguhr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_vsplicerb,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_C4_nbitsclr,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vcmpbgtu,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_cmpys_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_cmpys_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_F2_dfcmpuo,"idd","") +BUILTIN(__builtin_HEXAGON_S2_shuffob,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_and,"iii","") +BUILTIN(__builtin_HEXAGON_S5_popcountp,"iLLi","") +BUILTIN(__builtin_HEXAGON_S4_extractp,"LLiLLiUIiUIi","") +BUILTIN(__builtin_HEXAGON_S2_cl0,"ii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpbgti,"iLLiIi","") +BUILTIN(__builtin_HEXAGON_M2_mmacls_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmacls_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C4_cmpneq,"iii","") +BUILTIN(__builtin_HEXAGON_M2_vmac2es,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vdmacs_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vdmacs_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s0,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s1,"ULLiii","") +BUILTIN(__builtin_HEXAGON_S2_clb,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_maci,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_vmaxuh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_bitspliti,"LLiiUIi","") +BUILTIN(__builtin_HEXAGON_A2_vmaxub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s0,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s1,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_vrmac_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s0,"iii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r_sat,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2d,"LLif","") BUILTIN(__builtin_HEXAGON_S2_asr_r_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_nac,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_F2_dfimm_n,"dUIi","") +BUILTIN(__builtin_HEXAGON_A4_cmphgt,"iii","") +BUILTIN(__builtin_HEXAGON_F2_dfimm_p,"dUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_r,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_mpyri_addr_u2,"iiUIii","") +BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_i,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r_or,"iiii","") +BUILTIN(__builtin_HEXAGON_M5_vrmacbuu,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vspliceib,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyss_acc_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_cnacs_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_cnacs_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A2_maxu,"Uiii","") +BUILTIN(__builtin_HEXAGON_A2_maxp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_andir,"iiIi","") +BUILTIN(__builtin_HEXAGON_F2_sfrecipa,"fff","") +BUILTIN(__builtin_HEXAGON_A2_combineii,"LLiIiIi","") +BUILTIN(__builtin_HEXAGON_A4_orn,"iii","") +BUILTIN(__builtin_HEXAGON_A4_cmpbgtui,"iiUIi","") BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p_and,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpbeqi,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_r,"iii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_p,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_or,"iii","") +BUILTIN(__builtin_HEXAGON_F2_dfcmpeq,"idd","") +BUILTIN(__builtin_HEXAGON_C2_cmpeq,"iii","") +BUILTIN(__builtin_HEXAGON_A2_tfrp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_C4_and_andn,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_vsathub_nopack,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_satuh,"ii","") +BUILTIN(__builtin_HEXAGON_A2_satub,"ii","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_S4_or_ori,"iiiIi","") +BUILTIN(__builtin_HEXAGON_C4_fastcorner9_not,"iii","") +BUILTIN(__builtin_HEXAGON_A2_tfrih,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A2_tfril,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M4_mpyri_addr,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_vtrunehb,"iLLi","") +BUILTIN(__builtin_HEXAGON_A2_vabsw,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vabsh,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_sfsub,"fff","") +BUILTIN(__builtin_HEXAGON_C2_muxii,"iiIiIi","") +BUILTIN(__builtin_HEXAGON_C2_muxir,"iiiIi","") +BUILTIN(__builtin_HEXAGON_A2_swiz,"ii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_and,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s0,"iii","") +BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s1,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vraddub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_tlbmatch,"iLLii","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2w_chop,"id","") +BUILTIN(__builtin_HEXAGON_A2_and,"iii","") BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_p_xor,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_p_xor,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_xor,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_xor,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_r_sat,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_r_sat,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_acc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p_acc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_nac,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p_nac,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_xacc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_xacc,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_xacc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p_xacc,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_and,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_or,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p_and,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_p_or,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_r_sat,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_rnd,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S4_lsli,"iii","") -BUILTIN(__builtin_HEXAGON_S2_addasl_rrri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_andi_asl_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_ori_asl_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_addi_asl_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_subi_asl_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_andi_lsr_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_ori_lsr_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_addi_lsr_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S4_subi_lsr_ri,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_valignib,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_valignrb,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_vspliceib,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_vsplicerb,"LLiLLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_vsplatrh,"LLii","") -BUILTIN(__builtin_HEXAGON_S2_vsplatrb,"ii","") -BUILTIN(__builtin_HEXAGON_S2_insert,"iiiii","") -BUILTIN(__builtin_HEXAGON_S2_tableidxb_goodsyntax,"iiiii","") -BUILTIN(__builtin_HEXAGON_S2_tableidxh_goodsyntax,"iiiii","") -BUILTIN(__builtin_HEXAGON_S2_tableidxw_goodsyntax,"iiiii","") -BUILTIN(__builtin_HEXAGON_S2_tableidxd_goodsyntax,"iiiii","") -BUILTIN(__builtin_HEXAGON_A4_bitspliti,"LLiii","") -BUILTIN(__builtin_HEXAGON_A4_bitsplit,"LLiii","") -BUILTIN(__builtin_HEXAGON_S4_extract,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_extractu,"iiii","") -BUILTIN(__builtin_HEXAGON_S2_insertp,"LLiLLiLLiii","") -BUILTIN(__builtin_HEXAGON_S4_extractp,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_S2_extractup,"LLiLLiii","") -BUILTIN(__builtin_HEXAGON_S2_insert_rp,"iiiLLi","") -BUILTIN(__builtin_HEXAGON_S4_extract_rp,"iiLLi","") -BUILTIN(__builtin_HEXAGON_S2_extractu_rp,"iiLLi","") -BUILTIN(__builtin_HEXAGON_S2_insertp_rp,"LLiLLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S4_extractp_rp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_extractup_rp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_tstbit_i,"iii","") -BUILTIN(__builtin_HEXAGON_S4_ntstbit_i,"iii","") -BUILTIN(__builtin_HEXAGON_S2_setbit_i,"iii","") -BUILTIN(__builtin_HEXAGON_S2_togglebit_i,"iii","") -BUILTIN(__builtin_HEXAGON_S2_clrbit_i,"iii","") -BUILTIN(__builtin_HEXAGON_S2_tstbit_r,"iii","") -BUILTIN(__builtin_HEXAGON_S4_ntstbit_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_setbit_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_togglebit_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_clrbit_r,"iii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,"iLLii","") -BUILTIN(__builtin_HEXAGON_S5_asrhub_sat,"iLLii","") -BUILTIN(__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_vh,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_i_svw_trun,"iLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_svw_trun,"iLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_i_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_i_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asr_r_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_asl_r_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsr_r_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_lsl_r_vw,"LLiLLii","") -BUILTIN(__builtin_HEXAGON_S2_vrndpackwh,"iLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_S4_extract,"iiUIiUIi","") +BUILTIN(__builtin_HEXAGON_A2_vcmpweq,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_acci,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_acc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_or,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_F2_conv_ud2sf,"fLLi","") +BUILTIN(__builtin_HEXAGON_A2_tfr,"ii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_or,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A2_subri,"iIii","") +BUILTIN(__builtin_HEXAGON_A4_vrmaxuw,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M5_vmpybuu,"LLiii","") +BUILTIN(__builtin_HEXAGON_A4_vrmaxuh,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_vw,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A2_vavgw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_brev,"ii","") +BUILTIN(__builtin_HEXAGON_A2_vavgh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_clrbit_i,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_vh,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_or,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_nac,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s1,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyl_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmpyl_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_naccii,"iiiIi","") BUILTIN(__builtin_HEXAGON_S2_vrndpackwhs,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_vsxtbh,"LLii","") -BUILTIN(__builtin_HEXAGON_S2_vzxtbh,"LLii","") -BUILTIN(__builtin_HEXAGON_S2_vsathub,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_svsathub,"ii","") -BUILTIN(__builtin_HEXAGON_S2_svsathb,"ii","") -BUILTIN(__builtin_HEXAGON_S2_vsathb,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_vtrunohb,"iLLi","") BUILTIN(__builtin_HEXAGON_S2_vtrunewh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyss_nac_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M4_mac_up_s1_sat,"iiii","") +BUILTIN(__builtin_HEXAGON_S4_vrcrotate_acc,"LLiLLiLLiiUIi","") +BUILTIN(__builtin_HEXAGON_F2_conv_uw2df,"di","") +BUILTIN(__builtin_HEXAGON_A2_vaddubs,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_r_acc,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_orir,"iiIi","") +BUILTIN(__builtin_HEXAGON_A2_andp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_lfsp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_min,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpysmi,"iiIi","") +BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_r,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_svw_trun,"iLLii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyh_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmpyh_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2df,"df","") +BUILTIN(__builtin_HEXAGON_S2_vtrunohb,"iLLi","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2d_chop,"LLif","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2w,"id","") +BUILTIN(__builtin_HEXAGON_S5_asrhub_sat,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_xacc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2d,"LLid","") +BUILTIN(__builtin_HEXAGON_M2_mmaculs_s1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmaculs_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_svadduhs,"iii","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2w_chop,"if","") +BUILTIN(__builtin_HEXAGON_S2_svsathub,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_setbit_r,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vavghr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_sffma_sc,"ffffi","") +BUILTIN(__builtin_HEXAGON_F2_dfclass,"idUIi","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2ud,"LLid","") +BUILTIN(__builtin_HEXAGON_F2_conv_df2uw,"id","") +BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s0,"iii","") +BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s1,"iii","") +BUILTIN(__builtin_HEXAGON_C4_cmpltei,"iiIi","") +BUILTIN(__builtin_HEXAGON_C4_cmplteu,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vsubb_map,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_subh_l16_ll,"iii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M2_vrmpy_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_A2_minup,"ULLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_valignrb,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_S2_asr_r_p_acc,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vaddub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_combine_lh,"iii","") +BUILTIN(__builtin_HEXAGON_M5_vdmacbsu,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_combine_ll,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s0,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0c,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_rnd,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A2_addpsat,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_svaddhs,"iii","") +BUILTIN(__builtin_HEXAGON_S4_ori_lsr_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s0,"iii","") +BUILTIN(__builtin_HEXAGON_A2_vminw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vminh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vminb,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_i,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s0,"ULLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s1,"ULLiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_r_or,"iiii","") +BUILTIN(__builtin_HEXAGON_S4_lsli,"iIii","") +BUILTIN(__builtin_HEXAGON_S2_lsl_r_vw,"LLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s1,"iii","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_s0,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M4_vrmpyeh_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_vraddh,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_tfrrp,"ii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s1,"iiii","") BUILTIN(__builtin_HEXAGON_S2_vtrunowh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_vtrunehb,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_vsxthw,"LLii","") -BUILTIN(__builtin_HEXAGON_S2_vzxthw,"LLii","") -BUILTIN(__builtin_HEXAGON_S2_vsatwh,"iLLi","") +BUILTIN(__builtin_HEXAGON_A2_abs,"ii","") +BUILTIN(__builtin_HEXAGON_A4_cmpbeq,"iii","") +BUILTIN(__builtin_HEXAGON_A2_negp,"LLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_r_sat,"iiUIi","") +BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_hl,"iii","") BUILTIN(__builtin_HEXAGON_S2_vsatwuh,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_packhl,"LLiii","") -BUILTIN(__builtin_HEXAGON_A2_swiz,"ii","") -BUILTIN(__builtin_HEXAGON_S2_vsathub_nopack,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_vsathb_nopack,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_vsatwh_nopack,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_vsatwuh_nopack,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_shuffob,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_F2_dfcmpgt,"idd","") +BUILTIN(__builtin_HEXAGON_S2_svsathb,"ii","") +BUILTIN(__builtin_HEXAGON_C2_cmpgtup,"iLLiLLi","") +BUILTIN(__builtin_HEXAGON_A4_cround_ri,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S4_clbpaddi,"iLLiIi","") +BUILTIN(__builtin_HEXAGON_A4_cround_rr,"iii","") +BUILTIN(__builtin_HEXAGON_C2_mux,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_s0,"ULLiii","") BUILTIN(__builtin_HEXAGON_S2_shuffeb,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_shuffoh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_shuffeh,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S5_popcountp,"iLLi","") +BUILTIN(__builtin_HEXAGON_A2_vminuw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vaddhs,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_insert_rp,"iiiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vminuh,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vminub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_extractu,"iiUIiUIi","") +BUILTIN(__builtin_HEXAGON_A2_svsubh,"iii","") +BUILTIN(__builtin_HEXAGON_S4_clbaddi,"iiIi","") +BUILTIN(__builtin_HEXAGON_F2_sffms,"ffff","") +BUILTIN(__builtin_HEXAGON_S2_vsxtbh,"LLii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A2_subp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s1,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s0,"LLiLLiLLi","") BUILTIN(__builtin_HEXAGON_S4_parity,"iii","") -BUILTIN(__builtin_HEXAGON_S2_parityp,"iLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_lfsp,"LLiLLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_clbnorm,"ii","") -BUILTIN(__builtin_HEXAGON_S4_clbaddi,"iii","") -BUILTIN(__builtin_HEXAGON_S4_clbpnorm,"iLLi","") -BUILTIN(__builtin_HEXAGON_S4_clbpaddi,"iLLii","") -BUILTIN(__builtin_HEXAGON_S2_clb,"ii","") -BUILTIN(__builtin_HEXAGON_S2_cl0,"ii","") -BUILTIN(__builtin_HEXAGON_S2_cl1,"ii","") -BUILTIN(__builtin_HEXAGON_S2_clbp,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_cl0p,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_cl1p,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_brev,"ii","") -BUILTIN(__builtin_HEXAGON_S2_brevp,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_ct0,"ii","") -BUILTIN(__builtin_HEXAGON_S2_ct1,"ii","") -BUILTIN(__builtin_HEXAGON_S2_ct0p,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_ct1p,"iLLi","") -BUILTIN(__builtin_HEXAGON_S2_interleave,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_S2_deinterleave,"LLiLLi","") -BUILTIN(__builtin_HEXAGON_prefetch,"vv*","") -BUILTIN(__builtin_HEXAGON_Y2_dccleana,"vv*","") -BUILTIN(__builtin_HEXAGON_Y2_dccleaninva,"vv*","") -BUILTIN(__builtin_HEXAGON_Y2_dcinva,"vv*","") -BUILTIN(__builtin_HEXAGON_Y2_dczeroa,"vv*","") -BUILTIN(__builtin_HEXAGON_Y4_l2fetch,"vv*Ui","") -BUILTIN(__builtin_HEXAGON_Y5_l2fetch,"vv*LLUi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_S4_addi_asl_ri,"iUIiiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_r_nac,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_A4_cmpheqi,"iiIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_xor,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_F2_conv_sf2ud_chop,"LLif","") +BUILTIN(__builtin_HEXAGON_C2_cmpgeui,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_asl_r_p_and,"LLiLLiLLii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_lh,"iii","") +BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_ll,"iii","") +BUILTIN(__builtin_HEXAGON_M4_nac_up_s1_sat,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s1,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_A4_round_ri_sat,"iiUIi","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_vavghcr,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmacls_rs0,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_mmacls_rs1,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M2_cmaci_s0,"LLiLLiii","") +BUILTIN(__builtin_HEXAGON_S2_setbit_i,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S2_asl_i_p_or,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_andn,"iii","") +BUILTIN(__builtin_HEXAGON_M5_vrmpybsu,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S2_vrndpackwh,"iLLi","") +BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_r,"LLiLLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_vmaxuw,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_bitsclr,"iii","") +BUILTIN(__builtin_HEXAGON_M2_xor_xacc,"iiii","") +BUILTIN(__builtin_HEXAGON_A4_vcmpbgtui,"iLLiUIi","") +BUILTIN(__builtin_HEXAGON_A4_ornp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A2_tfrpi,"LLiIi","") +BUILTIN(__builtin_HEXAGON_C4_and_or,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s1,"iiii","") +BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s0,"iiii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_ll,"iii","") +BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_lh,"iii","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2su_s1,"LLiii","") +BUILTIN(__builtin_HEXAGON_M2_vmpy2su_s0,"LLiii","") +BUILTIN(__builtin_HEXAGON_S2_asr_i_p_acc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_C4_nbitsclri,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_vh,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_xacc,"LLiLLiLLiUIi","") + +// V55 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_A5_ACS,"LLiLLiLLiLLi","") + +// V60 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_S6_rol_i_p_and,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r_xacc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r_and,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r_acc,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_p_xacc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_p,"LLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_p_nac,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_p_acc,"LLiLLiLLiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r_or,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r,"iiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_r_nac,"iiiUIi","") +BUILTIN(__builtin_HEXAGON_S6_rol_i_p_or,"LLiLLiLLiUIi","") + +// V62 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_S6_vtrunehb_ppp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_V6_ldntnt0,"V16ii","") +BUILTIN(__builtin_HEXAGON_M6_vabsdiffub,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S6_vtrunohb_ppp,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_M6_vabsdiffb,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_A6_vminub_RdP,"LLiLLiLLi","") +BUILTIN(__builtin_HEXAGON_S6_vsplatrbp,"LLii","") + +// V65 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_A6_vcmpbeq_notany,"iLLiLLi","") + +// V66 Scalar Instructions. + +BUILTIN(__builtin_HEXAGON_F2_dfsub,"ddd","") +BUILTIN(__builtin_HEXAGON_F2_dfadd,"ddd","") +BUILTIN(__builtin_HEXAGON_M2_mnaci,"iiii","") +BUILTIN(__builtin_HEXAGON_S2_mask,"iUIiUIi","") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r,"iii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p,"LLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r_acc,"iiii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p_acc,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r_nac,"iiii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p_nac,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r_xacc,"iiii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p_xacc,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r_and,"iiii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_r_or,"iiii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p_and,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S6_rol_i_p_or,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_S2_cabacencbin,"LLiLLiLLii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_valignb,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_valignb_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlalignb,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlalignb_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_valignbi,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_valignbi_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlalignbi,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlalignbi_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vror,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vror_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackub,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackub_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackb,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackb_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackuh,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackuh_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackh,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackh_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackob,"V32iV32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackob_128B,"V64iV64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackoh,"V32iV32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vunpackoh_128B,"V64iV64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackeb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackeb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackeh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackeh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackob,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackob_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackoh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackoh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackhub_sat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackhub_sat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackhb_sat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackhb_sat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackwuh_sat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackwuh_sat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackwh_sat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpackwh_sat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vzb,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vzb_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsb,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsb_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vzh,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vzh_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsh,"V32iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsh_128B,"V64iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat,"V16iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_128B,"V32iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_acc,"V16iV16iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_acc_128B,"V32iV32iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat,"V16iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_128B,"V32iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_acc,"V16iV16iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_acc_128B,"V32iV32iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyb,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyb_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyb_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyb_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpybus,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpybus_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpybus_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpybus_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyhb,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybv_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybv_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubi,"V32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_128B,"V64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_acc,"V32iV32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_acc_128B,"V64iV64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybus,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybus_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybus_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybus_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusi,"V32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_128B,"V64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_acc,"V32iV32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_acc_128B,"V64iV64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdsaduh,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdsaduh_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdsaduh_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdsaduh_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrsadubi,"V32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrsadubi_128B,"V64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrsadubi_acc,"V32iV32iV32iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrsadubi_acc_128B,"V64iV64iV64iii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrw,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrw_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslw,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslw_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrw,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrw_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslwv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslwv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrwv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrwv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrh,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrh_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslh,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslh_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrh,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrh_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslhv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslhv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrhv,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlsrhv_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwh,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwh_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwhsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwhsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwhrndsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwhrndsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwuhsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrwuhsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundwh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundwh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundwuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundwuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhubsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhubsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhubrndsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhubrndsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhbrndsat,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrhbrndsat_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundhb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundhb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundhub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vroundhub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslw_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaslw_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrw_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vasrw_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddb_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddb_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubb_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubb_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddh_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddh_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubh_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubh_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddw_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddw_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubw_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubw_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwsat,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwsat_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwsat_dv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwsat_dv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgubrnd,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgubrnd_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavguh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavguh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavguhrnd,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavguhrnd_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavghrnd,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavghrnd_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgwrnd,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vavgwrnd_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsdiffw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnavgub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubh,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddubh_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububh,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsububh_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhw,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhw_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhw,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhw_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhw,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vadduhw_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhw,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubuhw_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vd0,"V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vd0_128B,"V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddbq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddbq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubbq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubbq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddbnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddbnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubbnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubbnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddhnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubhnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vaddwnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwnq,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsubwnq_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsh,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsh_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsh_sat,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsh_sat_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsw,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsw_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsw_sat,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vabsw_sat_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybv,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybv_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybv_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybv_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyubv,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyubv_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyubv_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyubv_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybusv,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybusv_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybusv_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybusv_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabusv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabusv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuuv,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuuv_128B,"V64iV64iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhv,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhv_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhv_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhv_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhv,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhvsrs,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhvsrs_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhus,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhus_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhus_acc,"V32iV32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhus_acc_128B,"V64iV64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyih,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyih_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyih_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyih_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyewuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_sacc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_sacc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_sacc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_sacc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyieoh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyieoh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiowh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiowh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewh_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewh_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_acc,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_acc_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyub,"V32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyub_128B,"V64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyub_acc,"V32iV32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyub_acc_128B,"V64iV64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybus,"V32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybus_128B,"V64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybus_acc,"V32iV32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpybus_acc_128B,"V64iV64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabus,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabus_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabus_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpabus_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpahb,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpahb_128B,"V64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpahb_acc,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpahb_acc_128B,"V64iV64iV64ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyh,"V32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyh_128B,"V64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhsat_acc,"V32iV32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhsat_acc_128B,"V64iV64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhss,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhss_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhsrs,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyhsrs_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuh,"V32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuh_128B,"V64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuh_acc,"V32iV32iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuh_acc_128B,"V64iV64iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyihb,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyihb_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyihb_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyihb_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwb,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwh,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vand,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vand_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vor,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vor_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vxor,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vxor_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnot,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnot_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandqrt,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandqrt_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandqrt_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandqrt_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandvrt,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandvrt_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandvrt_acc,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vandvrt_acc_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtw_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqw_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgth_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqh_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtb_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_veqb_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuw_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtuh_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_and,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_and_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_or,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_or_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_xor,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vgtub_xor_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_or,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_or_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_and,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_and_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_not,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_not_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_xor,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_xor_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_and_n,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_and_n_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_or_n,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_or_n_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_scalar2,"V16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_pred_scalar2_128B,"V32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmux,"V16iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmux_128B,"V32iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vswap,"V32iV16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vswap_128B,"V64iV32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminuh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminuh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaxw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminw,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vminw_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsathub,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsathub_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsatwh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vsatwh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffeb,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffeb_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffob,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffob_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufeh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufeh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoh,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoh_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffvdd,"V32iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffvdd_128B,"V64iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealvdd,"V32iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealvdd_128B,"V64iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoeh,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoeh_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoeb,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshufoeb_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealh,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealh_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealb,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealb_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealb4w,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdealb4w_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffh,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffh_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffb,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vshuffb_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_extractw,"iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_extractw_128B,"iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vinsertwr,"V16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vinsertwr_128B,"V32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_lvsplatw,"V16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_lvsplatw_128B,"V32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vassign,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vassign_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcombine,"V32iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcombine_128B,"V64iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdelta,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vdelta_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrdelta,"V16iV16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vrdelta_128B,"V32iV32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcl0w,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcl0w_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcl0h,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vcl0h_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnormamtw,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnormamtw_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnormamth,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vnormamth_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpopcounth,"V16iV16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vpopcounth_128B,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb,"V16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_128B,"V32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracc,"V16iV16iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracc_128B,"V32iV32iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh,"V32iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_128B,"V64iV32iV32ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracc,"V32iV32iV16iV16ii","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracc_128B,"V64iV64iV32iV32ii","v:60:") +// V60 HVX Instructions. -BUILTIN(__builtin_HEXAGON_V6_hi,"V16iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_lo,"V16iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_hi_128B,"V32iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_lo_128B,"V32iV64i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vassignp,"V32iV32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vassignp_128B,"V64iV64i","v:60:") +BUILTIN(__builtin_HEXAGON_V6_veqb_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vminub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vminub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaslw_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vaslw_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhvsrs,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhvsrs_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsathub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsathub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddh_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddh_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusi,"V32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_128B,"V64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vshufoh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshufoh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat,"V16iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_128B,"V32iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vrsadubi_acc,"V32iV32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrsadubi_acc_128B,"V64iV64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vnavgw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavgub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavgubrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgubrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vroundhb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vroundhb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vsububsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsububsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpabus_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabus_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vmux,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmux_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhus,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhus_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vpackeb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackeb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavghrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavghrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vtran2x2_map,"V16iV16iv*i","") +BUILTIN(__builtin_HEXAGON_V6_vtran2x2_map_128B,"V32iV32iv*i","") +BUILTIN(__builtin_HEXAGON_V6_vdelta,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdelta_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyhb,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vpackob,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackob_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vtmpybus_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpybus_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrw_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrw_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_pred_or,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_or_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_lo,"V16iV32i","") +BUILTIN(__builtin_HEXAGON_V6_lo_128B,"V32iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vsubb_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubb_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwh,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwb,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_ldu0,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_ldu0_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgth_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgth_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavgh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlalignb,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlalignb_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsh,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsh_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_pred_and_n,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_and_n_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsb,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsb_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vroundwuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vroundwuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrhv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vasrhv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffh,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffh_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vnormamth,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnormamth_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vavguh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavguh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrwv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrwv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrhv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrhv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat,"V16iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_128B,"V32iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vzh,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vzh_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhv_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhv_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vshufoeh,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshufoeh_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_veqh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuuv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuuv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwhsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrwhsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vminuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vminuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vror,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vror_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_sacc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_sacc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsh_sat,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsh_sat_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_pred_or_n,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_or_n_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdealb,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdealb_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybusv,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybusv_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vzb,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vzb_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddbq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddbq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrhubrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrhubrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrhubsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrhubsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vshufoeb,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshufoeb_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vpackhub_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackhub_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwh_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyb,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyb_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabusv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpabusv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_pred_and,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_and_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vpackwuh_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackwuh_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vswap,"V32iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vswap_128B,"V64iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaslw,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vaslw_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vpackhb_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackhb_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyih_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyih_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffvdd,"V32iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vshuffvdd_128B,"V64iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddb_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddb_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackub,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackub_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh,"V32iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_128B,"V64iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyieoh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyieoh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_extractw,"iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_extractw_128B,"iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vavgwrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgwrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyub,"V32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyub_128B,"V64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuh,"V32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuh_128B,"V64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vunpackob,"V32iV32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackob_128B,"V64iV64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpahb,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpahb_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_veqw_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vandqrt,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandqrt_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vxor,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vxor_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwhrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrwhrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhsat_acc,"V32iV32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhsat_acc_128B,"V64iV64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybus_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybus_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubhw,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhw_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdealb4w,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdealb4w_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_sacc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_sacc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybv,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybv_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffob,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffob_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyub_acc,"V32iV32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyub_acc_128B,"V64iV64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vnormamtw,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnormamtw_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackuh,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackuh_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackoh,"V32iV32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackoh_128B,"V64iV64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsat_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyubv,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyubv_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhss,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhss_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_hi,"V16iV32i","") +BUILTIN(__builtin_HEXAGON_V6_hi_128B,"V32iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwuhsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrwuhsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_veqw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdsaduh,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdsaduh_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubw_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubw_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyih,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyih_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyb_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyb_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybus,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybus_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpybus_acc,"V32iV32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpybus_acc_128B,"V64iV64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgth_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgth_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_acc,"V32iV32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_acc_128B,"V64iV64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vabsw,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsw_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrw,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlsrw_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vabsh,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsh_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrh,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlsrh_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_valignb,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_valignb_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubhq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubhq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vpackoh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackoh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhvsat_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybv_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybv_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vcombine,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vcombine_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vandqrt_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandqrt_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vaslhv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaslhv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vinsertwr,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vinsertwr_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubh_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubh_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffb,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffb_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vand,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vand_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhv,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhv_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_acc,"V16iV16iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsuisat_acc_128B,"V32iV32iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vsububsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsububsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdsaduh_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdsaduh_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuh_acc,"V32iV32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuh_acc_128B,"V64iV64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vcl0h,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vcl0h_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhus_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhus_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybv_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybv_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrsadubi,"V32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrsadubi_128B,"V64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vshufeh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshufeh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyewuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhsrs,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyhsrs_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_dv_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddubh,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubh_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrwh,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrwh_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_ld0,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_ld0_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_vpopcounth,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpopcounth_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldnt0,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_ldnt0_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgth_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgth_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vpackeh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackeh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyh,"V32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyh_128B,"V64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vminh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vminh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_pred_scalar2,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_pred_scalar2_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdealh,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vdealh_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vpackwh_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vpackwh_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaslh,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vaslh_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vor,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vor_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiowh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiowh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracc,"V16iV16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracc_128B,"V32iV32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vandvrt,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandvrt_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_veqh_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhw,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhw_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vcl0w,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vcl0w_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyihb,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyihb_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpybus,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpybus_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vd0,"V16i","") +BUILTIN(__builtin_HEXAGON_V6_vd0_128B,"V32i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpybus_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybus,"V32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpybus_128B,"V64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vandvrt_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandvrt_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vassign,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vassign_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtub_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhb_dv_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vunpackb,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackb_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackh,"V32iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vunpackh_128B,"V64iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpahb_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpahb_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddbnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddbnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlalignbi,"V16iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vlalignbi_128B,"V32iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vsatwh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsatwh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyihb_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyihb_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusv_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrdelta,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrdelta_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vroundwh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vroundwh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddw_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddw_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwb_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubbq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqh_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_valignbi,"V16iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_valignbi_128B,"V32iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vaddwsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddwsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_and,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_and_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffeb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vshuffeb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqw_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgth,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgth_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vnot,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnot_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtb_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_or,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtuw_or_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaslwv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaslwv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsw_sat,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsw_sat_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vroundhub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vroundhub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_acc,"V16iV16iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhisat_acc_128B,"V32iV32iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabus,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabus_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vassignp,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vassignp_128B,"V64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_veqb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsububh,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsububh_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_lvsplatw,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_lvsplatw_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddhnq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhnq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_pred_not,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_not_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracc,"V32iV32iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracc_128B,"V64iV64iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewh_acc,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewh_acc_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdealvdd,"V32iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdealvdd_128B,"V64iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vavgw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vdmpyhsusat_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vgtw_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vtmpyhb_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddhw,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhw_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhq,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhq_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubi,"V32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyubi_128B,"V64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vminw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vminw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyubv_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyubv_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_pred_xor,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_pred_xor_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_xor,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_veqb_xor_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiewuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybusv_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpybusv_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavguhrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavguhrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_rnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubwsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhw,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhw_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_acc,"V32iV32iV32iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybusi_acc_128B,"V64iV64iV64iiUIi","") +BUILTIN(__builtin_HEXAGON_V6_vasrw,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrw_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrh,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrh_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhv,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhv_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrhbrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrhbrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuhsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsdiffw_128B,"V32iV32iV32i","") -BUILTIN(__builtin_HEXAGON_V6_vS32b_qpred_ai,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nqpred_ai,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_qpred_ai,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_nqpred_ai,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_qpred_ai_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nqpred_ai_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_qpred_ai_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vS32b_nt_nqpred_ai_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstoreq,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorenq,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentq,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentnq,"vV16iv*V16i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstoreq_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorenq_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentq_128B,"vV32iv*V32i","v:60:") -BUILTIN(__builtin_HEXAGON_V6_vmaskedstorentnq_128B,"vV32iv*V32i","v:60:") +// V62 HVX Instructions. -BUILTIN(__builtin_HEXAGON_M6_vabsdiffb,"LLiLLiLLi","v:62:") -BUILTIN(__builtin_HEXAGON_M6_vabsdiffub,"LLiLLiLLi","v:62:") -BUILTIN(__builtin_HEXAGON_A6_vminub_RdP,"LLiLLiLLi","v:62:") -BUILTIN(__builtin_HEXAGON_S6_vsplatrbp,"LLii","v:62:") -BUILTIN(__builtin_HEXAGON_S6_vtrunehb_ppp,"LLiLLiLLi","v:62:") -BUILTIN(__builtin_HEXAGON_S6_vtrunohb_ppp,"LLiLLiLLi","v:62:") +BUILTIN(__builtin_HEXAGON_V6_vandnqrt_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandnqrt_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddclbh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddclbh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_64_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyowh_64_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_64,"V32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_64_128B,"V64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsatuwuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsatuwuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_shuffeqh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_shuffeqh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_shuffeqw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_shuffeqw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldcnpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldcnpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vsubcarry,"V16iV16iV16iv*","") +BUILTIN(__builtin_HEXAGON_V6_vsubcarry_128B,"V32iV32iV32iv*","") +BUILTIN(__builtin_HEXAGON_V6_vasrhbsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrhbsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vminb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vminb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhb_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhb_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vaddhw_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddhw_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlsrb,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlsrb_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwhi,"V32iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwhi_128B,"V64iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vaddububb_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddububb_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_ldtp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldtp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracci,"V16iV16iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracci_128B,"V32iV32iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_ldpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vandvnqv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vandvnqv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_lvsplatb,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_lvsplatb_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_lvsplath,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_lvsplath_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_ldtpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldtpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_nm,"V32iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_nm_128B,"V64iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_ldnpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldnpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhb,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhb_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_ldtnp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldtnp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vrounduhub,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrounduhub_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhw_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vadduhw_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldcp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldcp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vadduwsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vadduwsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldtnpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldtnpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vaddbsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddbsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vandnqrt,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vandnqrt_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmaxb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vmaxb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vandvqv,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vandvqv_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddcarry,"V16iV16iV16iv*","") +BUILTIN(__builtin_HEXAGON_V6_vaddcarry_128B,"V32iV32iV32iv*","") +BUILTIN(__builtin_HEXAGON_V6_vasrwuhrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrwuhrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvbi,"V16iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvbi_128B,"V32iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vsubuwsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddbsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddbsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_ldnp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldnp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vasruwuhrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasruwuhrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrounduwuh,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrounduwuh_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_nm,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvvb_nm_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_pred_scalar2v2,"V16ii","") +BUILTIN(__builtin_HEXAGON_V6_pred_scalar2v2_128B,"V32ii","") +BUILTIN(__builtin_HEXAGON_V6_ldp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vaddubh_acc,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddubh_acc_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaddclbw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddclbw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldcpnt0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldcpnt0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vadduwsat_dv,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vadduwsat_dv_128B,"V64iV64iV64i","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwub,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vsubububb_sat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubububb_sat_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_ldcnp0,"V16iii","") +BUILTIN(__builtin_HEXAGON_V6_ldcnp0_128B,"V32iii","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracci,"V32iV32iV16iV16iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracci_128B,"V64iV64iV32iV32iUIi","") +BUILTIN(__builtin_HEXAGON_V6_vsubbsat,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsubbsat_128B,"V32iV32iV32i","") -BUILTIN(__builtin_HEXAGON_V6_vlsrb,"V16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlsrb_128B,"V32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasrwuhrndsat,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasrwuhrndsat_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasruwuhrndsat,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasruwuhrndsat_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasrhbsat,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vasrhbsat_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vrounduwuh,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vrounduwuh_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vrounduhub,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vrounduhub_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduwsat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduwsat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduwsat_dv,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduwsat_dv_128B,"V64iV64iV64i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubuwsat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_dv,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubuwsat_dv_128B,"V64iV64iV64i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddbsat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddbsat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddbsat_dv,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddbsat_dv_128B,"V64iV64iV64i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubbsat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubbsat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubbsat_dv,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubbsat_dv_128B,"V64iV64iV64i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddububb_sat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddububb_sat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubububb_sat,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubububb_sat_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddhw_acc,"V32iV32iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddhw_acc_128B,"V64iV64iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduhw_acc,"V32iV32iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vadduhw_acc_128B,"V64iV64iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddubh_acc,"V32iV32iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddubh_acc_128B,"V64iV64iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_64,"V32iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyewuh_64_128B,"V64iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_64_acc,"V32iV32iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyowh_64_acc_128B,"V64iV64iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhb,"V32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhb_128B,"V64iV64ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhb_acc,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhb_acc_128B,"V64iV64iV64ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwub,"V16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_128B,"V32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_acc,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmpyiwub_acc_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandnqrt,"V16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandnqrt_128B,"V32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandnqrt_acc,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandnqrt_acc_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandvqv,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandvqv_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandvnqv,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vandvnqv_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_pred_scalar2v2,"V16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_pred_scalar2v2_128B,"V32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_shuffeqw,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_shuffeqw_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_shuffeqh,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_shuffeqh_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmaxb,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vmaxb_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vminb,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vminb_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsatuwuh,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsatuwuh_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_lvsplath,"V16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_lvsplath_128B,"V32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_lvsplatb,"V16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_lvsplatb_128B,"V32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddclbw,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddclbw_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddclbh,"V16iV16iV16i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddclbh_128B,"V32iV32iV32i","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvbi,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvbi_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracci,"V16iV16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_oracci_128B,"V32iV32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwhi,"V32iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwhi_128B,"V64iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracci,"V32iV32iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_oracci_128B,"V64iV64iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_nm,"V16iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvvb_nm_128B,"V32iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_nm,"V32iV16iV16ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vlutvwh_nm_128B,"V64iV32iV32ii","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddcarry,"V16iV16iV16iv*","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vaddcarry_128B,"V32iV32iV32iv*","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubcarry,"V16iV16iV16iv*","v:62:") -BUILTIN(__builtin_HEXAGON_V6_vsubcarry_128B,"V32iV32iV32iv*","v:62:") +// V65 HVX Instructions. -BUILTIN(__builtin_HEXAGON_A6_vcmpbeq_notany,"iLLiLLi","v:65:") -BUILTIN(__builtin_HEXAGON_A6_vcmpbeq_notany_128B,"iLLiLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt,"V32iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_128B,"V64iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_acc,"V32iV32iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_acc_128B,"V64iV64iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt,"V32iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_128B,"V64iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_acc,"V32iV32iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_acc_128B,"V64iV64iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruwuhsat,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruwuhsat_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruhubsat,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruhubsat_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruhubrndsat,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasruhubrndsat_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vaslh_acc,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vaslh_acc_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasrh_acc,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vasrh_acc_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavguw,"V16iV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavguw_128B,"V32iV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavguwrnd,"V16iV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavguwrnd_128B,"V32iV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavgb,"V16iV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavgb_128B,"V32iV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavgbrnd,"V16iV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vavgbrnd_128B,"V32iV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vnavgb,"V16iV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vnavgb_128B,"V32iV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vabsb,"V16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vabsb_128B,"V32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vabsb_sat,"V16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vabsb_sat_128B,"V32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuu,"V32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuu_128B,"V64iV64ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuu_acc,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpabuu_acc_128B,"V64iV64iV64ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyh_acc,"V32iV32iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyh_acc_128B,"V64iV64iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpahhsat,"V16iV16iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpahhsat_128B,"V32iV32iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhuhsat,"V16iV16iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpauhuhsat_128B,"V32iV32iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpsuhuhsat,"V16iV16iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpsuhuhsat_128B,"V32iV32iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vlut4,"V16iV16iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vlut4_128B,"V32iV32iLLi","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhe,"V16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_128B,"V32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_acc,"V16iV16iV16ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_acc_128B,"V32iV32iV32ii","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermw,"vv*iiV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermw_128B,"vv*iiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermh,"vv*iiV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermh_128B,"vv*iiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhw,"vv*iiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhw_128B,"vv*iiV64i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermwq,"vv*V16iiiV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermwq_128B,"vv*V32iiiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhq,"vv*V16iiiV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhq_128B,"vv*V32iiiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhwq,"vv*V16iiiV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vgathermhwq_128B,"vv*V32iiiV64i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermw,"viiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermw_128B,"viiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermh,"viiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermh_128B,"viiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermw_add,"viiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermw_add_128B,"viiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermh_add,"viiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermh_add_128B,"viiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermwq,"vV16iiiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermwq_128B,"vV32iiiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhq,"vV16iiiV16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhq_128B,"vV32iiiV32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhw,"viiV32iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhw_128B,"viiV64iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhwq,"vV16iiiV32iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhwq_128B,"vV32iiiV64iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhw_add,"viiV32iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vscattermhw_add_128B,"viiV64iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqb,"V16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqb_128B,"V32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqh,"V16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqh_128B,"V32iV32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqw,"V16iV16i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vprefixqw_128B,"V32iV32i","v:65:") +BUILTIN(__builtin_HEXAGON_V6_vasruhubrndsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasruhubrndsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt,"V32iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_128B,"V64iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpahhsat,"V16iV16iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpahhsat_128B,"V32iV32iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vavguwrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavguwrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vnavgb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasrh_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasrh_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhuhsat,"V16iV16iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpauhuhsat_128B,"V32iV32iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpyh_acc,"V32iV32iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyh_acc_128B,"V64iV64iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_acc,"V32iV32iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpybub_rtt_acc_128B,"V64iV64iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vavgb,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgb_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vaslh_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vaslh_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vavguw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavguw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vlut4,"V16iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vlut4_128B,"V32iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_acc,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_acc_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt,"V32iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_128B,"V64iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpsuhuhsat,"V16iV16iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vmpsuhuhsat_128B,"V32iV32iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vasruhubsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasruhubsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhe,"V16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpyuhe_128B,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_acc,"V32iV32iV16iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vrmpyub_rtt_acc_128B,"V64iV64iV32iLLi","") +BUILTIN(__builtin_HEXAGON_V6_vasruwuhsat,"V16iV16iV16ii","") +BUILTIN(__builtin_HEXAGON_V6_vasruwuhsat_128B,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuu_acc,"V32iV32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuu_acc_128B,"V64iV64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqw,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqw_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqh,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqh_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqb,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vprefixqb_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vabsb,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsb_128B,"V32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vavgbrnd,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vavgbrnd_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vdd0,"V32i","") +BUILTIN(__builtin_HEXAGON_V6_vdd0_128B,"V64i","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuu,"V32iV32ii","") +BUILTIN(__builtin_HEXAGON_V6_vmpabuu_128B,"V64iV64ii","") +BUILTIN(__builtin_HEXAGON_V6_vabsb_sat,"V16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vabsb_sat_128B,"V32iV32i","") -BUILTIN(__builtin_HEXAGON_V6_vdd0,"V32i","v:65:") -BUILTIN(__builtin_HEXAGON_V6_vdd0_128B,"V64i","v:65:") +// V66 HVX Instructions. +BUILTIN(__builtin_HEXAGON_V6_vaddcarrysat,"V16iV16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vaddcarrysat_128B,"V32iV32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vasr_into,"V32iV32iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vasr_into_128B,"V64iV64iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vsatdw,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vsatdw_128B,"V32iV32iV32i","") +BUILTIN(__builtin_HEXAGON_V6_vrotr,"V16iV16iV16i","") +BUILTIN(__builtin_HEXAGON_V6_vrotr_128B,"V32iV32iV32i","") #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsNios2.def b/include/clang/Basic/BuiltinsNios2.def deleted file mode 100644 index d9697e795c44..000000000000 --- a/include/clang/Basic/BuiltinsNios2.def +++ /dev/null @@ -1,70 +0,0 @@ -//===-- BuiltinsNios2.def - Nios2 Builtin function database --------*- C++ -*-==// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the Nios2-specific builtin function database. Users of -// this file must define the BUILTIN macro to make use of this information. -// -//===----------------------------------------------------------------------===// - -// The format of this database matches clang/Basic/Builtins.def. - -#if defined(BUILTIN) && !defined(TARGET_BUILTIN) -# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS) -#endif - -// Nios2 R1 builtins: - -//int __builtin_ldbio(volatile const void *); -BUILTIN(__builtin_ldbio, "ivDC*", "") -//int __builtin_ldbuio(volatile const void *); -BUILTIN(__builtin_ldbuio, "ivDC*", "") -//int __builtin_ldhio(volatile const void *); -BUILTIN(__builtin_ldhio, "ivDC*", "") -//int __builtin_ldhuio(volatile const void *); -BUILTIN(__builtin_ldhuio, "ivDC*", "") -//int __builtin_ldwio(volatile const void *); -BUILTIN(__builtin_ldwio, "ivDC*", "") -//int __builtin_ldwuio(int); -BUILTIN(__builtin_ldwuio, "ii", "") -// int __builtin_rdctl(int); -BUILTIN(__builtin_rdctl, "iIi", "") -// void __builtin_wrctl(int, int); -BUILTIN(__builtin_wrctl, "vIii", "") -// int __builtin_rdprs(int, int); -BUILTIN(__builtin_rdprs, "iii", "") -//void __builtin_stbio(volatile void *, int); -BUILTIN(__builtin_stbio, "vvD*i", "") -//void __builtin_sthio(volatile void *, int); -BUILTIN(__builtin_sthio, "vvD*i", "") -//void __builtin_stwio(volatile void *, int); -BUILTIN(__builtin_stwio, "vvD*i", "") -//void __builtin_sync(void); -BUILTIN(__builtin_sync, "v", "") -// void __builtin_flushd(volatile void *); -BUILTIN(__builtin_flushd, "vvD*", "") -// void __builtin_flushda(volatile void *); -BUILTIN(__builtin_flushda, "vvD*", "") - -// Nios2 R2 builtins: - -// int __builtin_wrpie(int); -TARGET_BUILTIN(__builtin_wrpie, "ii", "", "nios2r2mandatory") -// void __builtin_eni(int); -TARGET_BUILTIN(__builtin_eni, "vi", "", "nios2r2mandatory") -// int __builtin_ldex(volatile const void *); -TARGET_BUILTIN(__builtin_ldex, "ivDC*", "", "nios2r2mandatory") -// int __builtin_stex(volatile void *, int); -TARGET_BUILTIN(__builtin_stex, "ivD*i", "", "nios2r2mandatory") -// int __builtin_ldsex(volatile const void *); -TARGET_BUILTIN(__builtin_ldsex, "ivDC*", "", "nios2r2mpx") -// int __builtin_stsex(volatile void *, int); -TARGET_BUILTIN(__builtin_stsex, "ivDC*i", "", "nios2r2mpx") - -#undef BUILTIN -#undef TARGET_BUILTIN diff --git a/include/clang/Basic/BuiltinsPPC.def b/include/clang/Basic/BuiltinsPPC.def index 9be760853d50..d31cb06f05f5 100644 --- a/include/clang/Basic/BuiltinsPPC.def +++ b/include/clang/Basic/BuiltinsPPC.def @@ -431,6 +431,8 @@ BUILTIN(__builtin_mulf128_round_to_odd, "LLdLLdLLd", "") BUILTIN(__builtin_divf128_round_to_odd, "LLdLLdLLd", "") BUILTIN(__builtin_fmaf128_round_to_odd, "LLdLLdLLdLLd", "") BUILTIN(__builtin_truncf128_round_to_odd, "dLLd", "") +BUILTIN(__builtin_vsx_scalar_extract_expq, "ULLiLLd", "") +BUILTIN(__builtin_vsx_scalar_insert_exp_qp, "LLdLLdULLi", "") // HTM builtins BUILTIN(__builtin_tbegin, "UiUIi", "") @@ -470,6 +472,10 @@ BUILTIN(__builtin_divde, "SLLiSLLiSLLi", "") BUILTIN(__builtin_divdeu, "ULLiULLiULLi", "") BUILTIN(__builtin_bpermd, "SLLiSLLiSLLi", "") +// Vector int128 (un)pack +BUILTIN(__builtin_unpack_vector_int128, "ULLiV1LLLii", "") +BUILTIN(__builtin_pack_vector_int128, "V1LLLiULLiULLi", "") + // FIXME: Obviously incomplete. #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsWebAssembly.def b/include/clang/Basic/BuiltinsWebAssembly.def index b3d877dcedf3..55931edc5ca3 100644 --- a/include/clang/Basic/BuiltinsWebAssembly.def +++ b/include/clang/Basic/BuiltinsWebAssembly.def @@ -16,22 +16,94 @@ // The format of this database matches clang/Basic/Builtins.def. +#if defined(BUILTIN) && !defined(TARGET_BUILTIN) +# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS) +#endif + // Query the current memory size, and increase the current memory size. // Note that memory.size is not "c" (readnone) because it must be sequenced // with respect to memory.grow calls. BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") -// These are the old names. -BUILTIN(__builtin_wasm_mem_size, "zIi", "n") -BUILTIN(__builtin_wasm_mem_grow, "zIiz", "n") - -// These are the old old names. They also lack the immediate field. -BUILTIN(__builtin_wasm_current_memory, "z", "n") -BUILTIN(__builtin_wasm_grow_memory, "zz", "n") +// Floating point min/max +BUILTIN(__builtin_wasm_min_f32, "fff", "nc") +BUILTIN(__builtin_wasm_max_f32, "fff", "nc") +BUILTIN(__builtin_wasm_min_f64, "ddd", "nc") +BUILTIN(__builtin_wasm_max_f64, "ddd", "nc") // Exception handling builtins. -BUILTIN(__builtin_wasm_throw, "vUiv*", "r") -BUILTIN(__builtin_wasm_rethrow, "v", "r") +TARGET_BUILTIN(__builtin_wasm_throw, "vUiv*", "r", "exception-handling") +TARGET_BUILTIN(__builtin_wasm_rethrow, "v", "r", "exception-handling") + +// Atomic wait and notify. +BUILTIN(__builtin_wasm_atomic_wait_i32, "ii*iLLi", "n") +BUILTIN(__builtin_wasm_atomic_wait_i64, "iLLi*LLiLLi", "n") +BUILTIN(__builtin_wasm_atomic_notify, "Uii*Ui", "n") + +// Saturating fp-to-int conversions +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i32_f32, "if", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i32_f32, "if", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i32_f64, "id", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i32_f64, "id", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i64_f32, "LLif", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i64_f32, "LLif", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i64_f64, "LLid", "nc", "nontrapping-fptoint") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i64_f64, "LLid", "nc", "nontrapping-fptoint") + +// SIMD builtins +TARGET_BUILTIN(__builtin_wasm_extract_lane_s_i8x16, "iV16cIi", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_u_i8x16, "iV16cIi", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_s_i16x8, "iV8sIi", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_u_i16x8, "iV8sIi", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_i32x4, "iV4iIi", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_i64x2, "LLiV2LLiIi", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_f32x4, "fV4fIi", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_extract_lane_f64x2, "dV2dIi", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_replace_lane_i8x16, "V16cV16cIii", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_replace_lane_i16x8, "V8sV8sIii", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_replace_lane_i32x4, "V4iV4iIii", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_replace_lane_i64x2, "V2LLiV2LLiIiLLi", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_replace_lane_f32x4, "V4fV4fIif", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_replace_lane_f64x2, "V2dV2dIid", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_add_saturate_s_i8x16, "V16cV16cV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_add_saturate_u_i8x16, "V16cV16cV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_add_saturate_s_i16x8, "V8sV8sV8s", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_add_saturate_u_i16x8, "V8sV8sV8s", "nc", "simd128") + +TARGET_BUILTIN(__builtin_wasm_sub_saturate_s_i8x16, "V16cV16cV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_sub_saturate_u_i8x16, "V16cV16cV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_sub_saturate_s_i16x8, "V8sV8sV8s", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_sub_saturate_u_i16x8, "V8sV8sV8s", "nc", "simd128") + +TARGET_BUILTIN(__builtin_wasm_bitselect, "V4iV4iV4iV4i", "nc", "simd128") + +TARGET_BUILTIN(__builtin_wasm_any_true_i8x16, "iV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_any_true_i16x8, "iV8s", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_any_true_i32x4, "iV4i", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_any_true_i64x2, "iV2LLi", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_all_true_i8x16, "iV16c", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_all_true_i16x8, "iV8s", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_all_true_i32x4, "iV4i", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_all_true_i64x2, "iV2LLi", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_abs_f32x4, "V4fV4f", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_abs_f64x2, "V2dV2d", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_min_f32x4, "V4fV4fV4f", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_max_f32x4, "V4fV4fV4f", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_min_f64x2, "V2dV2dV2d", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_max_f64x2, "V2dV2dV2d", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_sqrt_f32x4, "V4fV4f", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_sqrt_f64x2, "V2dV2d", "nc", "unimplemented-simd128") + +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i32x4_f32x4, "V4iV4f", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i32x4_f32x4, "V4iV4f", "nc", "simd128") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_s_i64x2_f64x2, "V2LLiV2d", "nc", "unimplemented-simd128") +TARGET_BUILTIN(__builtin_wasm_trunc_saturate_u_i64x2_f64x2, "V2LLiV2d", "nc", "unimplemented-simd128") #undef BUILTIN +#undef TARGET_BUILTIN diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index e98f7d612c3c..b3564b957e99 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -719,16 +719,21 @@ TARGET_BUILTIN(__builtin_ia32_wbinvd, "v", "n", "") TARGET_BUILTIN(__builtin_ia32_wbnoinvd, "v", "n", "wbnoinvd") // ADX -TARGET_BUILTIN(__builtin_ia32_addcarryx_u32, "UcUcUiUiUi*", "n", "adx") -TARGET_BUILTIN(__builtin_ia32_addcarry_u32, "UcUcUiUiUi*", "n", "") +TARGET_BUILTIN(__builtin_ia32_addcarryx_u32, "UcUcUiUiUi*", "n", "") TARGET_BUILTIN(__builtin_ia32_subborrow_u32, "UcUcUiUiUi*", "n", "") // RDSEED TARGET_BUILTIN(__builtin_ia32_rdseed16_step, "UiUs*", "n", "rdseed") TARGET_BUILTIN(__builtin_ia32_rdseed32_step, "UiUi*", "n", "rdseed") +// LZCNT +TARGET_BUILTIN(__builtin_ia32_lzcnt_u16, "UsUs", "nc", "lzcnt") +TARGET_BUILTIN(__builtin_ia32_lzcnt_u32, "UiUi", "nc", "lzcnt") + // BMI TARGET_BUILTIN(__builtin_ia32_bextr_u32, "UiUiUi", "nc", "bmi") +TARGET_BUILTIN(__builtin_ia32_tzcnt_u16, "UsUs", "nc", "") +TARGET_BUILTIN(__builtin_ia32_tzcnt_u32, "UiUi", "nc", "") // BMI2 TARGET_BUILTIN(__builtin_ia32_bzhi_si, "UiUiUi", "nc", "bmi2") @@ -963,49 +968,52 @@ TARGET_BUILTIN(__builtin_ia32_vpdpwssds128, "V4iV4iV4iV4i", "ncV:128:", "avx512v TARGET_BUILTIN(__builtin_ia32_vpdpwssds256, "V8iV8iV8iV8i", "ncV:256:", "avx512vl,avx512vnni") TARGET_BUILTIN(__builtin_ia32_vpdpwssds512, "V16iV16iV16iV16i", "ncV:512:", "avx512vnni") -TARGET_BUILTIN(__builtin_ia32_gather3div2df, "V2dV2ddC*V2LLiUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div2di, "V2LLiV2LLiLLiC*V2LLiUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div4df, "V4dV4ddC*V4LLiUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div4di, "V4LLiV4LLiLLiC*V4LLiUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div4sf, "V4fV4ffC*V2LLiUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div4si, "V4iV4iiC*V2LLiUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div8sf, "V4fV4ffC*V4LLiUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3div8si, "V4iV4iiC*V4LLiUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv2df, "V2dV2ddC*V4iUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv2di, "V2LLiV2LLiLLiC*V4iUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv4df, "V4dV4ddC*V4iUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv4di, "V4LLiV4LLiLLiC*V4iUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv4sf, "V4fV4ffC*V4iUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv4si, "V4iV4iiC*V4iUcIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv8sf, "V8fV8ffC*V8iUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gather3siv8si, "V8iV8iiC*V8iUcIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_gathersiv8df, "V8dV8ddC*V8iUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv16sf, "V16fV16ffC*V16fUsIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv8df, "V8dV8ddC*V8LLiUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv16sf, "V8fV8ffC*V8LLiUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv8di, "V8LLiV8LLiLLiC*V8iUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv16si, "V16iV16iiC*V16iUsIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv8di, "V8LLiV8LLiLLiC*V8LLiUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv16si, "V8iV8iiC*V8LLiUcIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv8df, "vd*UcV8iV8dIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv16sf, "vf*UsV16iV16fIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8df, "vd*UcV8LLiV8dIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv16sf, "vf*UcV8LLiV8fIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv8di, "vLLi*UcV8iV8LLiIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv16si, "vi*UsV16iV16iIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8di, "vLLi*UcV8LLiV8LLiIi", "nV:512:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv16si, "vi*UcV8LLiV8iIi", "nV:512:", "avx512f") - -TARGET_BUILTIN(__builtin_ia32_gatherpfdpd, "vUcV8iLLiC*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfdps, "vUsV16iiC*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfqpd, "vUcV8LLiLLiC*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfqps, "vUcV8LLiiC*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfdpd, "vUcV8iLLi*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfdps, "vUsV16ii*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfqpd, "vUcV8LLiLLi*IiIi", "nV:512:", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfqps, "vUcV8LLii*IiIi", "nV:512:", "avx512pf") - +TARGET_BUILTIN(__builtin_ia32_gather3div2df, "V2dV2dvC*V2LLiUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div2di, "V2LLiV2LLivC*V2LLiUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4df, "V4dV4dvC*V4LLiUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4di, "V4LLiV4LLivC*V4LLiUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4sf, "V4fV4fvC*V2LLiUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4si, "V4iV4ivC*V2LLiUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div8sf, "V4fV4fvC*V4LLiUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div8si, "V4iV4ivC*V4LLiUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv2df, "V2dV2dvC*V4iUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv2di, "V2LLiV2LLivC*V4iUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4df, "V4dV4dvC*V4iUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4di, "V4LLiV4LLivC*V4iUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4sf, "V4fV4fvC*V4iUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4si, "V4iV4ivC*V4iUcIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv8sf, "V8fV8fvC*V8iUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv8si, "V8iV8ivC*V8iUcIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_gathersiv8df, "V8dV8dvC*V8iUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv16sf, "V16fV16fvC*V16iUsIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv8df, "V8dV8dvC*V8LLiUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv16sf, "V8fV8fvC*V8LLiUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv8di, "V8LLiV8LLivC*V8iUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv16si, "V16iV16ivC*V16iUsIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv8di, "V8LLiV8LLivC*V8LLiUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv16si, "V8iV8ivC*V8LLiUcIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv8df, "vv*UcV8iV8dIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv16sf, "vv*UsV16iV16fIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8df, "vv*UcV8LLiV8dIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv16sf, "vv*UcV8LLiV8fIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv8di, "vv*UcV8iV8LLiIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv16si, "vv*UsV16iV16iIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8di, "vv*UcV8LLiV8LLiIi", "nV:512:", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv16si, "vv*UcV8LLiV8iIi", "nV:512:", "avx512f") + +TARGET_BUILTIN(__builtin_ia32_gatherpfdpd, "vUcV8ivC*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfdps, "vUsV16ivC*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfqpd, "vUcV8LLivC*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfqps, "vUcV8LLivC*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfdpd, "vUcV8iv*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfdps, "vUsV16iv*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfqpd, "vUcV8LLiv*IiIi", "nV:512:", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfqps, "vUcV8LLiv*IiIi", "nV:512:", "avx512pf") + +TARGET_BUILTIN(__builtin_ia32_knotqi, "UcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_knothi, "UsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_knotsi, "UiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_knotdi, "ULLiULLi", "nc", "avx512bw") TARGET_BUILTIN(__builtin_ia32_cmpb128_mask, "UsV16cV16cIiUs", "ncV:128:", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_cmpd128_mask, "UcV4iV4iIiUc", "ncV:128:", "avx512vl") @@ -1038,10 +1046,10 @@ TARGET_BUILTIN(__builtin_ia32_packssdw512, "V32sV16iV16i", "ncV:512:", "avx512bw TARGET_BUILTIN(__builtin_ia32_packsswb512, "V64cV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_packusdw512, "V32sV16iV16i", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_packuswb512, "V64cV32sV32s", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_paddsb512_mask, "V64cV64cV64cV64cULLi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_paddsw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_paddusb512_mask, "V64cV64cV64cV64cULLi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_paddusw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_paddsb512, "V64cV64cV64c", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_paddsw512, "V32sV32sV32s", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_paddusb512, "V64cV64cV64c", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_paddusw512, "V32sV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaxsb512, "V64cV64cV64c", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaxsw512, "V32sV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaxub512, "V64cV64cV64c", "ncV:512:", "avx512bw") @@ -1051,10 +1059,10 @@ TARGET_BUILTIN(__builtin_ia32_pminsw512, "V32sV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pminub512, "V64cV64cV64c", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pminuw512, "V32sV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pshufb512, "V64cV64cV64c", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_psubsb512_mask, "V64cV64cV64cV64cULLi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_psubsw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_psubusb512_mask, "V64cV64cV64cV64cULLi", "ncV:512:", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_psubusw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_psubsb512, "V64cV64cV64c", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_psubsw512, "V32sV32sV32s", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_psubusb512, "V64cV64cV64c", "ncV:512:", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_psubusw512, "V32sV32sV32s", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_vpconflictdi_128_mask, "V2LLiV2LLiV2LLiUc", "ncV:128:", "avx512cd,avx512vl") TARGET_BUILTIN(__builtin_ia32_vpconflictdi_256_mask, "V4LLiV4LLiV4LLiUc", "ncV:256:", "avx512cd,avx512vl") @@ -1202,22 +1210,22 @@ TARGET_BUILTIN(__builtin_ia32_scalefpd256_mask, "V4dV4dV4dV4dUc", "ncV:256:", "a TARGET_BUILTIN(__builtin_ia32_scalefps128_mask, "V4fV4fV4fV4fUc", "ncV:128:", "avx512vl") TARGET_BUILTIN(__builtin_ia32_scalefps256_mask, "V8fV8fV8fV8fUc", "ncV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv2df, "vd*UcV2LLiV2dIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv2di, "vLLi*UcV2LLiV2LLiIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4df, "vd*UcV4LLiV4dIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4di, "vLLi*UcV4LLiV4LLiIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4sf, "vf*UcV2LLiV4fIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4si, "vi*UcV2LLiV4iIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8sf, "vf*UcV4LLiV4fIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8si, "vi*UcV4LLiV4iIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv2df, "vd*UcV4iV2dIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv2di, "vLLi*UcV4iV2LLiIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4df, "vd*UcV4iV4dIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4di, "vLLi*UcV4iV4LLiIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4sf, "vf*UcV4iV4fIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4si, "vi*UcV4iV4iIi", "nV:128:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv8sf, "vf*UcV8iV8fIi", "nV:256:", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv8si, "vi*UcV8iV8iIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv2df, "vv*UcV2LLiV2dIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv2di, "vv*UcV2LLiV2LLiIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4df, "vv*UcV4LLiV4dIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4di, "vv*UcV4LLiV4LLiIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4sf, "vv*UcV2LLiV4fIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4si, "vv*UcV2LLiV4iIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8sf, "vv*UcV4LLiV4fIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8si, "vv*UcV4LLiV4iIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv2df, "vv*UcV4iV2dIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv2di, "vv*UcV4iV2LLiIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4df, "vv*UcV4iV4dIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4di, "vv*UcV4iV4LLiIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4sf, "vv*UcV4iV4fIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4si, "vv*UcV4iV4iIi", "nV:128:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv8sf, "vv*UcV8iV8fIi", "nV:256:", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv8si, "vv*UcV8iV8iIi", "nV:256:", "avx512vl") TARGET_BUILTIN(__builtin_ia32_vpermi2vard128, "V4iV4iV4iV4i", "ncV:128:", "avx512vl") TARGET_BUILTIN(__builtin_ia32_vpermi2vard256, "V8iV8iV8iV8i", "ncV:256:", "avx512vl") @@ -1248,43 +1256,25 @@ TARGET_BUILTIN(__builtin_ia32_vpshldw128, "V8sV8sV8sIi", "ncV:128:", "avx512vl,a TARGET_BUILTIN(__builtin_ia32_vpshldw256, "V16sV16sV16sIi", "ncV:256:", "avx512vl,avx512vbmi2") TARGET_BUILTIN(__builtin_ia32_vpshldw512, "V32sV32sV32sIi", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd128_mask, "V4iV4iV4iV4iUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd256_mask, "V8iV8iV8iV8iUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd512_mask, "V16iV16iV16iV16iUs", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw128_mask, "V8sV8sV8sV8sUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw256_mask, "V16sV16sV16sV16sUs", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd128_maskz, "V4iV4iV4iV4iUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd256_maskz, "V8iV8iV8iV8iUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvd512_maskz, "V16iV16iV16iV16iUs", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq128_maskz, "V2LLiV2LLiV2LLiV2LLiUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq256_maskz, "V4LLiV4LLiV4LLiV4LLiUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw128_maskz, "V8sV8sV8sV8sUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw256_maskz, "V16sV16sV16sV16sUs", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshldvw512_maskz, "V32sV32sV32sV32sUi", "ncV:512:", "avx512vbmi2") - -TARGET_BUILTIN(__builtin_ia32_vpshrdvd128_mask, "V4iV4iV4iV4iUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvd256_mask, "V8iV8iV8iV8iUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvd512_mask, "V16iV16iV16iV16iUs", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw128_mask, "V8sV8sV8sV8sUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw256_mask, "V16sV16sV16sV16sUs", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw512_mask, "V32sV32sV32sV32sUi", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvd128_maskz, "V4iV4iV4iV4iUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvd256_maskz, "V8iV8iV8iV8iUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvd512_maskz, "V16iV16iV16iV16iUs", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq128_maskz, "V2LLiV2LLiV2LLiV2LLiUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq256_maskz, "V4LLiV4LLiV4LLiV4LLiUc", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc", "ncV:512:", "avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw128_maskz, "V8sV8sV8sV8sUc", "ncV:128:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw256_maskz, "V16sV16sV16sV16sUs", "ncV:256:", "avx512vl,avx512vbmi2") -TARGET_BUILTIN(__builtin_ia32_vpshrdvw512_maskz, "V32sV32sV32sV32sUi", "ncV:512:", "avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvd128, "V4iV4iV4iV4i", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvd256, "V8iV8iV8iV8i", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvd512, "V16iV16iV16iV16i", "ncV:512:", "avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvq128, "V2LLiV2LLiV2LLiV2LLi", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvq256, "V4LLiV4LLiV4LLiV4LLi", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvq512, "V8LLiV8LLiV8LLiV8LLi", "ncV:512:", "avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvw128, "V8sV8sV8sV8s", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvw256, "V16sV16sV16sV16s", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshldvw512, "V32sV32sV32sV32s", "ncV:512:", "avx512vbmi2") + +TARGET_BUILTIN(__builtin_ia32_vpshrdvd128, "V4iV4iV4iV4i", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvd256, "V8iV8iV8iV8i", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvd512, "V16iV16iV16iV16i", "ncV:512:", "avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvq128, "V2LLiV2LLiV2LLiV2LLi", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvq256, "V4LLiV4LLiV4LLiV4LLi", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvq512, "V8LLiV8LLiV8LLiV8LLi", "ncV:512:", "avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvw128, "V8sV8sV8sV8s", "ncV:128:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvw256, "V16sV16sV16sV16s", "ncV:256:", "avx512vl,avx512vbmi2") +TARGET_BUILTIN(__builtin_ia32_vpshrdvw512, "V32sV32sV32sV32s", "ncV:512:", "avx512vbmi2") TARGET_BUILTIN(__builtin_ia32_vpshrdd128, "V4iV4iV4iIi", "ncV:128:", "avx512vl,avx512vbmi2") TARGET_BUILTIN(__builtin_ia32_vpshrdd256, "V8iV8iV8iIi", "ncV:256:", "avx512vl,avx512vbmi2") @@ -1734,14 +1724,59 @@ TARGET_BUILTIN(__builtin_ia32_fpclassps512_mask, "UsV16fIiUs", "ncV:512:", "avx5 TARGET_BUILTIN(__builtin_ia32_fpclasspd512_mask, "UcV8dIiUc", "ncV:512:", "avx512dq") TARGET_BUILTIN(__builtin_ia32_fpclasssd_mask, "UcV2dIiUc", "ncV:128:", "avx512dq") TARGET_BUILTIN(__builtin_ia32_fpclassss_mask, "UcV4fIiUc", "ncV:128:", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kaddqi, "UcUcUc", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kaddhi, "UsUsUs", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kaddsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kadddi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kandqi, "UcUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_kandhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kandsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kanddi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kandnqi, "UcUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_kandnhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kandnsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kandndi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_korqi, "UcUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_korhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_korsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kordi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kortestcqi, "iUcUc", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kortestzqi, "iUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_kortestchi, "iUsUs", "nc", "avx512f") TARGET_BUILTIN(__builtin_ia32_kortestzhi, "iUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kortestcsi, "iUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kortestzsi, "iUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kortestcdi, "iULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kortestzdi, "iULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_ktestcqi, "iUcUc", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_ktestzqi, "iUcUc", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_ktestchi, "iUsUs", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_ktestzhi, "iUsUs", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_ktestcsi, "iUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_ktestzsi, "iUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_ktestcdi, "iULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_ktestzdi, "iULLiULLi", "nc", "avx512bw") TARGET_BUILTIN(__builtin_ia32_kunpckhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kxnorqi, "UcUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_kxnorhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kxnorsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kxnordi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kxorqi, "UcUcUc", "nc", "avx512dq") TARGET_BUILTIN(__builtin_ia32_kxorhi, "UsUsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kxorsi, "UiUiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kxordi, "ULLiULLiULLi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kshiftliqi, "UcUcIUi", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kshiftlihi, "UsUsIUi", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kshiftlisi, "UiUiIUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kshiftlidi, "ULLiULLiIUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kshiftriqi, "UcUcIUi", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kshiftrihi, "UsUsIUi", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kshiftrisi, "UiUiIUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kshiftridi, "ULLiULLiIUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kmovb, "UcUc", "nc", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_kmovw, "UsUs", "nc", "avx512f") +TARGET_BUILTIN(__builtin_ia32_kmovd, "UiUi", "nc", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_kmovq, "ULLiULLi", "nc", "avx512bw") TARGET_BUILTIN(__builtin_ia32_palignr512, "V64cV64cV64cIi", "ncV:512:", "avx512bw") TARGET_BUILTIN(__builtin_ia32_dbpsadbw128, "V8sV16cV16cIi", "ncV:128:", "avx512bw,avx512vl") TARGET_BUILTIN(__builtin_ia32_dbpsadbw256, "V16sV32cV32cIi", "ncV:256:", "avx512bw,avx512vl") @@ -1786,9 +1821,9 @@ TARGET_BUILTIN(__builtin_ia32_cvtsd2ss_round_mask, "V4fV4fV2dV4fUcIi", "ncV:128: TARGET_BUILTIN(__builtin_ia32_cvtsi2ss32, "V4fV4fiIi", "ncV:128:", "avx512f") TARGET_BUILTIN(__builtin_ia32_cvtss2sd_round_mask, "V2dV2dV4fV2dUcIi", "ncV:128:", "avx512f") TARGET_BUILTIN(__builtin_ia32_cvtusi2ss32, "V4fV4fUiIi", "ncV:128:", "avx512f") -TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb512_mask, "V64cV64cV64cV64cULLi", "ncV:512:", "avx512vbmi") -TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb128_mask, "V16cV16cV16cV16cUs", "ncV:128:", "avx512vbmi,avx512vl") -TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb256_mask, "V32cV32cV32cV32cUi", "ncV:256:", "avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb512, "V64cV64cV64c", "ncV:512:", "avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb128, "V16cV16cV16c", "ncV:128:", "avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb256, "V32cV32cV32c", "ncV:256:", "avx512vbmi,avx512vl") // generic select intrinsics TARGET_BUILTIN(__builtin_ia32_selectb_128, "V16cUsV16cV16c", "ncV:128:", "avx512bw,avx512vl") diff --git a/include/clang/Basic/BuiltinsX86_64.def b/include/clang/Basic/BuiltinsX86_64.def index cc400c0697f9..5e8cce5c6e5e 100644 --- a/include/clang/Basic/BuiltinsX86_64.def +++ b/include/clang/Basic/BuiltinsX86_64.def @@ -31,6 +31,8 @@ TARGET_HEADER_BUILTIN(_mul128, "LLiLLiLLiLLi*", "nch", "intrin.h", ALL_MS TARGET_HEADER_BUILTIN(_umul128, "ULLiULLiULLiULLi*", "nch", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(__faststorefence, "v", "nh", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(__shiftleft128, "ULLiULLiULLiUc", "nch", "intrin.h", ALL_MS_LANGUAGES, "") +TARGET_HEADER_BUILTIN(__shiftright128, "ULLiULLiULLiUc", "nch", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedAnd64, "LLiLLiD*LLi", "nh", "intrin.h", ALL_MS_LANGUAGES, "") TARGET_HEADER_BUILTIN(_InterlockedDecrement64, "LLiLLiD*", "nh", "intrin.h", ALL_MS_LANGUAGES, "") @@ -74,12 +76,13 @@ TARGET_BUILTIN(__builtin_ia32_incsspq, "vULLi", "n", "shstk") TARGET_BUILTIN(__builtin_ia32_rdsspq, "ULLiULLi", "n", "shstk") TARGET_BUILTIN(__builtin_ia32_wrssq, "vULLiv*", "n", "shstk") TARGET_BUILTIN(__builtin_ia32_wrussq, "vULLiv*", "n", "shstk") -TARGET_BUILTIN(__builtin_ia32_addcarryx_u64, "UcUcULLiULLiULLi*", "n", "adx") -TARGET_BUILTIN(__builtin_ia32_addcarry_u64, "UcUcULLiULLiULLi*", "n", "") +TARGET_BUILTIN(__builtin_ia32_addcarryx_u64, "UcUcULLiULLiULLi*", "n", "") TARGET_BUILTIN(__builtin_ia32_subborrow_u64, "UcUcULLiULLiULLi*", "n", "") TARGET_BUILTIN(__builtin_ia32_rdrand64_step, "UiULLi*", "n", "rdrnd") TARGET_BUILTIN(__builtin_ia32_rdseed64_step, "UiULLi*", "n", "rdseed") +TARGET_BUILTIN(__builtin_ia32_lzcnt_u64, "ULLiULLi", "nc", "lzcnt") TARGET_BUILTIN(__builtin_ia32_bextr_u64, "ULLiULLiULLi", "nc", "bmi") +TARGET_BUILTIN(__builtin_ia32_tzcnt_u64, "ULLiULLi", "nc", "") TARGET_BUILTIN(__builtin_ia32_bzhi_di, "ULLiULLiULLi", "nc", "bmi2") TARGET_BUILTIN(__builtin_ia32_pdep_di, "ULLiULLiULLi", "nc", "bmi2") TARGET_BUILTIN(__builtin_ia32_pext_di, "ULLiULLiULLi", "nc", "bmi2") diff --git a/include/clang/Basic/CodeGenOptions.def b/include/clang/Basic/CodeGenOptions.def new file mode 100644 index 000000000000..ed2387b9a2e2 --- /dev/null +++ b/include/clang/Basic/CodeGenOptions.def @@ -0,0 +1,370 @@ +//===--- CodeGenOptions.def - Code generation option database ----- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the code generation options. Users of this file +// must define the CODEGENOPT macro to make use of this information. +// Optionally, the user may also define ENUM_CODEGENOPT (for options +// that have enumeration type and VALUE_CODEGENOPT is a code +// generation option that describes a value rather than a flag. +// +//===----------------------------------------------------------------------===// +#ifndef CODEGENOPT +# error Define the CODEGENOPT macro to handle language options +#endif + +#ifndef VALUE_CODEGENOPT +# define VALUE_CODEGENOPT(Name, Bits, Default) \ +CODEGENOPT(Name, Bits, Default) +#endif + +#ifndef ENUM_CODEGENOPT +# define ENUM_CODEGENOPT(Name, Type, Bits, Default) \ +CODEGENOPT(Name, Bits, Default) +#endif + +CODEGENOPT(DisableIntegratedAS, 1, 0) ///< -no-integrated-as +ENUM_CODEGENOPT(CompressDebugSections, llvm::DebugCompressionType, 2, + llvm::DebugCompressionType::None) +CODEGENOPT(RelaxELFRelocations, 1, 0) ///< -Wa,--mrelax-relocations +CODEGENOPT(AsmVerbose , 1, 0) ///< -dA, -fverbose-asm. +CODEGENOPT(PreserveAsmComments, 1, 1) ///< -dA, -fno-preserve-as-comments. +CODEGENOPT(AssumeSaneOperatorNew , 1, 1) ///< implicit __attribute__((malloc)) operator new +CODEGENOPT(Autolink , 1, 1) ///< -fno-autolink +CODEGENOPT(ObjCAutoRefCountExceptions , 1, 0) ///< Whether ARC should be EH-safe. +CODEGENOPT(Backchain , 1, 0) ///< -mbackchain +CODEGENOPT(ControlFlowGuard , 1, 0) ///< -cfguard +CODEGENOPT(CoverageExtraChecksum, 1, 0) ///< Whether we need a second checksum for functions in GCNO files. +CODEGENOPT(CoverageNoFunctionNamesInData, 1, 0) ///< Do not include function names in GCDA files. +CODEGENOPT(CoverageExitBlockBeforeBody, 1, 0) ///< Whether to emit the exit block before the body blocks in GCNO files. +CODEGENOPT(CXAAtExit , 1, 1) ///< Use __cxa_atexit for calling destructors. +CODEGENOPT(RegisterGlobalDtorsWithAtExit, 1, 1) ///< Use atexit or __cxa_atexit to register global destructors. +CODEGENOPT(CXXCtorDtorAliases, 1, 0) ///< Emit complete ctors/dtors as linker + ///< aliases to base ctors when possible. +CODEGENOPT(DataSections , 1, 0) ///< Set when -fdata-sections is enabled. +CODEGENOPT(UniqueSectionNames, 1, 1) ///< Set for -funique-section-names. +CODEGENOPT(DisableFPElim , 1, 0) ///< Set when -fomit-frame-pointer is enabled. +CODEGENOPT(DisableFree , 1, 0) ///< Don't free memory. +CODEGENOPT(DiscardValueNames , 1, 0) ///< Discard Value Names from the IR (LLVMContext flag) +CODEGENOPT(DisableGCov , 1, 0) ///< Don't run the GCov pass, for testing. +CODEGENOPT(DisableLLVMPasses , 1, 0) ///< Don't run any LLVM IR passes to get + ///< the pristine IR generated by the + ///< frontend. +CODEGENOPT(DisableLifetimeMarkers, 1, 0) ///< Don't emit any lifetime markers +CODEGENOPT(DisableO0ImplyOptNone , 1, 0) ///< Don't annonate function with optnone at O0 +CODEGENOPT(ExperimentalNewPassManager, 1, 0) ///< Enables the new, experimental + ///< pass manager. +CODEGENOPT(DebugPassManager, 1, 0) ///< Prints debug information for the new + ///< pass manager. +CODEGENOPT(DisableRedZone , 1, 0) ///< Set when -mno-red-zone is enabled. +CODEGENOPT(IndirectTlsSegRefs, 1, 0) ///< Set when -mno-tls-direct-seg-refs + ///< is specified. +CODEGENOPT(DisableTailCalls , 1, 0) ///< Do not emit tail calls. +CODEGENOPT(NoEscapingBlockTailCalls, 1, 0) ///< Do not emit tail calls from + ///< escaping blocks. +CODEGENOPT(EmitDeclMetadata , 1, 0) ///< Emit special metadata indicating what + ///< Decl* various IR entities came from. + ///< Only useful when running CodeGen as a + ///< subroutine. +CODEGENOPT(EmitVersionIdentMetadata , 1, 1) ///< Emit compiler version metadata. +CODEGENOPT(EmitGcovArcs , 1, 0) ///< Emit coverage data files, aka. GCDA. +CODEGENOPT(EmitGcovNotes , 1, 0) ///< Emit coverage "notes" files, aka GCNO. +CODEGENOPT(EmitOpenCLArgMetadata , 1, 0) ///< Emit OpenCL kernel arg metadata. +CODEGENOPT(EmulatedTLS , 1, 0) ///< Set by default or -f[no-]emulated-tls. +CODEGENOPT(ExplicitEmulatedTLS , 1, 0) ///< Set if -f[no-]emulated-tls is used. +/// Embed Bitcode mode (off/all/bitcode/marker). +ENUM_CODEGENOPT(EmbedBitcode, EmbedBitcodeKind, 2, Embed_Off) +CODEGENOPT(ForbidGuardVariables , 1, 0) ///< Issue errors if C++ guard variables + ///< are required. +CODEGENOPT(FunctionSections , 1, 0) ///< Set when -ffunction-sections is enabled. +CODEGENOPT(InstrumentFunctions , 1, 0) ///< Set when -finstrument-functions is + ///< enabled. +CODEGENOPT(InstrumentFunctionsAfterInlining , 1, 0) ///< Set when + ///< -finstrument-functions-after-inlining is enabled. +CODEGENOPT(InstrumentFunctionEntryBare , 1, 0) ///< Set when + ///< -finstrument-function-entry-bare is enabled. +CODEGENOPT(CFProtectionReturn , 1, 0) ///< if -fcf-protection is + ///< set to full or return. +CODEGENOPT(CFProtectionBranch , 1, 0) ///< if -fcf-protection is + ///< set to full or branch. +CODEGENOPT(XRayInstrumentFunctions , 1, 0) ///< Set when -fxray-instrument is + ///< enabled. +CODEGENOPT(StackSizeSection , 1, 0) ///< Set when -fstack-size-section is enabled. + +///< Set when -fxray-always-emit-customevents is enabled. +CODEGENOPT(XRayAlwaysEmitCustomEvents , 1, 0) + +///< Set when -fxray-always-emit-typedevents is enabled. +CODEGENOPT(XRayAlwaysEmitTypedEvents , 1, 0) + +///< Set the minimum number of instructions in a function to determine selective +///< XRay instrumentation. +VALUE_CODEGENOPT(XRayInstructionThreshold , 32, 200) + +CODEGENOPT(InstrumentForProfiling , 1, 0) ///< Set when -pg is enabled. +CODEGENOPT(CallFEntry , 1, 0) ///< Set when -mfentry is enabled. +CODEGENOPT(LessPreciseFPMAD , 1, 0) ///< Enable less precise MAD instructions to + ///< be generated. +CODEGENOPT(PrepareForLTO , 1, 0) ///< Set when -flto is enabled on the + ///< compile step. +CODEGENOPT(PrepareForThinLTO , 1, 0) ///< Set when -flto=thin is enabled on the + ///< compile step. +CODEGENOPT(LTOUnit, 1, 0) ///< Emit IR to support LTO unit features (CFI, whole + ///< program vtable opt). +CODEGENOPT(EnableSplitLTOUnit, 1, 0) ///< Enable LTO unit splitting to support + /// CFI and traditional whole program + /// devirtualization that require whole + /// program IR support. +CODEGENOPT(IncrementalLinkerCompatible, 1, 0) ///< Emit an object file which can + ///< be used with an incremental + ///< linker. +CODEGENOPT(MergeAllConstants , 1, 1) ///< Merge identical constants. +CODEGENOPT(MergeFunctions , 1, 0) ///< Set when -fmerge-functions is enabled. +CODEGENOPT(MSVolatile , 1, 0) ///< Set when /volatile:ms is enabled. +CODEGENOPT(NoCommon , 1, 0) ///< Set when -fno-common or C++ is enabled. +CODEGENOPT(NoDwarfDirectoryAsm , 1, 0) ///< Set when -fno-dwarf-directory-asm is + ///< enabled. +CODEGENOPT(NoExecStack , 1, 0) ///< Set when -Wa,--noexecstack is enabled. +CODEGENOPT(FatalWarnings , 1, 0) ///< Set when -Wa,--fatal-warnings is + ///< enabled. +CODEGENOPT(EnableSegmentedStacks , 1, 0) ///< Set when -fsplit-stack is enabled. +CODEGENOPT(NoImplicitFloat , 1, 0) ///< Set when -mno-implicit-float is enabled. +CODEGENOPT(NoInfsFPMath , 1, 0) ///< Assume FP arguments, results not +-Inf. +CODEGENOPT(NoSignedZeros , 1, 0) ///< Allow ignoring the signedness of FP zero +CODEGENOPT(NullPointerIsValid , 1, 0) ///< Assume Null pointer deference is defined. +CODEGENOPT(Reassociate , 1, 0) ///< Allow reassociation of FP math ops +CODEGENOPT(ReciprocalMath , 1, 0) ///< Allow FP divisions to be reassociated. +CODEGENOPT(NoTrappingMath , 1, 0) ///< Set when -fno-trapping-math is enabled. +CODEGENOPT(NoNaNsFPMath , 1, 0) ///< Assume FP arguments, results not NaN. +CODEGENOPT(FlushDenorm , 1, 0) ///< Allow FP denorm numbers to be flushed to zero +CODEGENOPT(CorrectlyRoundedDivSqrt, 1, 0) ///< -cl-fp32-correctly-rounded-divide-sqrt + +/// When false, this attempts to generate code as if the result of an +/// overflowing conversion matches the overflowing behavior of a target's native +/// float-to-int conversion instructions. +CODEGENOPT(StrictFloatCastOverflow, 1, 1) + +CODEGENOPT(UniformWGSize , 1, 0) ///< -cl-uniform-work-group-size +CODEGENOPT(NoZeroInitializedInBSS , 1, 0) ///< -fno-zero-initialized-in-bss. +/// Method of Objective-C dispatch to use. +ENUM_CODEGENOPT(ObjCDispatchMethod, ObjCDispatchMethodKind, 2, Legacy) +/// Replace certain message sends with calls to ObjC runtime entrypoints +CODEGENOPT(ObjCConvertMessagesToRuntimeCalls , 1, 1) +CODEGENOPT(OmitLeafFramePointer , 1, 0) ///< Set when -momit-leaf-frame-pointer is + ///< enabled. + +VALUE_CODEGENOPT(OptimizationLevel, 2, 0) ///< The -O[0-3] option specified. +VALUE_CODEGENOPT(OptimizeSize, 2, 0) ///< If -Os (==1) or -Oz (==2) is specified. + +/// Choose profile instrumenation kind or no instrumentation. +ENUM_CODEGENOPT(ProfileInstr, ProfileInstrKind, 2, ProfileNone) +/// Choose profile kind for PGO use compilation. +ENUM_CODEGENOPT(ProfileUse, ProfileInstrKind, 2, ProfileNone) +CODEGENOPT(CoverageMapping , 1, 0) ///< Generate coverage mapping regions to + ///< enable code coverage analysis. +CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping + ///< regions. + + /// If -fpcc-struct-return or -freg-struct-return is specified. +ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default) + +CODEGENOPT(RelaxAll , 1, 0) ///< Relax all machine code instructions. +CODEGENOPT(RelaxedAliasing , 1, 0) ///< Set when -fno-strict-aliasing is enabled. +CODEGENOPT(StructPathTBAA , 1, 0) ///< Whether or not to use struct-path TBAA. +CODEGENOPT(NewStructPathTBAA , 1, 0) ///< Whether or not to use enhanced struct-path TBAA. +CODEGENOPT(SaveTempLabels , 1, 0) ///< Save temporary labels. +CODEGENOPT(SanitizeAddressUseAfterScope , 1, 0) ///< Enable use-after-scope detection + ///< in AddressSanitizer +CODEGENOPT(SanitizeAddressPoisonCustomArrayCookie, 1, + 0) ///< Enable poisoning operator new[] which is not a replaceable + ///< global allocation function in AddressSanitizer +CODEGENOPT(SanitizeAddressGlobalsDeadStripping, 1, 0) ///< Enable linker dead stripping + ///< of globals in AddressSanitizer +CODEGENOPT(SanitizeAddressUseOdrIndicator, 1, 0) ///< Enable ODR indicator globals +CODEGENOPT(SanitizeMemoryTrackOrigins, 2, 0) ///< Enable tracking origins in + ///< MemorySanitizer +CODEGENOPT(SanitizeMemoryUseAfterDtor, 1, 0) ///< Enable use-after-delete detection + ///< in MemorySanitizer +CODEGENOPT(SanitizeCfiCrossDso, 1, 0) ///< Enable cross-dso support in CFI. +CODEGENOPT(SanitizeMinimalRuntime, 1, 0) ///< Use "_minimal" sanitizer runtime for + ///< diagnostics. +CODEGENOPT(SanitizeCfiICallGeneralizePointers, 1, 0) ///< Generalize pointer types in + ///< CFI icall function signatures +CODEGENOPT(SanitizeCoverageType, 2, 0) ///< Type of sanitizer coverage + ///< instrumentation. +CODEGENOPT(SanitizeCoverageIndirectCalls, 1, 0) ///< Enable sanitizer coverage + ///< for indirect calls. +CODEGENOPT(SanitizeCoverageTraceBB, 1, 0) ///< Enable basic block tracing in + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageTraceCmp, 1, 0) ///< Enable cmp instruction tracing + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageTraceDiv, 1, 0) ///< Enable div instruction tracing + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageTraceGep, 1, 0) ///< Enable GEP instruction tracing + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverage8bitCounters, 1, 0) ///< Use 8-bit frequency counters + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageTracePC, 1, 0) ///< Enable PC tracing + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageTracePCGuard, 1, 0) ///< Enable PC tracing with guard + ///< in sanitizer coverage. +CODEGENOPT(SanitizeCoverageInline8bitCounters, 1, 0) ///< Use inline 8bit counters. +CODEGENOPT(SanitizeCoveragePCTable, 1, 0) ///< Create a PC Table. +CODEGENOPT(SanitizeCoverageNoPrune, 1, 0) ///< Disable coverage pruning. +CODEGENOPT(SanitizeCoverageStackDepth, 1, 0) ///< Enable max stack depth tracing +CODEGENOPT(SanitizeStats , 1, 0) ///< Collect statistics for sanitizers. +CODEGENOPT(SimplifyLibCalls , 1, 1) ///< Set when -fbuiltin is enabled. +CODEGENOPT(SoftFloat , 1, 0) ///< -soft-float. +CODEGENOPT(SpeculativeLoadHardening, 1, 0) ///< Enable speculative load hardening. +CODEGENOPT(FineGrainedBitfieldAccesses, 1, 0) ///< Enable fine-grained bitfield accesses. +CODEGENOPT(StrictEnums , 1, 0) ///< Optimize based on strict enum definition. +CODEGENOPT(StrictVTablePointers, 1, 0) ///< Optimize based on the strict vtable pointers +CODEGENOPT(TimePasses , 1, 0) ///< Set when -ftime-report is enabled. +CODEGENOPT(UnrollLoops , 1, 0) ///< Control whether loops are unrolled. +CODEGENOPT(RerollLoops , 1, 0) ///< Control whether loops are rerolled. +CODEGENOPT(NoUseJumpTables , 1, 0) ///< Set when -fno-jump-tables is enabled. +CODEGENOPT(UnsafeFPMath , 1, 0) ///< Allow unsafe floating point optzns. +CODEGENOPT(UnwindTables , 1, 0) ///< Emit unwind tables. +CODEGENOPT(VectorizeLoop , 1, 0) ///< Run loop vectorizer. +CODEGENOPT(VectorizeSLP , 1, 0) ///< Run SLP vectorizer. +CODEGENOPT(ProfileSampleAccurate, 1, 0) ///< Sample profile is accurate. + + /// Attempt to use register sized accesses to bit-fields in structures, when + /// possible. +CODEGENOPT(UseRegisterSizedBitfieldAccess , 1, 0) + +CODEGENOPT(VerifyModule , 1, 1) ///< Control whether the module should be run + ///< through the LLVM Verifier. + +CODEGENOPT(StackRealignment , 1, 0) ///< Control whether to force stack + ///< realignment. +CODEGENOPT(UseInitArray , 1, 0) ///< Control whether to use .init_array or + ///< .ctors. +VALUE_CODEGENOPT(StackAlignment , 32, 0) ///< Overrides default stack + ///< alignment, if not 0. +VALUE_CODEGENOPT(StackProbeSize , 32, 4096) ///< Overrides default stack + ///< probe size, even if 0. +CODEGENOPT(NoStackArgProbe, 1, 0) ///< Set when -mno-stack-arg-probe is used +CODEGENOPT(DebugColumnInfo, 1, 0) ///< Whether or not to use column information + ///< in debug info. + +CODEGENOPT(DebugTypeExtRefs, 1, 0) ///< Whether or not debug info should contain + ///< external references to a PCH or module. + +CODEGENOPT(DebugExplicitImport, 1, 0) ///< Whether or not debug info should + ///< contain explicit imports for + ///< anonymous namespaces + +ENUM_CODEGENOPT(SplitDwarfMode, DwarfFissionKind, 2, NoFission) ///< DWARF fission mode to use. + +CODEGENOPT(SplitDwarfInlining, 1, 1) ///< Whether to include inlining info in the + ///< skeleton CU to allow for symbolication + ///< of inline stack frames without .dwo files. +CODEGENOPT(DebugFwdTemplateParams, 1, 0) ///< Whether to emit complete + ///< template parameter descriptions in + ///< forward declarations (versus just + ///< including them in the name). + +CODEGENOPT(EmitLLVMUseLists, 1, 0) ///< Control whether to serialize use-lists. + +CODEGENOPT(WholeProgramVTables, 1, 0) ///< Whether to apply whole-program + /// vtable optimization. + +/// Whether to use public LTO visibility for entities in std and stdext +/// namespaces. This is enabled by clang-cl's /MT and /MTd flags. +CODEGENOPT(LTOVisibilityPublicStd, 1, 0) + +/// The user specified number of registers to be used for integral arguments, +/// or 0 if unspecified. +VALUE_CODEGENOPT(NumRegisterParameters, 32, 0) + +/// The lower bound for a buffer to be considered for stack protection. +VALUE_CODEGENOPT(SSPBufferSize, 32, 0) + +/// The kind of generated debug info. +ENUM_CODEGENOPT(DebugInfo, codegenoptions::DebugInfoKind, 3, codegenoptions::NoDebugInfo) + +/// Whether to generate macro debug info. +CODEGENOPT(MacroDebugInfo, 1, 0) + +/// Tune the debug info for this debugger. +ENUM_CODEGENOPT(DebuggerTuning, llvm::DebuggerKind, 2, + llvm::DebuggerKind::Default) + +/// Dwarf version. Version zero indicates to LLVM that no DWARF should be +/// emitted. +VALUE_CODEGENOPT(DwarfVersion, 3, 0) + +/// Whether we should emit CodeView debug information. It's possible to emit +/// CodeView and DWARF into the same object. +CODEGENOPT(EmitCodeView, 1, 0) + +/// Whether to emit the .debug$H section containing hashes of CodeView types. +CODEGENOPT(CodeViewGHash, 1, 0) + +/// The kind of inlining to perform. +ENUM_CODEGENOPT(Inlining, InliningMethod, 2, NormalInlining) + +// Vector functions library to use. +ENUM_CODEGENOPT(VecLib, VectorLibrary, 2, NoLibrary) + +/// The default TLS model to use. +ENUM_CODEGENOPT(DefaultTLSModel, TLSModel, 2, GeneralDynamicTLSModel) + +/// Number of path components to strip when emitting checks. (0 == full +/// filename) +VALUE_CODEGENOPT(EmitCheckPathComponentsToStrip, 32, 0) + +/// Whether to report the hotness of the code region for optimization remarks. +CODEGENOPT(DiagnosticsWithHotness, 1, 0) + +/// The minimum hotness value a diagnostic needs in order to be included in +/// optimization diagnostics. +VALUE_CODEGENOPT(DiagnosticsHotnessThreshold, 32, 0) + +/// Whether copy relocations support is available when building as PIE. +CODEGENOPT(PIECopyRelocations, 1, 0) + +/// Whether we should use the undefined behaviour optimization for control flow +/// paths that reach the end of a function without executing a required return. +CODEGENOPT(StrictReturn, 1, 1) + +/// Whether emit extra debug info for sample pgo profile collection. +CODEGENOPT(DebugInfoForProfiling, 1, 0) + +/// Whether 3-component vector type is preserved. +CODEGENOPT(PreserveVec3Type, 1, 0) + +/// Whether to emit .debug_gnu_pubnames section instead of .debug_pubnames. +CODEGENOPT(DebugNameTable, 2, 0) + +/// Whether to use DWARF base address specifiers in .debug_ranges. +CODEGENOPT(DebugRangesBaseAddress, 1, 0) + +CODEGENOPT(NoPLT, 1, 0) + +/// Whether to embed source in DWARF debug line section. +CODEGENOPT(EmbedSource, 1, 0) + +/// Whether to emit all vtables +CODEGENOPT(ForceEmitVTables, 1, 0) + +/// Whether to emit an address-significance table into the object file. +CODEGENOPT(Addrsig, 1, 0) + +ENUM_CODEGENOPT(SignReturnAddress, SignReturnAddressScope, 2, None) +ENUM_CODEGENOPT(SignReturnAddressKey, SignReturnAddressKeyValue, 1, AKey) +CODEGENOPT(BranchTargetEnforcement, 1, 0) + +/// Whether to emit unused static constants. +CODEGENOPT(KeepStaticConsts, 1, 0) + +#undef CODEGENOPT +#undef ENUM_CODEGENOPT +#undef VALUE_CODEGENOPT + diff --git a/include/clang/Basic/CodeGenOptions.h b/include/clang/Basic/CodeGenOptions.h new file mode 100644 index 000000000000..ec6eda7fb788 --- /dev/null +++ b/include/clang/Basic/CodeGenOptions.h @@ -0,0 +1,333 @@ +//===--- CodeGenOptions.h ---------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the CodeGenOptions interface. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_CODEGENOPTIONS_H +#define LLVM_CLANG_BASIC_CODEGENOPTIONS_H + +#include "clang/Basic/DebugInfoOptions.h" +#include "clang/Basic/Sanitizers.h" +#include "clang/Basic/XRayInstr.h" +#include "llvm/Support/CodeGen.h" +#include "llvm/Support/Regex.h" +#include "llvm/Target/TargetOptions.h" +#include <map> +#include <memory> +#include <string> +#include <vector> + +namespace clang { + +/// Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure +/// that this large collection of bitfields is a trivial class type. +class CodeGenOptionsBase { +public: +#define CODEGENOPT(Name, Bits, Default) unsigned Name : Bits; +#define ENUM_CODEGENOPT(Name, Type, Bits, Default) +#include "clang/Basic/CodeGenOptions.def" + +protected: +#define CODEGENOPT(Name, Bits, Default) +#define ENUM_CODEGENOPT(Name, Type, Bits, Default) unsigned Name : Bits; +#include "clang/Basic/CodeGenOptions.def" +}; + +/// CodeGenOptions - Track various options which control how the code +/// is optimized and passed to the backend. +class CodeGenOptions : public CodeGenOptionsBase { +public: + enum InliningMethod { + NormalInlining, // Use the standard function inlining pass. + OnlyHintInlining, // Inline only (implicitly) hinted functions. + OnlyAlwaysInlining // Only run the always inlining pass. + }; + + enum VectorLibrary { + NoLibrary, // Don't use any vector library. + Accelerate, // Use the Accelerate framework. + SVML // Intel short vector math library. + }; + + + enum ObjCDispatchMethodKind { + Legacy = 0, + NonLegacy = 1, + Mixed = 2 + }; + + enum TLSModel { + GeneralDynamicTLSModel, + LocalDynamicTLSModel, + InitialExecTLSModel, + LocalExecTLSModel + }; + + enum DwarfFissionKind { NoFission, SplitFileFission, SingleFileFission }; + + /// Clang versions with different platform ABI conformance. + enum class ClangABI { + /// Attempt to be ABI-compatible with code generated by Clang 3.8.x + /// (SVN r257626). This causes <1 x long long> to be passed in an + /// integer register instead of an SSE register on x64_64. + Ver3_8, + + /// Attempt to be ABI-compatible with code generated by Clang 4.0.x + /// (SVN r291814). This causes move operations to be ignored when + /// determining whether a class type can be passed or returned directly. + Ver4, + + /// Conform to the underlying platform's C and C++ ABIs as closely + /// as we can. + Latest + }; + + enum StructReturnConventionKind { + SRCK_Default, // No special option was passed. + SRCK_OnStack, // Small structs on the stack (-fpcc-struct-return). + SRCK_InRegs // Small structs in registers (-freg-struct-return). + }; + + enum ProfileInstrKind { + ProfileNone, // Profile instrumentation is turned off. + ProfileClangInstr, // Clang instrumentation to generate execution counts + // to use with PGO. + ProfileIRInstr, // IR level PGO instrumentation in LLVM. + }; + + enum EmbedBitcodeKind { + Embed_Off, // No embedded bitcode. + Embed_All, // Embed both bitcode and commandline in the output. + Embed_Bitcode, // Embed just the bitcode in the output. + Embed_Marker // Embed a marker as a placeholder for bitcode. + }; + + enum SignReturnAddressScope { + None, // No signing for any function + NonLeaf, // Sign the return address of functions that spill LR + All // Sign the return address of all functions + }; + + enum SignReturnAddressKeyValue { AKey, BKey }; + + /// The code model to use (-mcmodel). + std::string CodeModel; + + /// The filename with path we use for coverage data files. The runtime + /// allows further manipulation with the GCOV_PREFIX and GCOV_PREFIX_STRIP + /// environment variables. + std::string CoverageDataFile; + + /// The filename with path we use for coverage notes files. + std::string CoverageNotesFile; + + /// Regexes separated by a semi-colon to filter the files to instrument. + std::string ProfileFilterFiles; + + /// Regexes separated by a semi-colon to filter the files to not instrument. + std::string ProfileExcludeFiles; + + /// The version string to put into coverage files. + char CoverageVersion[4]; + + /// Enable additional debugging information. + std::string DebugPass; + + /// The string to embed in debug information as the current working directory. + std::string DebugCompilationDir; + + /// The string to embed in the debug information for the compile unit, if + /// non-empty. + std::string DwarfDebugFlags; + + /// The string containing the commandline for the llvm.commandline metadata, + /// if non-empty. + std::string RecordCommandLine; + + std::map<std::string, std::string> DebugPrefixMap; + + /// The ABI to use for passing floating point arguments. + std::string FloatABI; + + /// The floating-point denormal mode to use. + std::string FPDenormalMode; + + /// The float precision limit to use, if non-empty. + std::string LimitFloatPrecision; + + struct BitcodeFileToLink { + /// The filename of the bitcode file to link in. + std::string Filename; + /// If true, we set attributes functions in the bitcode library according to + /// our CodeGenOptions, much as we set attrs on functions that we generate + /// ourselves. + bool PropagateAttrs = false; + /// If true, we use LLVM module internalizer. + bool Internalize = false; + /// Bitwise combination of llvm::Linker::Flags, passed to the LLVM linker. + unsigned LinkFlags = 0; + }; + + /// The files specified here are linked in to the module before optimizations. + std::vector<BitcodeFileToLink> LinkBitcodeFiles; + + /// The user provided name for the "main file", if non-empty. This is useful + /// in situations where the input file name does not match the original input + /// file, for example with -save-temps. + std::string MainFileName; + + /// The name for the split debug info file that we'll break out. This is used + /// in the backend for setting the name in the skeleton cu. + std::string SplitDwarfFile; + + /// The name of the relocation model to use. + llvm::Reloc::Model RelocationModel; + + /// The thread model to use + std::string ThreadModel; + + /// If not an empty string, trap intrinsics are lowered to calls to this + /// function instead of to trap instructions. + std::string TrapFuncName; + + /// A list of dependent libraries. + std::vector<std::string> DependentLibraries; + + /// A list of linker options to embed in the object file. + std::vector<std::string> LinkerOptions; + + /// Name of the profile file to use as output for -fprofile-instr-generate + /// and -fprofile-generate. + std::string InstrProfileOutput; + + /// Name of the profile file to use with -fprofile-sample-use. + std::string SampleProfileFile; + + /// Name of the profile file to use as input for -fprofile-instr-use + std::string ProfileInstrumentUsePath; + + /// Name of the profile remapping file to apply to the profile data supplied + /// by -fprofile-sample-use or -fprofile-instr-use. + std::string ProfileRemappingFile; + + /// Name of the function summary index file to use for ThinLTO function + /// importing. + std::string ThinLTOIndexFile; + + /// Name of a file that can optionally be written with minimized bitcode + /// to be used as input for the ThinLTO thin link step, which only needs + /// the summary and module symbol table (and not, e.g. any debug metadata). + std::string ThinLinkBitcodeFile; + + /// Prefix to use for -save-temps output. + std::string SaveTempsFilePrefix; + + /// Name of file passed with -fcuda-include-gpubinary option to forward to + /// CUDA runtime back-end for incorporating them into host-side object file. + std::string CudaGpuBinaryFileName; + + /// The name of the file to which the backend should save YAML optimization + /// records. + std::string OptRecordFile; + + /// Regular expression to select optimizations for which we should enable + /// optimization remarks. Transformation passes whose name matches this + /// expression (and support this feature), will emit a diagnostic + /// whenever they perform a transformation. This is enabled by the + /// -Rpass=regexp flag. + std::shared_ptr<llvm::Regex> OptimizationRemarkPattern; + + /// Regular expression to select optimizations for which we should enable + /// missed optimization remarks. Transformation passes whose name matches this + /// expression (and support this feature), will emit a diagnostic + /// whenever they tried but failed to perform a transformation. This is + /// enabled by the -Rpass-missed=regexp flag. + std::shared_ptr<llvm::Regex> OptimizationRemarkMissedPattern; + + /// Regular expression to select optimizations for which we should enable + /// optimization analyses. Transformation passes whose name matches this + /// expression (and support this feature), will emit a diagnostic + /// whenever they want to explain why they decided to apply or not apply + /// a given transformation. This is enabled by the -Rpass-analysis=regexp + /// flag. + std::shared_ptr<llvm::Regex> OptimizationRemarkAnalysisPattern; + + /// Set of files defining the rules for the symbol rewriting. + std::vector<std::string> RewriteMapFiles; + + /// Set of sanitizer checks that are non-fatal (i.e. execution should be + /// continued when possible). + SanitizerSet SanitizeRecover; + + /// Set of sanitizer checks that trap rather than diagnose. + SanitizerSet SanitizeTrap; + + /// List of backend command-line options for -fembed-bitcode. + std::vector<uint8_t> CmdArgs; + + /// A list of all -fno-builtin-* function names (e.g., memset). + std::vector<std::string> NoBuiltinFuncs; + + std::vector<std::string> Reciprocals; + + /// The preferred width for auto-vectorization transforms. This is intended to + /// override default transforms based on the width of the architected vector + /// registers. + std::string PreferVectorWidth; + + /// Set of XRay instrumentation kinds to emit. + XRayInstrSet XRayInstrumentationBundle; + + std::vector<std::string> DefaultFunctionAttrs; + +public: + // Define accessors/mutators for code generation options of enumeration type. +#define CODEGENOPT(Name, Bits, Default) +#define ENUM_CODEGENOPT(Name, Type, Bits, Default) \ + Type get##Name() const { return static_cast<Type>(Name); } \ + void set##Name(Type Value) { Name = static_cast<unsigned>(Value); } +#include "clang/Basic/CodeGenOptions.def" + + CodeGenOptions(); + + /// Is this a libc/libm function that is no longer recognized as a + /// builtin because a -fno-builtin-* option has been specified? + bool isNoBuiltinFunc(const char *Name) const; + + const std::vector<std::string> &getNoBuiltinFuncs() const { + return NoBuiltinFuncs; + } + + /// Check if Clang profile instrumenation is on. + bool hasProfileClangInstr() const { + return getProfileInstr() == ProfileClangInstr; + } + + /// Check if IR level profile instrumentation is on. + bool hasProfileIRInstr() const { + return getProfileInstr() == ProfileIRInstr; + } + + /// Check if Clang profile use is on. + bool hasProfileClangUse() const { + return getProfileUse() == ProfileClangInstr; + } + + /// Check if IR level profile use is on. + bool hasProfileIRUse() const { + return getProfileUse() == ProfileIRInstr; + } + +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/Cuda.h b/include/clang/Basic/Cuda.h index 24159e160f3f..0575e703338e 100644 --- a/include/clang/Basic/Cuda.h +++ b/include/clang/Basic/Cuda.h @@ -24,7 +24,8 @@ enum class CudaVersion { CUDA_90, CUDA_91, CUDA_92, - LATEST = CUDA_92, + CUDA_100, + LATEST = CUDA_100, }; const char *CudaVersionToString(CudaVersion V); @@ -47,6 +48,7 @@ enum class CudaArch { SM_62, SM_70, SM_72, + SM_75, GFX600, GFX601, GFX700, @@ -60,6 +62,9 @@ enum class CudaArch { GFX810, GFX900, GFX902, + GFX904, + GFX906, + GFX909, LAST, }; const char *CudaArchToString(CudaArch A); @@ -82,6 +87,7 @@ enum class CudaVirtualArch { COMPUTE_62, COMPUTE_70, COMPUTE_72, + COMPUTE_75, COMPUTE_AMDGCN, }; const char *CudaVirtualArchToString(CudaVirtualArch A); diff --git a/include/clang/Basic/DebugInfoOptions.h b/include/clang/Basic/DebugInfoOptions.h index 037c813c6114..f3be0fe52d31 100644 --- a/include/clang/Basic/DebugInfoOptions.h +++ b/include/clang/Basic/DebugInfoOptions.h @@ -13,6 +13,11 @@ namespace clang { namespace codegenoptions { +enum DebugInfoFormat { + DIF_DWARF, + DIF_CodeView, +}; + enum DebugInfoKind { NoDebugInfo, /// Don't generate debug info. LocTrackingOnly, /// Emit location information but do not generate @@ -21,6 +26,7 @@ enum DebugInfoKind { /// locations for instructions without actually /// emitting debug info for them (e.g., when -Rpass /// is used). + DebugDirectivesOnly, /// Emit only debug directives with the line numbers data DebugLineTablesOnly, /// Emit only debug info necessary for generating /// line number tables (-gline-tables-only). LimitedDebugInfo, /// Limit generated debug info to reduce size diff --git a/include/clang/Basic/DeclNodes.td b/include/clang/Basic/DeclNodes.td index 67ca9e5c6c62..a184b480f7c0 100644 --- a/include/clang/Basic/DeclNodes.td +++ b/include/clang/Basic/DeclNodes.td @@ -97,5 +97,6 @@ def Captured : Decl, DeclContext; def ClassScopeFunctionSpecialization : Decl; def Import : Decl; def OMPThreadPrivate : Decl; +def OMPRequires : Decl; def Empty : Decl; diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h index d30ac14e02fe..a516721ace6d 100644 --- a/include/clang/Basic/Diagnostic.h +++ b/include/clang/Basic/Diagnostic.h @@ -177,6 +177,9 @@ public: /// IdentifierInfo ak_identifierinfo, + /// Qualifiers + ak_qual, + /// QualType ak_qualtype, @@ -486,10 +489,8 @@ public: DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete; ~DiagnosticsEngine(); - LLVM_DUMP_METHOD void dump() const { DiagStatesByLoc.dump(*SourceMgr); } - LLVM_DUMP_METHOD void dump(StringRef DiagName) const { - DiagStatesByLoc.dump(*SourceMgr, DiagName); - } + LLVM_DUMP_METHOD void dump() const; + LLVM_DUMP_METHOD void dump(StringRef DiagName) const; const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagnosticIDs() const { return Diags; diff --git a/include/clang/Basic/DiagnosticAST.h b/include/clang/Basic/DiagnosticAST.h new file mode 100644 index 000000000000..b0e9178d9b0b --- /dev/null +++ b/include/clang/Basic/DiagnosticAST.h @@ -0,0 +1,29 @@ +//===--- DiagnosticAST.h - Diagnostics for the AST library ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICAST_H +#define LLVM_CLANG_BASIC_DIAGNOSTICAST_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define ASTSTART +#include "clang/Basic/DiagnosticASTKinds.inc" +#undef DIAG + NUM_BUILTIN_AST_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICAST_H diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td index 3358fc3d70c7..c39673a44ac0 100644 --- a/include/clang/Basic/DiagnosticASTKinds.td +++ b/include/clang/Basic/DiagnosticASTKinds.td @@ -121,6 +121,8 @@ def note_constexpr_ltor_non_const_int : Note< "read of non-const variable %0 is not allowed in a constant expression">; def note_constexpr_ltor_non_constexpr : Note< "read of non-constexpr variable %0 is not allowed in a constant expression">; +def note_constexpr_ltor_incomplete_type : Note< + "read of incomplete type %0 is not allowed in a constant expression">; def note_constexpr_access_null : Note< "%select{read of|assignment to|increment of|decrement of}0 " "dereferenced null pointer is not allowed in a constant expression">; @@ -163,12 +165,19 @@ def note_constexpr_unsupported_unsized_array : Note< def note_constexpr_unsized_array_indexed : Note< "indexing of array without known bound is not allowed " "in a constant expression">; +def note_constexpr_memcpy_null : Note< + "%select{source|destination}2 of " + "'%select{%select{memcpy|wmemcpy}1|%select{memmove|wmemmove}1}0' " + "is %3">; def note_constexpr_memcpy_type_pun : Note< "cannot constant evaluate '%select{memcpy|memmove}0' from object of " "type %1 to object of type %2">; def note_constexpr_memcpy_nontrivial : Note< "cannot constant evaluate '%select{memcpy|memmove}0' between objects of " "non-trivially-copyable type %1">; +def note_constexpr_memcpy_incomplete_type : Note< + "cannot constant evaluate '%select{memcpy|memmove}0' between objects of " + "incomplete type %1">; def note_constexpr_memcpy_overlap : Note< "'%select{memcpy|wmemcpy}0' between overlapping memory regions">; def note_constexpr_memcpy_unsupported : Note< @@ -305,4 +314,34 @@ def err_odr_non_type_parameter_type_inconsistent : Error< "non-type template parameter declared with incompatible types in different " "translation units (%0 vs. %1)">; def err_unsupported_ast_node: Error<"cannot import unsupported AST node %0">; + +def remark_sanitize_address_insert_extra_padding_accepted : Remark< + "-fsanitize-address-field-padding applied to %0">, ShowInSystemHeader, + InGroup<SanitizeAddressRemarks>; +def remark_sanitize_address_insert_extra_padding_rejected : Remark< + "-fsanitize-address-field-padding ignored for %0 because it " + "%select{is not C++|is packed|is a union|is trivially copyable|" + "has trivial destructor|is standard layout|is in a blacklisted file|" + "is blacklisted}1">, ShowInSystemHeader, + InGroup<SanitizeAddressRemarks>; + +def warn_npot_ms_struct : Warning< + "ms_struct may not produce Microsoft-compatible layouts with fundamental " + "data types with sizes that aren't a power of two">, + DefaultError, InGroup<IncompatibleMSStruct>; + +// -Wpadded, -Wpacked +def warn_padded_struct_field : Warning< + "padding %select{struct|interface|class}0 %1 with %2 " + "%select{byte|bit}3%s2 to align %4">, + InGroup<Padded>, DefaultIgnore; +def warn_padded_struct_anon_field : Warning< + "padding %select{struct|interface|class}0 %1 with %2 " + "%select{byte|bit}3%s2 to align anonymous bit-field">, + InGroup<Padded>, DefaultIgnore; +def warn_padded_struct_size : Warning< + "padding size of %0 with %1 %select{byte|bit}2%s1 to alignment boundary">, + InGroup<Padded>, DefaultIgnore; +def warn_unnecessary_packed : Warning< + "packed attribute is unnecessary for %0">, InGroup<Packed>, DefaultIgnore; } diff --git a/include/clang/Basic/DiagnosticAnalysis.h b/include/clang/Basic/DiagnosticAnalysis.h new file mode 100644 index 000000000000..3748b538d2d2 --- /dev/null +++ b/include/clang/Basic/DiagnosticAnalysis.h @@ -0,0 +1,29 @@ +//===--- DiagnosticAnalysis.h - Diagnostics for libanalysis -----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICANALYSIS_H +#define LLVM_CLANG_BASIC_DIAGNOSTICANALYSIS_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define ANALYSISSTART +#include "clang/Basic/DiagnosticAnalysisKinds.inc" +#undef DIAG + NUM_BUILTIN_ANALYSIS_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICANALYSIS_H diff --git a/include/clang/Basic/DiagnosticComment.h b/include/clang/Basic/DiagnosticComment.h new file mode 100644 index 000000000000..a6c5f182cb32 --- /dev/null +++ b/include/clang/Basic/DiagnosticComment.h @@ -0,0 +1,29 @@ +//===--- DiagnosticComment.h - Diagnostics for the AST library --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICCOMMENT_H +#define LLVM_CLANG_BASIC_DIAGNOSTICCOMMENT_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define COMMENTSTART +#include "clang/Basic/DiagnosticCommentKinds.inc" +#undef DIAG + NUM_BUILTIN_COMMENT_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICCOMMENT_H diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index b98b183c9d6f..34ce489e50b2 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -131,6 +131,36 @@ def err_nullability_conflicting : Error< } +// OpenCL Section 6.8.g +def err_opencl_unknown_type_specifier : Error< + "OpenCL %select{C|C++}0 version %1 does not support the '%2' " + "%select{type qualifier|storage class specifier}3">; + +def warn_unknown_attribute_ignored : Warning< + "unknown attribute %0 ignored">, InGroup<UnknownAttributes>; +def err_use_of_tag_name_without_tag : Error< + "must use '%1' tag to refer to type %0%select{| in this scope}2">; + +def duplicate_declspec : TextSubstitution< + "duplicate '%0' declaration specifier">; + +def ext_duplicate_declspec : Extension<"%sub{duplicate_declspec}0">, + InGroup<DuplicateDeclSpecifier>; +def ext_warn_duplicate_declspec : ExtWarn<"%sub{duplicate_declspec}0">, + InGroup<DuplicateDeclSpecifier>; +def warn_duplicate_declspec : Warning<"%sub{duplicate_declspec}0">, + InGroup<DuplicateDeclSpecifier>; + +def err_friend_decl_spec : Error<"'%0' is invalid in friend declarations">; + +def err_invalid_member_in_interface : Error< + "%select{data member |non-public member function |static member function |" + "user-declared constructor|user-declared destructor|operator |" + "nested class }0%1 is not permitted within an interface type">; + +def err_attribute_uuid_malformed_guid : Error< + "uuid attribute contains a malformed GUID">; + // Sema && Lex def ext_c99_longlong : Extension< "'long long' is an extension when C99 mode is not enabled">, @@ -172,6 +202,8 @@ def err_too_large_for_fixed_point : Error< "this value is too large for this fixed point type">; def err_fixed_point_not_enabled : Error<"compile with " "'-ffixed-point' to enable fixed point types">; +def err_unimplemented_conversion_with_fixed_point_type : Error< + "conversion between fixed point and %0 is not yet supported">; // SEH def err_seh_expected_handler : Error< @@ -187,6 +219,16 @@ def err_seh___finally_block : Error< def note_invalid_subexpr_in_const_expr : Note< "subexpression not valid in a constant expression">; +// Sema && Frontend +let CategoryName = "Inline Assembly Issue" in { + def err_asm_invalid_type_in_input : Error< + "invalid type %0 in asm input for constraint '%1'">; +} + +// Sema && Serialization +def warn_dup_category_def : Warning< + "duplicate definition of category %1 on interface %0">; + // Targets def err_target_unknown_triple : Error< @@ -199,6 +241,9 @@ def err_target_unknown_abi : Error<"unknown target ABI '%0'">; def err_target_unsupported_abi : Error<"ABI '%0' is not supported on CPU '%1'">; def err_target_unsupported_abi_for_triple : Error< "ABI '%0' is not supported for '%1'">; +def err_unsupported_abi_for_opt : Error<"'%0' can only be used with the '%1' ABI">; +def err_mips_fp64_req : Error< + "'%0' can only be used if the target supports the mfhc1 and mthc1 instructions">; def err_target_unknown_fpmath : Error<"unknown FP unit '%0'">; def err_target_unsupported_fpmath : Error< "the '%0' unit is not supported with this instruction set">; @@ -245,4 +290,10 @@ def err_openclcxx_not_supported : Error< // OpenMP def err_omp_more_one_clause : Error< "directive '#pragma omp %0' cannot contain more than one '%1' clause%select{| with '%3' name modifier| with 'source' dependence}2">; + +// Static Analyzer Core +def err_unknown_analyzer_checker : Error< + "no analyzer checkers are associated with '%0'">; +def note_suggest_disabling_all_checkers : Note< + "use -analyzer-disable-all-checks to disable all static analyzer checkers">; } diff --git a/include/clang/Basic/DiagnosticCrossTU.h b/include/clang/Basic/DiagnosticCrossTU.h new file mode 100644 index 000000000000..8cff33479f43 --- /dev/null +++ b/include/clang/Basic/DiagnosticCrossTU.h @@ -0,0 +1,29 @@ +//===--- DiagnosticCrossTU.h - Diagnostics for Cross TU ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICCROSSTU_H +#define LLVM_CLANG_BASIC_DIAGNOSTICCROSSTU_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define CROSSTUSTART +#include "clang/Basic/DiagnosticCrossTUKinds.inc" +#undef DIAG + NUM_BUILTIN_CROSSTU_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICCROSSTU_H diff --git a/include/clang/Basic/DiagnosticCrossTUKinds.td b/include/clang/Basic/DiagnosticCrossTUKinds.td index 8b6d8b681445..89e261c84bc6 100644 --- a/include/clang/Basic/DiagnosticCrossTUKinds.td +++ b/include/clang/Basic/DiagnosticCrossTUKinds.td @@ -9,10 +9,17 @@ let Component = "CrossTU" in { -def err_fnmap_parsing : Error< +def err_ctu_error_opening : Error< + "error opening '%0': required by the CrossTU functionality">; + +def err_extdefmap_parsing : Error< "error parsing index file: '%0' line: %1 'UniqueID filename' format " "expected">; def err_multiple_def_index : Error< "multiple definitions are found for the same key in index ">; + +def warn_ctu_incompat_triple : Warning< + "imported AST from '%0' had been generated for a different target, " + "current: %1, imported: %2">, InGroup<CrossTU>; } diff --git a/include/clang/Basic/DiagnosticDriver.h b/include/clang/Basic/DiagnosticDriver.h new file mode 100644 index 000000000000..2ab9b3e08366 --- /dev/null +++ b/include/clang/Basic/DiagnosticDriver.h @@ -0,0 +1,29 @@ +//===--- DiagnosticDriver.h - Diagnostics for libdriver ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICDRIVER_H +#define LLVM_CLANG_BASIC_DIAGNOSTICDRIVER_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define DRIVERSTART +#include "clang/Basic/DiagnosticDriverKinds.inc" +#undef DIAG + NUM_BUILTIN_DRIVER_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICDRIVER_H diff --git a/include/clang/Basic/DiagnosticDriverKinds.td b/include/clang/Basic/DiagnosticDriverKinds.td index 7f75f45c6578..5475e28ed754 100644 --- a/include/clang/Basic/DiagnosticDriverKinds.td +++ b/include/clang/Basic/DiagnosticDriverKinds.td @@ -151,9 +151,6 @@ def warn_drv_unknown_argument_clang_cl_with_suggestion : Warning< "unknown argument ignored in clang-cl '%0' (did you mean '%1'?)">, InGroup<UnknownArgument>; -def warn_drv_ycyu_no_arg_clang_cl : Warning< - "support for '%0' without a filename not implemented yet; flag ignored">, - InGroup<ClangClPch>; def warn_drv_ycyu_different_arg_clang_cl : Warning< "support for '/Yc' and '/Yu' with different filenames not implemented yet; flags ignored">, InGroup<ClangClPch>; @@ -164,6 +161,9 @@ def warn_drv_yc_multiple_inputs_clang_cl : Warning< "support for '/Yc' with more than one source file not implemented yet; flag ignored">, InGroup<ClangClPch>; +def err_drv_dllexport_inlines_and_fallback : Error< + "option '/Zc:dllexportInlines-' is ABI-changing and not compatible with '/fallback'">; + def err_drv_invalid_value : Error<"invalid value '%1' in '%0'">; def err_drv_invalid_int_value : Error<"invalid integral value '%1' in '%0'">; def err_drv_invalid_remap_file : Error< @@ -193,6 +193,9 @@ def err_drv_mg_requires_m_or_mm : Error< "option '-MG' requires '-M' or '-MM'">; def err_drv_unknown_objc_runtime : Error< "unknown or ill-formed Objective-C runtime '%0'">; +def err_drv_invalid_cf_runtime_abi + : Error<"invalid CoreFoundation Runtime ABI '%0'; must be one of " + "'objc', 'standalone', 'swift', 'swift-5.0', 'swift-4.2', 'swift-4.1'">; def err_drv_gnustep_objc_runtime_incompatible_binary : Error< "GNUstep Objective-C runtime version %0 incompatible with target binary format">; def err_drv_emit_llvm_link : Error< @@ -213,6 +216,8 @@ def warn_drv_omp_offload_target_duplicate : Warning< def warn_drv_omp_offload_target_missingbcruntime : Warning< "No library '%0' found in the default clang lib directory or in LIBRARY_PATH. Expect degraded performance due to no inlining of runtime functions on target devices.">, InGroup<OpenMPTarget>; +def err_drv_unsupported_embed_bitcode + : Error<"%0 is not supported with -fembed-bitcode">; def err_drv_bitcode_unsupported_on_toolchain : Error< "-fembed-bitcode is not supported on versions of iOS prior to 6.0">; @@ -277,6 +282,8 @@ def warn_drv_disabling_vptr_no_rtti_default : Warning< def warn_drv_object_size_disabled_O0 : Warning< "the object size sanitizer has no effect at -O0, but is explicitly enabled: %0">, InGroup<InvalidCommandLineArgument>, DefaultWarnNoWerror; +def err_invalid_branch_protection: Error < + "invalid branch protection option '%0' in '%1'">; def note_drv_command_failed_diag_msg : Note< "diagnostic msg: %0">; @@ -292,6 +299,9 @@ def err_analyzer_config_no_value : Error< "analyzer-config option '%0' has a key but no value">; def err_analyzer_config_multiple_values : Error< "analyzer-config option '%0' should contain only one '='">; +def err_analyzer_config_invalid_input : Error< + "invalid input for analyzer-config option '%0', that expects %1 value">; +def err_analyzer_config_unknown : Error<"unknown analyzer-config '%0'">; def err_drv_invalid_hvx_length : Error< "-mhvx-length is not supported without a -mhvx/-mhvx= flag">; @@ -299,6 +309,9 @@ def warn_drv_vectorize_needs_hvx : Warning< "auto-vectorization requires HVX, use -mhvx to enable it">, InGroup<OptionIgnored>; +def err_drv_module_header_wrong_kind : Error< + "header file '%0' input type '%1' does not match type of prior input " + "in module compilation; use '-x %2' to override">; def err_drv_modules_validate_once_requires_timestamp : Error< "option '-fmodules-validate-once-per-build-session' requires " "'-fbuild-session-timestamp=<seconds since Epoch>' or '-fbuild-session-file=<file>'">; @@ -347,7 +360,7 @@ def warn_drv_unsupported_pic_with_mabicalls : Warning< "%select{implicit usage of|}1 -mabicalls and the N64 ABI">, InGroup<OptionIgnored>; def err_drv_unsupported_noabicalls_pic : Error< - "position-independent code requires ‘-mabicalls’">; + "position-independent code requires '-mabicalls'">; def err_drv_unsupported_indirect_jump_opt : Error< "'-mindirect-jump=%0' is unsupported with the '%1' architecture">; def err_drv_unknown_indirect_jump_opt : Error< @@ -392,4 +405,24 @@ def warn_drv_experimental_isel_incomplete_opt : Warning< def warn_drv_moutline_unsupported_opt : Warning< "The '%0' architecture does not support -moutline; flag ignored">, InGroup<OptionIgnored>; + +def warn_drv_darwin_sdk_invalid_settings : Warning< + "SDK settings were ignored as 'SDKSettings.json' could not be parsed">, + InGroup<DiagGroup<"darwin-sdk-settings">>; + +def err_drv_trivial_auto_var_init_zero_disabled : Error< + "-ftrivial-auto-var-init=zero hasn't been enabled. Enable it at your own peril for benchmarking purpose only with " + "-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang">; + +def warn_drv_msp430_hwmult_unsupported : Warning<"the given MCU does not " + "support hardware multiply, but -mhwmult is set to %0.">, + InGroup<InvalidCommandLineArgument>; +def warn_drv_msp430_hwmult_mismatch : Warning<"the given MCU supports %0 " + "hardware multiply, but -mhwmult is set to %1.">, + InGroup<InvalidCommandLineArgument>; +def warn_drv_msp430_hwmult_no_device : Warning<"no MCU device specified, but " + "'-mhwmult' is set to 'auto', assuming no hardware multiply. Use -mmcu to " + "specify a MSP430 device, or -mhwmult to set hardware multiply type " + "explicitly.">, InGroup<InvalidCommandLineArgument>; + } diff --git a/include/clang/Basic/DiagnosticFrontend.h b/include/clang/Basic/DiagnosticFrontend.h new file mode 100644 index 000000000000..1f066cf491ae --- /dev/null +++ b/include/clang/Basic/DiagnosticFrontend.h @@ -0,0 +1,29 @@ +//===--- DiagnosticFrontend.h - Diagnostics for frontend --------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICFRONTEND_H +#define LLVM_CLANG_BASIC_DIAGNOSTICFRONTEND_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define FRONTENDSTART +#include "clang/Basic/DiagnosticFrontendKinds.inc" +#undef DIAG + NUM_BUILTIN_FRONTEND_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICFRONTEND_H diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td index 66287933b7ca..927b8cbc2477 100644 --- a/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/include/clang/Basic/DiagnosticFrontendKinds.td @@ -63,16 +63,6 @@ def note_fe_backend_invalid_loc : Note<"could " def err_fe_backend_unsupported : Error<"%0">, BackendInfo; -def remark_sanitize_address_insert_extra_padding_accepted : Remark< - "-fsanitize-address-field-padding applied to %0">, ShowInSystemHeader, - InGroup<SanitizeAddressRemarks>; -def remark_sanitize_address_insert_extra_padding_rejected : Remark< - "-fsanitize-address-field-padding ignored for %0 because it " - "%select{is not C++|is packed|is a union|is trivially copyable|" - "has trivial destructor|is standard layout|is in a blacklisted file|" - "is blacklisted}1">, ShowInSystemHeader, - InGroup<SanitizeAddressRemarks>; - def err_fe_invalid_code_complete_file : Error< "cannot locate code-completion file %0">, DefaultFatal; def err_fe_stdout_binary : Error<"unable to change standard output to binary">, @@ -99,8 +89,6 @@ def err_fe_unable_to_interface_with_target : Error< "unable to interface with target machine">; def err_fe_unable_to_open_output : Error< "unable to open output file '%0': '%1'">; -def err_fe_pth_file_has_no_source_header : Error< - "PTH file '%0' does not designate an original source header file for -include-pth">; def warn_fe_macro_contains_embedded_newline : Warning< "macro '%0' contains embedded newline; text after the newline is ignored">; def warn_fe_cc_print_header_failure : Warning< @@ -172,11 +160,6 @@ def warn_unknown_warning_specifier : Warning< "unknown %0 warning specifier: '%1'">, InGroup<UnknownWarningOption>; -def err_unknown_analyzer_checker : Error< - "no analyzer checkers are associated with '%0'">; -def note_suggest_disabling_all_checkers : Note< - "use -analyzer-disable-all-checks to disable all static analyzer checkers">; - def warn_incompatible_analyzer_plugin_api : Warning< "checker plugin '%0' is not compatible with this version of the analyzer">, InGroup<DiagGroup<"analyzer-incompatible-plugin"> >; @@ -187,6 +170,8 @@ def err_module_build_requires_fmodules : Error< "module compilation requires '-fmodules'">; def err_module_interface_requires_modules_ts : Error< "module interface compilation requires '-fmodules-ts'">; +def err_header_module_requires_modules : Error< + "header module compilation requires '-fmodules' or '-fmodules-ts'">; def warn_module_config_mismatch : Warning< "module file %0 cannot be loaded due to a configuration mismatch with the current " "compilation">, InGroup<DiagGroup<"module-file-config-mismatch">>, DefaultError; @@ -224,6 +209,10 @@ def remark_module_build_done : Remark<"finished building module '%0'">, def err_modules_embed_file_not_found : Error<"file '%0' specified by '-fmodules-embed-file=' not found">, DefaultFatal; +def err_module_header_file_not_found : + Error<"module header file '%0' not found">, DefaultFatal; +def err_module_header_file_invalid : + Error<"unexpected module header file input '%0'">, DefaultFatal; def err_test_module_file_extension_version : Error< "test module file extension '%0' has different version (%1.%2) than expected " @@ -238,7 +227,52 @@ def warn_option_invalid_ocl_version : Warning< "OpenCL version %0 does not support the option '%1'">, InGroup<Deprecated>; def warn_stdlibcxx_not_found : Warning< - "include path for stdlibc++ headers not found; pass '-std=libc++' on the " + "include path for stdlibc++ headers not found; pass '-stdlib=libc++' on the " "command line to use the libc++ standard library instead">, InGroup<DiagGroup<"stdlibcxx-not-found">>; + +def err_builtin_needs_feature : Error<"%0 needs target feature %1">; +def err_function_needs_feature : Error< + "always_inline function %1 requires target feature '%2', but would " + "be inlined into function %0 that is compiled without support for '%2'">; + +def err_alias_to_undefined : Error< + "%select{alias|ifunc}0 must point to a defined " + "%select{variable or |}1function">; +def warn_alias_to_weak_alias : Warning< + "%select{alias|ifunc}2 will always resolve to %0 even if weak definition of " + "%1 is overridden">, + InGroup<IgnoredAttributes>; +def err_duplicate_mangled_name : Error< + "definition with same mangled name '%0' as another definition">; +def err_cyclic_alias : Error< + "%select{alias|ifunc}0 definition is part of a cycle">; +def err_ifunc_resolver_return : Error< + "ifunc resolver function must return a pointer">; + +def warn_atomic_op_misaligned : Warning< + "%select{large|misaligned}0 atomic operation may incur " + "significant performance penalty">, InGroup<DiagGroup<"atomic-alignment">>; + +def warn_alias_with_section : Warning< + "%select{alias|ifunc}1 will not be in section '%0' but in the same section " + "as the %select{aliasee|resolver}2">, + InGroup<IgnoredAttributes>; + +let CategoryName = "Instrumentation Issue" in { +def warn_profile_data_out_of_date : Warning< + "profile data may be out of date: of %0 function%s0, %1 %plural{1:has|:have}1" + " mismatched data that will be ignored">, + InGroup<ProfileInstrOutOfDate>; +def warn_profile_data_missing : Warning< + "profile data may be incomplete: of %0 function%s0, %1 %plural{1:has|:have}1" + " no data">, + InGroup<ProfileInstrMissing>, + DefaultIgnore; +def warn_profile_data_unprofiled : Warning< + "no profile data available for file \"%0\"">, + InGroup<ProfileInstrUnprofiled>; + +} // end of instrumentation issue category + } diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index 2156ef93c19f..19e187cc5d93 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -59,6 +59,8 @@ def BoolConversion : DiagGroup<"bool-conversion", [PointerBoolConversion, UndefinedBoolConversion]>; def IntConversion : DiagGroup<"int-conversion">; def EnumConversion : DiagGroup<"enum-conversion">; +def ImplicitIntConversion : DiagGroup<"implicit-int-conversion">; +def ImplicitFloatConversion : DiagGroup<"implicit-float-conversion">; def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">; def FloatZeroConversion : DiagGroup<"float-zero-conversion">; @@ -102,7 +104,11 @@ def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">; def MissingNoEscape : DiagGroup<"missing-noescape">; def DeleteIncomplete : DiagGroup<"delete-incomplete">; -def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">; +def DeleteNonAbstractNonVirtualDtor : DiagGroup<"delete-non-abstract-non-virtual-dtor">; +def DeleteAbstractNonVirtualDtor : DiagGroup<"delete-abstract-non-virtual-dtor">; +def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor", + [DeleteNonAbstractNonVirtualDtor, + DeleteAbstractNonVirtualDtor]>; def AbstractFinalClass : DiagGroup<"abstract-final-class">; def CXX11CompatDeprecatedWritableStr : @@ -160,6 +166,8 @@ def GNUEmptyStruct : DiagGroup<"gnu-empty-struct">; def ExtraTokens : DiagGroup<"extra-tokens">; def CXX98CompatExtraSemi : DiagGroup<"c++98-compat-extra-semi">; def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">; +def EmptyInitStatement : DiagGroup<"empty-init-stmt">; +def ExtraSemiStmt : DiagGroup<"extra-semi-stmt", [EmptyInitStatement]>; def ExtraSemi : DiagGroup<"extra-semi", [CXX98CompatExtraSemi, CXX11ExtraSemi]>; @@ -283,6 +291,7 @@ def ExpansionToDefined : DiagGroup<"expansion-to-defined">; def FlagEnum : DiagGroup<"flag-enum">; def IncrementBool : DiagGroup<"increment-bool", [DeprecatedIncrementBool]>; def InfiniteRecursion : DiagGroup<"infinite-recursion">; +def PureVirtualCallFromCtorDtor: DiagGroup<"call-to-pure-virtual-from-ctor-dtor">; def GNUImaginaryConstant : DiagGroup<"gnu-imaginary-constant">; def IgnoredQualifiers : DiagGroup<"ignored-qualifiers">; def : DiagGroup<"import">; @@ -356,6 +365,8 @@ def NullArithmetic : DiagGroup<"null-arithmetic">; def NullCharacter : DiagGroup<"null-character">; def NullDereference : DiagGroup<"null-dereference">; def InitializerOverrides : DiagGroup<"initializer-overrides">; +// For compatibility with GCC; -Woverride-init = -Winitializer-overrides +def : DiagGroup<"override-init", [InitializerOverrides]>; def NonNull : DiagGroup<"nonnull">; def NonPODVarargs : DiagGroup<"non-pod-varargs">; def ClassVarargs : DiagGroup<"class-varargs", [NonPODVarargs]>; @@ -364,7 +375,6 @@ def NonVirtualDtor : DiagGroup<"non-virtual-dtor">; def NullPointerArithmetic : DiagGroup<"null-pointer-arithmetic">; def : DiagGroup<"effc++", [NonVirtualDtor]>; def OveralignedType : DiagGroup<"over-aligned">; -def AlignedAllocationUnavailable : DiagGroup<"aligned-allocation-unavailable">; def OldStyleCast : DiagGroup<"old-style-cast">; def : DiagGroup<"old-style-definition">; def OutOfLineDeclaration : DiagGroup<"out-of-line-declaration">; @@ -381,6 +391,7 @@ def FunctionDefInObjCContainer : DiagGroup<"function-def-in-objc-container">; def BadFunctionCast : DiagGroup<"bad-function-cast">; def ObjCPropertyImpl : DiagGroup<"objc-property-implementation">; def ObjCPropertyNoAttribute : DiagGroup<"objc-property-no-attribute">; +def ObjCPropertyAssignOnObjectType : DiagGroup<"objc-property-assign-on-object-type">; def ObjCProtocolQualifiers : DiagGroup<"objc-protocol-qualifiers">; def ObjCMissingSuperCalls : DiagGroup<"objc-missing-super-calls">; def ObjCDesignatedInit : DiagGroup<"objc-designated-initializers">; @@ -621,7 +632,8 @@ def DeallocInCategory:DiagGroup<"dealloc-in-category">; def SelectorTypeMismatch : DiagGroup<"selector-type-mismatch">; def Selector : DiagGroup<"selector", [SelectorTypeMismatch]>; def Protocol : DiagGroup<"protocol">; -def AtProtocol : DiagGroup<"at-protocol">; +// No longer in use, preserve for backwards compatibility. +def : DiagGroup<"at-protocol">; def PropertyAccessDotSyntax: DiagGroup<"property-access-dot-syntax">; def PropertyAttr : DiagGroup<"property-attribute-mismatch">; def SuperSubClassMismatch : DiagGroup<"super-class-method-mismatch">; @@ -708,6 +720,8 @@ def Conversion : DiagGroup<"conversion", FloatConversion, Shorten64To32, IntConversion, + ImplicitIntConversion, + ImplicitFloatConversion, LiteralConversion, NonLiteralNullConversion, // (1-1)->pointer (etc) NullConversion, // NULL->non-pointer @@ -763,7 +777,8 @@ def Extra : DiagGroup<"extra", [ MissingMethodReturnType, SignCompare, UnusedParameter, - NullPointerArithmetic + NullPointerArithmetic, + EmptyInitStatement ]>; def Most : DiagGroup<"most", [ @@ -1030,3 +1045,8 @@ def ExperimentalISel : DiagGroup<"experimental-isel">; // A warning group specifically for warnings related to function // multiversioning. def FunctionMultiVersioning : DiagGroup<"function-multiversion">; + +def NoDeref : DiagGroup<"noderef">; + +// A group for cross translation unit static analysis related warnings. +def CrossTU : DiagGroup<"ctu">; diff --git a/include/clang/Basic/DiagnosticIDs.h b/include/clang/Basic/DiagnosticIDs.h index 983dcb21cfdf..876629f373a1 100644 --- a/include/clang/Basic/DiagnosticIDs.h +++ b/include/clang/Basic/DiagnosticIDs.h @@ -30,7 +30,7 @@ namespace clang { enum { DIAG_SIZE_COMMON = 300, DIAG_SIZE_DRIVER = 200, - DIAG_SIZE_FRONTEND = 100, + DIAG_SIZE_FRONTEND = 150, DIAG_SIZE_SERIALIZATION = 120, DIAG_SIZE_LEX = 400, DIAG_SIZE_PARSE = 500, diff --git a/include/clang/Basic/DiagnosticLex.h b/include/clang/Basic/DiagnosticLex.h new file mode 100644 index 000000000000..6ec4da80338f --- /dev/null +++ b/include/clang/Basic/DiagnosticLex.h @@ -0,0 +1,29 @@ +//===--- DiagnosticLex.h - Diagnostics for liblex ---------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICLEX_H +#define LLVM_CLANG_BASIC_DIAGNOSTICLEX_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define LEXSTART +#include "clang/Basic/DiagnosticLexKinds.inc" +#undef DIAG + NUM_BUILTIN_LEX_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICLEX_H diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td index 1c960711bccb..14e306246ba3 100644 --- a/include/clang/Basic/DiagnosticLexKinds.td +++ b/include/clang/Basic/DiagnosticLexKinds.td @@ -122,6 +122,9 @@ def ext_unicode_whitespace : ExtWarn< def warn_utf8_symbol_homoglyph : Warning< "treating Unicode character <U+%0> as identifier character rather than " "as '%1' symbol">, InGroup<DiagGroup<"unicode-homoglyph">>; +def warn_utf8_symbol_zero_width : Warning< + "identifier contains Unicode character <U+%0> that is invisible in " + "some environments">, InGroup<DiagGroup<"unicode-zero-width">>; def err_hex_escape_no_digits : Error< "\\%0 used with no following hex digits">; @@ -255,13 +258,6 @@ def warn_bad_character_encoding : ExtWarn< def err_lexing_string : Error<"failure when lexing a string">; def err_placeholder_in_source : Error<"editor placeholder in source file">; - -//===----------------------------------------------------------------------===// -// PTH Diagnostics -//===----------------------------------------------------------------------===// -def err_invalid_pth_file : Error< - "invalid or corrupt PTH file '%0'">; - //===----------------------------------------------------------------------===// // Preprocessor Diagnostics //===----------------------------------------------------------------------===// @@ -409,11 +405,20 @@ def err_pp_through_header_not_found : Error< def err_pp_through_header_not_seen : Error< "#include of '%0' not seen while attempting to " "%select{create|use}1 precompiled header">, DefaultFatal; +def err_pp_pragma_hdrstop_not_seen : Error< + "#pragma hdrstop not seen while attempting to use precompiled header">, + DefaultFatal; def warn_pp_macro_def_mismatch_with_pch : Warning< "definition of macro %0 does not match definition in precompiled header">, InGroup<ClangClPch>; -def err_pp_file_not_found_not_fatal : Error< +def warn_pp_hdrstop_filename_ignored : Warning< + "#pragma hdrstop filename not supported, " + "/Fp can be used to specify precompiled header filename">, + InGroup<ClangClPch>; +def err_pp_file_not_found_angled_include_not_fatal : Error< "'%0' file not found with <angled> include; use \"quotes\" instead">; +def err_pp_file_not_found_typo_not_fatal + : Error<"'%0' file not found, did you mean '%1'?">; def err_pp_error_opening_file : Error< "error opening file '%0': %1">, DefaultFatal; def err_pp_empty_filename : Error<"empty filename">; @@ -558,8 +563,6 @@ def err_pp_module_end_without_module_begin : Error< "'#pragma clang module end'">; def note_pp_module_begin_here : Note< "entering module '%0' due to this pragma">; -def err_pp_module_build_pth : Error< - "'#pragma clang module build' not supported in pretokenized header">; def err_pp_module_build_missing_end : Error< "no matching '#pragma clang module endbuild' for this '#pragma clang module build'">; diff --git a/include/clang/Basic/DiagnosticParse.h b/include/clang/Basic/DiagnosticParse.h new file mode 100644 index 000000000000..2113b03262d7 --- /dev/null +++ b/include/clang/Basic/DiagnosticParse.h @@ -0,0 +1,29 @@ +//===--- DiagnosticParse.h - Diagnostics for libparse -----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICPARSE_H +#define LLVM_CLANG_BASIC_DIAGNOSTICPARSE_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define PARSESTART +#include "clang/Basic/DiagnosticParseKinds.inc" +#undef DIAG + NUM_BUILTIN_PARSE_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICPARSE_H diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index 609dca4f075c..06281e2904c7 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -53,6 +53,10 @@ def ext_extra_semi_cxx11 : Extension< def warn_extra_semi_after_mem_fn_def : Warning< "extra ';' after member function definition">, InGroup<ExtraSemi>, DefaultIgnore; +def warn_null_statement : Warning< + "empty expression statement has no effect; " + "remove unnecessary ';' to silence this warning">, + InGroup<ExtraSemiStmt>, DefaultIgnore; def ext_thread_before : Extension<"'__thread' before '%0'">; def ext_keyword_as_ident : ExtWarn< @@ -88,9 +92,12 @@ def err_enumerator_unnamed_no_def : Error< def ext_cxx11_enum_fixed_underlying_type : Extension< "enumeration types with a fixed underlying type are a C++11 extension">, InGroup<CXX11>; -def ext_c_enum_fixed_underlying_type : Extension< +def ext_ms_c_enum_fixed_underlying_type : Extension< "enumeration types with a fixed underlying type are a Microsoft extension">, InGroup<MicrosoftFixedEnum>; +def ext_clang_c_enum_fixed_underlying_type : Extension< + "enumeration types with a fixed underlying type are a Clang extension">, + InGroup<DiagGroup<"fixed-enum-extension">>; def warn_cxx98_compat_enum_fixed_underlying_type : Warning< "enumeration types with a fixed underlying type are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; @@ -219,6 +226,11 @@ def ext_nested_namespace_definition : ExtWarn< def warn_cxx14_compat_nested_namespace_definition : Warning< "nested namespace definition is incompatible with C++ standards before C++17">, InGroup<CXXPre17Compat>, DefaultIgnore; +def ext_inline_nested_namespace_definition : ExtWarn< + "inline nested namespace definition is a C++2a extension">, InGroup<CXX2a>; +def warn_cxx17_compat_inline_nested_namespace_definition : Warning< + "inline nested namespace definition is incompatible with C++ standards before" + " C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore; def err_inline_nested_namespace_definition : Error< "nested namespace definition cannot be 'inline'">; def err_expected_semi_after_attribute_list : Error< @@ -331,6 +343,10 @@ def err_expected_parentheses_around_typename : Error< def err_expected_case_before_expression: Error< "expected 'case' keyword before expression">; +def ext_warn_gnu_final : ExtWarn< + "__final is a GNU extension, consider using C++11 final">, + InGroup<GccCompat>; + // Declarations. def err_typename_requires_specqual : Error< "type name requires a specifier or qualifier">; @@ -358,6 +374,12 @@ def ext_c11_static_assert : Extension< def warn_cxx98_compat_static_assert : Warning< "static_assert declarations are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def ext_static_assert_no_message : ExtWarn< + "static_assert with no message is a C++17 extension">, InGroup<CXX17>; +def warn_cxx14_compat_static_assert_no_message : Warning< + "static_assert with no message is incompatible with C++ standards before " + "C++17">, + DefaultIgnore, InGroup<CXXPre17Compat>; def err_function_definition_not_allowed : Error< "function definition is not allowed here">; def err_expected_end_of_enumerator : Error< @@ -488,6 +510,13 @@ def err_dynamic_and_noexcept_specification : Error< "cannot have both throw() and noexcept() clause on the same function">; def err_except_spec_unparsed : Error< "unexpected end of exception specification">; +def ext_dynamic_exception_spec : ExtWarn< + "ISO C++17 does not allow dynamic exception specifications">, + InGroup<DynamicExceptionSpec>, DefaultError; +def warn_exception_spec_deprecated : Warning< + "dynamic exception specifications are deprecated">, + InGroup<DeprecatedDynamicExceptionSpec>, DefaultIgnore; +def note_exception_spec_deprecated : Note<"use '%0' instead">; def warn_cxx98_compat_noexcept_decl : Warning< "noexcept specifications are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; @@ -540,6 +569,15 @@ def ext_init_statement : ExtWarn< def warn_cxx14_compat_init_statement : Warning< "%select{if|switch}0 initialization statements are incompatible with " "C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>; +def ext_for_range_init_stmt : ExtWarn< + "range-based for loop initialization statements are a C++2a extension">, + InGroup<CXX2a>; +def warn_cxx17_compat_for_range_init_stmt : Warning< + "range-based for loop initialization statements are incompatible with " + "C++ standards before C++2a">, DefaultIgnore, InGroup<CXXPre2aCompat>; +def warn_empty_init_statement : Warning< + "empty initialization statement of '%select{if|switch|range-based for}0' " + "has no effect">, InGroup<EmptyInitStatement>, DefaultIgnore; // C++ derived classes def err_dup_virtual : Error<"duplicate 'virtual' in base specifier">; @@ -566,6 +604,9 @@ def warn_cxx98_compat_noexcept_expr : Warning< def warn_cxx98_compat_nullptr : Warning< "'nullptr' is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def warn_wrong_clang_attr_namespace : Warning< + "'__clang__' is a predefined macro name, not an attribute scope specifier; " + "did you mean '_Clang' instead?">, InGroup<IgnoredAttributes>; def ext_ns_enum_attribute : Extension< "attributes on %select{a namespace|an enumerator}0 declaration are " "a C++17 extension">, InGroup<CXX17>; @@ -1023,8 +1064,8 @@ def err_pragma_optimize_invalid_argument : Error< def err_pragma_optimize_extra_argument : Error< "unexpected extra argument '%0' to '#pragma clang optimize'">; // - #pragma clang attribute -def err_pragma_attribute_expected_push_pop : Error< - "expected 'push' or 'pop' after '#pragma clang attribute'">; +def err_pragma_attribute_expected_push_pop_paren : Error< + "expected 'push', 'pop', or '(' after '#pragma clang attribute'">; def err_pragma_attribute_invalid_argument : Error< "unexpected argument '%0' to '#pragma clang attribute'; " "expected 'push' or 'pop'">; @@ -1059,6 +1100,13 @@ def err_pragma_attribute_unknown_subject_sub_rule : Error< "sub-rules: %3}2">; def err_pragma_attribute_duplicate_subject : Error< "duplicate attribute subject matcher '%0'">; +def err_pragma_attribute_expected_period : Error< + "expected '.' after pragma attribute namespace %0">; +def err_pragma_attribute_namespace_on_attribute : Error< + "namespace can only apply to 'push' or 'pop' directives">; +def note_pragma_attribute_namespace_on_attribute : Note< + "omit the namespace to add attributes to the most-recently" + " pushed attribute group">; def err_opencl_unroll_hint_on_non_loop : Error< "OpenCL only supports 'opencl_unroll_hint' attribute on for, while, and do statements">; @@ -1116,15 +1164,19 @@ def err_omp_decl_in_declare_simd : Error< def err_omp_unknown_map_type : Error< "incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'">; def err_omp_unknown_map_type_modifier : Error< - "incorrect map type modifier, expected 'always'">; + "incorrect map type modifier, expected 'always' or 'close'">; def err_omp_map_type_missing : Error< "missing map type">; +def err_omp_map_type_modifier_missing : Error< + "missing map type modifier">; def err_omp_declare_simd_inbranch_notinbranch : Error< "unexpected '%0' clause, '%1' is specified already">; def err_expected_end_declare_target : Error< "expected '#pragma omp end declare target'">; def err_omp_declare_target_unexpected_clause: Error< "unexpected '%0' clause, only 'to' or 'link' clauses expected">; +def err_omp_expected_clause: Error< + "expected at least one clause on '#pragma omp %0' directive">; // Pragma loop support. def err_pragma_loop_missing_argument : Error< @@ -1132,7 +1184,8 @@ def err_pragma_loop_missing_argument : Error< "'enable'%select{|, 'full'}1%select{|, 'assume_safety'}2 or 'disable'}0">; def err_pragma_loop_invalid_option : Error< "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, " - "vectorize_width, interleave, interleave_count, unroll, unroll_count, or distribute">; + "vectorize_width, interleave, interleave_count, unroll, unroll_count, " + "pipeline, pipeline_initiation_interval, or distribute">; def err_pragma_fp_invalid_option : Error< "%select{invalid|missing}0 option%select{ %1|}0; expected contract">; @@ -1145,6 +1198,8 @@ def err_pragma_fp_scope : Error< def err_pragma_invalid_keyword : Error< "invalid argument; expected 'enable'%select{|, 'full'}0%select{|, 'assume_safety'}1 or 'disable'">; +def err_pragma_pipeline_invalid_keyword : Error< + "invalid argument; expected 'disable'">; // Pragma unroll support. def warn_pragma_unroll_cuda_value_in_parens : Warning< diff --git a/include/clang/Basic/DiagnosticRefactoring.h b/include/clang/Basic/DiagnosticRefactoring.h new file mode 100644 index 000000000000..8d3914f25289 --- /dev/null +++ b/include/clang/Basic/DiagnosticRefactoring.h @@ -0,0 +1,29 @@ +//===--- DiagnosticRefactoring.h - ------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICREFACTORING_H +#define LLVM_CLANG_BASIC_DIAGNOSTICREFACTORING_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define REFACTORINGSTART +#include "clang/Basic/DiagnosticRefactoringKinds.inc" +#undef DIAG + NUM_BUILTIN_REFACTORING_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICREFACTORING_H diff --git a/include/clang/Basic/DiagnosticSema.h b/include/clang/Basic/DiagnosticSema.h new file mode 100644 index 000000000000..b05b24db5609 --- /dev/null +++ b/include/clang/Basic/DiagnosticSema.h @@ -0,0 +1,29 @@ +//===--- DiagnosticSema.h - Diagnostics for libsema -------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICSEMA_H +#define LLVM_CLANG_BASIC_DIAGNOSTICSEMA_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define SEMASTART +#include "clang/Basic/DiagnosticSemaKinds.inc" +#undef DIAG + NUM_BUILTIN_SEMA_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICSEMA_H diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 586f65e9201c..5feb877e46c5 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -192,10 +192,6 @@ def ext_flexible_array_init : Extension< "flexible array initialization is a GNU extension">, InGroup<GNUFlexibleArrayInitializer>; // Declarations. -def ext_duplicate_declspec : ExtWarn<"duplicate '%0' declaration specifier">, - InGroup<DuplicateDeclSpecifier>; -def warn_duplicate_declspec : Warning<"duplicate '%0' declaration specifier">, - InGroup<DuplicateDeclSpecifier>; def ext_plain_complex : ExtWarn< "plain '_Complex' requires a type specifier; assuming '_Complex double'">; def ext_imaginary_constant : Extension< @@ -209,7 +205,6 @@ def err_invalid_sign_spec : Error<"'%0' cannot be signed or unsigned">; def err_invalid_width_spec : Error< "'%select{|short|long|long long}0 %1' is invalid">; def err_invalid_complex_spec : Error<"'_Complex %0' is invalid">; -def err_friend_decl_spec : Error<"'%0' is invalid in friend declarations">; def ext_auto_type_specifier : ExtWarn< "'auto' type specifier is a C++11 extension">, InGroup<CXX11>; @@ -250,9 +245,6 @@ def err_invalid_vector_long_double_decl_spec : Error< def warn_vector_long_decl_spec_combination : Warning< "Use of 'long' with '__vector' is deprecated">, InGroup<Deprecated>; -def err_use_of_tag_name_without_tag : Error< - "must use '%1' tag to refer to type %0%select{| in this scope}2">; - def err_redeclaration_different_type : Error< "redeclaration of %0 with a different type%diff{: $ vs $|}1,2">; def err_bad_variable_name : Error< @@ -369,7 +361,7 @@ def warn_implicit_function_decl : Warning< "implicit declaration of function %0">, InGroup<ImplicitFunctionDeclare>, DefaultIgnore; def ext_implicit_function_decl : ExtWarn< - "implicit declaration of function %0 is invalid in %select{C99|OpenCL}1">, + "implicit declaration of function %0 is invalid in C99">, InGroup<ImplicitFunctionDeclare>; def note_function_suggestion : Note<"did you mean %0?">; @@ -452,10 +444,12 @@ def err_decomp_decl_multiple_bases_with_members : Error< "have non-static data members">; def err_decomp_decl_ambiguous_base : Error< "cannot decompose members of ambiguous base class %1 of %0:%2">; -def err_decomp_decl_non_public_base : Error< - "cannot decompose members of non-public base class %1 of %0">; -def err_decomp_decl_non_public_member : Error< - "cannot decompose non-public member %0 of %1">; +def err_decomp_decl_inaccessible_base : Error< + "cannot decompose members of inaccessible base class %1 of %0">, + AccessControl; +def err_decomp_decl_inaccessible_field : Error< + "cannot decompose %select{private|protected}0 member %1 of %3">, + AccessControl; def err_decomp_decl_anon_union_member : Error< "cannot decompose class type %0 because it has an anonymous " "%select{struct|union}1 member">; @@ -526,13 +520,6 @@ def warn_access_decl_deprecated : Warning< def err_access_decl : Error< "ISO C++11 does not allow access declarations; " "use using declarations instead">; -def ext_dynamic_exception_spec : ExtWarn< - "ISO C++17 does not allow dynamic exception specifications">, - InGroup<DynamicExceptionSpec>, DefaultError; -def warn_exception_spec_deprecated : Warning< - "dynamic exception specifications are deprecated">, - InGroup<DeprecatedDynamicExceptionSpec>, DefaultIgnore; -def note_exception_spec_deprecated : Note<"use '%0' instead">; def warn_deprecated_copy_operation : Warning< "definition of implicit copy %select{constructor|assignment operator}1 " "for %0 is deprecated because it has a user-declared " @@ -618,11 +605,6 @@ def err_invalid_cpu_supports : Error<"invalid cpu feature string for builtin">; def err_invalid_cpu_is : Error<"invalid cpu name for builtin">; def err_invalid_cpu_specific_dispatch_value : Error< "invalid option '%0' for %select{cpu_specific|cpu_dispatch}1">; -def err_builtin_needs_feature : Error<"%0 needs target feature %1">; -def err_function_needs_feature - : Error<"always_inline function %1 requires target feature '%2', but would " - "be inlined into function %0 that is compiled without support for " - "'%2'">; def warn_builtin_unknown : Warning<"use of unknown builtin %0">, InGroup<ImplicitFunctionDeclare>, DefaultError; def warn_cstruct_memaccess : Warning< @@ -694,7 +676,8 @@ def warn_assume_side_effects : Warning< InGroup<DiagGroup<"assume">>; def warn_memcpy_chk_overflow : Warning< - "%0 will always overflow destination buffer">, + "'%0' will always overflow; destination buffer has size %1," + " but size argument is %2">, InGroup<DiagGroup<"builtin-memcpy-chk-size">>; /// main() @@ -773,7 +756,7 @@ def warn_pragma_pack_non_default_at_include : Warning< "members in the included file">, InGroup<PragmaPackSuspiciousInclude>, DefaultIgnore; def warn_pragma_pack_modified_after_include : Warning< - "the current #pragma pack aligment value is modified in the included " + "the current #pragma pack alignment value is modified in the included " "file">, InGroup<PragmaPack>; def warn_pragma_pack_no_pop_eof : Warning<"unterminated " "'#pragma pack (push, ...)' at end of file">, InGroup<PragmaPack>; @@ -791,10 +774,6 @@ def warn_cxx_ms_struct : Warning<"ms_struct may not produce Microsoft-compatible layouts for classes " "with base classes or virtual functions">, DefaultError, InGroup<IncompatibleMSStruct>; -def warn_npot_ms_struct : - Warning<"ms_struct may not produce Microsoft-compatible layouts with fundamental " - "data types with sizes that aren't a power of two">, - DefaultError, InGroup<IncompatibleMSStruct>; def err_section_conflict : Error<"%0 causes a section type conflict with %1">; def err_no_base_classes : Error<"invalid use of '__super', %0 has no base classes">; def err_invalid_super_scope : Error<"invalid use of '__super', " @@ -836,7 +815,8 @@ def err_pragma_attribute_matcher_negated_subrule_contradicts_subrule : Error< def err_pragma_attribute_invalid_matchers : Error< "attribute %0 can't be applied to %1">; def err_pragma_attribute_stack_mismatch : Error< - "'#pragma clang attribute pop' with no matching '#pragma clang attribute push'">; + "'#pragma clang attribute %select{%1.|}0pop' with no matching" + " '#pragma clang attribute %select{%1.|}0push'">; def warn_pragma_attribute_unused : Warning< "unused attribute %0 in '#pragma clang attribute push' region">, InGroup<PragmaClangAttribute>; @@ -846,6 +826,9 @@ def err_pragma_attribute_no_pop_eof : Error<"unterminated " "'#pragma clang attribute push' at end of file">; def note_pragma_attribute_applied_decl_here : Note< "when applied to this declaration">; +def err_pragma_attr_attr_no_push : Error< + "'#pragma clang attribute' attribute with no matching " + "'#pragma clang attribute push'">; /// Objective-C parser diagnostics def err_duplicate_class_def : Error< @@ -867,8 +850,8 @@ def err_protocol_has_circular_dependency : Error< "protocol has circular dependency">; def err_undeclared_protocol : Error<"cannot find protocol declaration for %0">; def warn_undef_protocolref : Warning<"cannot find protocol definition for %0">; -def warn_atprotocol_protocol : Warning< - "@protocol is using a forward protocol declaration of %0">, InGroup<AtProtocol>; +def err_atprotocol_protocol : Error< + "@protocol is using a forward protocol declaration of %0">; def warn_readonly_property : Warning< "attribute 'readonly' of property %0 restricts attribute " "'readwrite' of property inherited from %1">, @@ -920,8 +903,6 @@ def err_objc_runtime_visible_subclass : Error< "Objective-C runtime">; def note_objc_needs_superclass : Note< "add a super class to fix this problem">; -def warn_dup_category_def : Warning< - "duplicate definition of category %1 on interface %0">; def err_conflicting_super_class : Error<"conflicting super class name %0">; def err_dup_implementation_class : Error<"reimplementation of class %0">; def err_dup_implementation_category : Error< @@ -1046,6 +1027,9 @@ def err_objc_property_attr_mutually_exclusive : Error< "property attributes '%0' and '%1' are mutually exclusive">; def err_objc_property_requires_object : Error< "property with '%0' attribute must be of object type">; +def warn_objc_property_assign_on_object : Warning< + "'assign' property of object type may become a dangling reference; consider using 'unsafe_unretained'">, + InGroup<ObjCPropertyAssignOnObjectType>, DefaultIgnore; def warn_objc_property_no_assignment_attribute : Warning< "no 'assign', 'retain', or 'copy' attribute is specified - " "'assign' is assumed">, @@ -1278,11 +1262,6 @@ def err_static_assert_expression_is_not_constant : Error< def err_static_assert_failed : Error<"static_assert failed%select{ %1|}0">; def err_static_assert_requirement_failed : Error< "static_assert failed due to requirement '%0'%select{ %2|}1">; -def ext_static_assert_no_message : ExtWarn< - "static_assert with no message is a C++17 extension">, InGroup<CXX17>; -def warn_cxx14_compat_static_assert_no_message : Warning< - "static_assert with no message is incompatible with C++ standards before C++17">, - DefaultIgnore, InGroup<CXXPre17Compat>; def ext_inline_variable : ExtWarn< "inline variables are a C++17 extension">, InGroup<CXX17>; @@ -1319,8 +1298,8 @@ def ext_unelaborated_friend_type : ExtWarn< def warn_cxx98_compat_unelaborated_friend_type : Warning< "befriending %1 without '%select{struct|interface|union|class|enum}0' " "keyword is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; -def err_qualified_friend_not_found : Error< - "no function named %0 with type %1 was found in the specified scope">; +def err_qualified_friend_no_match : Error< + "friend declaration of %0 does not match any declaration in %1">; def err_introducing_special_friend : Error< "%plural{[0,2]:must use a qualified name when declaring|3:cannot declare}0" " a %select{constructor|destructor|conversion operator|deduction guide}0 " @@ -1355,10 +1334,6 @@ def ext_friend_tag_redecl_outside_namespace : ExtWarn< InGroup<MicrosoftUnqualifiedFriend>; def err_pure_friend : Error<"friend declaration cannot have a pure-specifier">; -def err_invalid_member_in_interface : Error< - "%select{data member |non-public member function |static member function |" - "user-declared constructor|user-declared destructor|operator |" - "nested class }0%1 is not permitted within an interface type">; def err_invalid_base_in_interface : Error< "interface type cannot inherit from " "%select{struct|non-public interface|class}0 %1">; @@ -1464,6 +1439,10 @@ def err_noexcept_needs_constant_expression : Error< "argument to noexcept specifier must be a constant expression">; def err_exception_spec_not_parsed : Error< "exception specification is not available until end of class definition">; +def err_exception_spec_cycle : Error< + "exception specification of %0 uses itself">; +def err_exception_spec_incomplete_type : Error< + "exception specification needed for member of incomplete class %0">; // C++ access checking def err_class_redeclared_with_different_access : Error< @@ -1644,7 +1623,7 @@ def err_member_function_call_bad_type : Error< def warn_call_to_pure_virtual_member_function_from_ctor_dtor : Warning< "call to pure virtual member function %0 has undefined behavior; " "overrides of %0 in subclasses are not available in the " - "%select{constructor|destructor}1 of %2">; + "%select{constructor|destructor}1 of %2">, InGroup<PureVirtualCallFromCtorDtor>; def select_special_member_kind : TextSubstitution< "%select{default constructor|copy constructor|move constructor|" @@ -1809,6 +1788,10 @@ def err_destructor_expr_type_mismatch : Error< def note_destructor_type_here : Note< "type %0 is declared here">; +def err_destroy_attr_on_non_static_var : Error< + "%select{no_destroy|always_destroy}0 attribute can only be applied to a" + " variable with static or thread storage duration">; + def err_destructor_template : Error< "destructor cannot be declared as a template">; @@ -1826,11 +1809,7 @@ def err_init_conversion_failed : Error< "|: different number of parameters (%5 vs %6)" "|: type mismatch at %ordinal5 parameter%diff{ ($ vs $)|}6,7" "|: different return type%diff{ ($ vs $)|}5,6" - "|: different qualifiers (" - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}5 vs " - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}6)" + "|: different qualifiers (%5 vs %6)" "|: different exception specifications}4">; def err_lvalue_to_rvalue_ref : Error<"rvalue reference %diff{to type $ cannot " @@ -1858,6 +1837,9 @@ def err_reference_bind_init_list : Error< def err_init_list_bad_dest_type : Error< "%select{|non-aggregate }0type %1 cannot be initialized with an initializer " "list">; +def warn_cxx2a_compat_aggregate_init_with_ctors : Warning< + "aggregate initialization of type %0 with user-declared constructors " + "is incompatible with C++2a">, DefaultIgnore, InGroup<CXX2aCompat>; def err_reference_bind_to_bitfield : Error< "%select{non-const|volatile}0 reference cannot bind to " @@ -2139,8 +2121,12 @@ def note_deduction_guide_template_access : Note< "member template declared %0 here">; def note_deduction_guide_access : Note< "deduction guide declared %0 by intervening access specifier">; +def warn_cxx14_compat_class_template_argument_deduction : Warning< + "class template argument deduction is incompatible with C++ standards " + "before C++17%select{|; for compatibility, use explicit type name %1}0">, + InGroup<CXXPre17Compat>, DefaultIgnore; -// C++1y deduced return types +// C++14 deduced return types def err_auto_fn_deduction_failure : Error< "cannot deduce return type %0 from returned value of type %1">; def err_auto_fn_different_deductions : Error< @@ -2156,6 +2142,9 @@ def err_auto_fn_return_init_list : Error< "cannot deduce return type from initializer list">; def err_auto_fn_virtual : Error< "function with deduced return type cannot be virtual">; +def warn_cxx11_compat_deduced_return_type : Warning< + "return type deduction is incompatible with C++ standards before C++14">, + InGroup<CXXPre14Compat>, DefaultIgnore; // C++11 override control def override_keyword_only_allowed_on_virtual_member_functions : Error< @@ -2235,8 +2224,6 @@ def err_for_range_incomplete_type : Error< "cannot use incomplete type %0 as a range">; def err_for_range_iter_deduction_failure : Error< "cannot use type %0 as an iterator">; -def err_for_range_member_begin_end_mismatch : Error< - "range type %0 has '%select{begin|end}1' member but no '%select{end|begin}1' member">; def ext_for_range_begin_end_types_differ : ExtWarn< "'begin' and 'end' returning different types (%0 and %1) is a C++17 extension">, InGroup<CXX17>; @@ -2249,6 +2236,8 @@ def note_in_for_range: Note< def err_for_range_invalid: Error< "invalid range expression of type %0; no viable '%select{begin|end}1' " "function available">; +def note_for_range_member_begin_end_ignored : Note< + "member is not a candidate because range type %0 has no '%select{end|begin}1' member">; def err_range_on_array_parameter : Error< "cannot build range expression with array function parameter %0 since " "parameter with array type %1 is treated as pointer type %2">; @@ -2275,6 +2264,9 @@ def warn_for_range_copy : Warning< "loop variable %0 of type %1 creates a copy from type %2">, InGroup<RangeLoopAnalysis>, DefaultIgnore; def note_use_reference_type : Note<"use reference type %0 to prevent copying">; +def err_objc_for_range_init_stmt : Error< + "initialization statement is not supported when iterating over Objective-C " + "collection">; // C++11 constexpr def warn_cxx98_compat_constexpr : Warning< @@ -2330,6 +2322,13 @@ def warn_cxx11_compat_constexpr_body_invalid_stmt : Warning< "use of this statement in a constexpr %select{function|constructor}0 " "is incompatible with C++ standards before C++14">, InGroup<CXXPre14Compat>, DefaultIgnore; +def ext_constexpr_body_invalid_stmt_cxx2a : ExtWarn< + "use of this statement in a constexpr %select{function|constructor}0 " + "is a C++2a extension">, InGroup<CXX2a>; +def warn_cxx17_compat_constexpr_body_invalid_stmt : Warning< + "use of this statement in a constexpr %select{function|constructor}0 " + "is incompatible with C++ standards before C++2a">, + InGroup<CXXPre2aCompat>, DefaultIgnore; def ext_constexpr_type_definition : ExtWarn< "type definition in a constexpr %select{function|constructor}0 " "is a C++14 extension">, InGroup<CXX14>; @@ -2382,6 +2381,16 @@ def note_constexpr_body_previous_return : Note< "previous return statement is here">; def err_constexpr_function_try_block : Error< "function try block not allowed in constexpr %select{function|constructor}0">; + +// c++2a function try blocks in constexpr +def ext_constexpr_function_try_block_cxx2a : ExtWarn< + "function try block in constexpr %select{function|constructor}0 is " + "a C++2a extension">, InGroup<CXX2a>; +def warn_cxx17_compat_constexpr_function_try_block : Warning< + "function try block in constexpr %select{function|constructor}0 is " + "incompatible with C++ standards before C++2a">, + InGroup<CXXPre2aCompat>, DefaultIgnore; + def err_constexpr_union_ctor_no_init : Error< "constexpr union constructor does not initialize any member">; def err_constexpr_ctor_missing_init : Error< @@ -2479,7 +2488,8 @@ def err_attribute_invalid_vector_type : Error<"invalid vector element type %0">; def err_attribute_bad_neon_vector_size : Error< "Neon vector size must be 64 or 128 bits">; def err_attribute_requires_positive_integer : Error< - "%0 attribute requires a positive integral compile time constant expression">; + "%0 attribute requires a %select{positive|non-negative}1 " + "integral compile time constant expression">; def err_attribute_requires_opencl_version : Error< "%0 attribute requires OpenCL version %1%select{| or above}2">; def warn_unsupported_target_attribute @@ -2521,8 +2531,6 @@ def err_attribute_argument_out_of_bounds : Error< "%0 attribute parameter %1 is out of bounds">; def err_attribute_only_once_per_parameter : Error< "%0 attribute can only be applied once per parameter">; -def err_attribute_uuid_malformed_guid : Error< - "uuid attribute contains a malformed GUID">; def err_mismatched_uuid : Error<"uuid does not match previous declaration">; def note_previous_uuid : Note<"previous uuid specified here">; def warn_attribute_pointers_only : Warning< @@ -2599,6 +2607,10 @@ def err_arg_with_address_space : Error< "parameter may not be qualified with an address space">; def err_field_with_address_space : Error< "field may not be qualified with an address space">; +def err_compound_literal_with_address_space : Error< + "compound literal in function scope may not be qualified with an address space">; +def err_address_space_mismatch_templ_inst : Error< + "conflicting address space qualifiers are provided between types %0 and %1">; def err_attr_objc_ownership_redundant : Error< "the type %0 is already explicitly ownership-qualified">; def err_invalid_nsnumber_type : Error< @@ -2742,8 +2754,6 @@ def warn_nocf_check_attribute_ignored : def warn_attribute_after_definition_ignored : Warning< "attribute %0 after definition is ignored">, InGroup<IgnoredAttributes>; -def warn_unknown_attribute_ignored : Warning< - "unknown attribute %0 ignored">, InGroup<UnknownAttributes>; def warn_cxx11_gnu_attribute_on_type : Warning< "attribute %0 ignored, because it cannot be applied to a type">, InGroup<IgnoredAttributes>; @@ -2843,22 +2853,6 @@ def err_attribute_weakref_without_alias : Error< "weakref declaration of %0 must also have an alias attribute">; def err_alias_not_supported_on_darwin : Error < "aliases are not supported on darwin">; -def err_alias_to_undefined : Error< - "%select{alias|ifunc}0 must point to a defined %select{variable or |}1function">; -def warn_alias_to_weak_alias : Warning< - "%select{alias|ifunc}2 will always resolve to %0 even if weak definition of %1 is overridden">, - InGroup<IgnoredAttributes>; -def warn_alias_with_section : Warning< - "%select{alias|ifunc}1 will not be in section '%0' but in the same section as the %select{aliasee|resolver}2">, - InGroup<IgnoredAttributes>; -def err_duplicate_mangled_name : Error< - "definition with same mangled name '%0' as another definition">; -def err_cyclic_alias : Error< - "%select{alias|ifunc}0 definition is part of a cycle">; -def err_ifunc_resolver_return : Error< - "ifunc resolver function must return a pointer">; -def err_ifunc_resolver_params : Error< - "ifunc resolver function must have no parameters">; def warn_attribute_wrong_decl_type_str : Warning< "%0 attribute only applies to %1">, InGroup<IgnoredAttributes>; def err_attribute_wrong_decl_type_str : Error< @@ -2960,6 +2954,9 @@ def warn_availability_on_static_initializer : Warning< InGroup<Availability>; def note_overridden_method : Note< "overridden method is here">; +def warn_availability_swift_unavailable_deprecated_only : Warning< + "only 'unavailable' and 'deprecated' are supported for Swift availability">, + InGroup<Availability>; def note_protocol_method : Note< "protocol method is here">; @@ -2986,6 +2983,14 @@ def warn_invalid_capability_name : Warning< def warn_thread_attribute_ignored : Warning< "ignoring %0 attribute because its argument is invalid">, InGroup<ThreadSafetyAttributes>, DefaultIgnore; +def warn_thread_attribute_not_on_non_static_member : Warning< + "%0 attribute without capability arguments can only be applied to non-static " + "methods of a class">, + InGroup<ThreadSafetyAttributes>, DefaultIgnore; +def warn_thread_attribute_not_on_capability_member : Warning< + "%0 attribute without capability arguments refers to 'this', but %1 isn't " + "annotated with 'capability' or 'scoped_lockable' attribute">, + InGroup<ThreadSafetyAttributes>, DefaultIgnore; def warn_thread_attribute_argument_not_lockable : Warning< "%0 attribute requires arguments whose type is annotated " "with 'capability' attribute; type here is %1">, @@ -3143,10 +3148,10 @@ def err_impcast_complex_scalar : Error< "implicit conversion from %0 to %1 is not permitted in C++">; def warn_impcast_float_precision : Warning< "implicit conversion loses floating-point precision: %0 to %1">, - InGroup<Conversion>, DefaultIgnore; + InGroup<ImplicitFloatConversion>, DefaultIgnore; def warn_impcast_float_result_precision : Warning< "implicit conversion when assigning computation result loses floating-point precision: %0 to %1">, - InGroup<Conversion>, DefaultIgnore; + InGroup<ImplicitFloatConversion>, DefaultIgnore; def warn_impcast_double_promotion : Warning< "implicit conversion increases floating-point precision: %0 to %1">, InGroup<DoublePromotion>, DefaultIgnore; @@ -3158,7 +3163,13 @@ def warn_impcast_integer_sign_conditional : Warning< InGroup<SignConversion>, DefaultIgnore; def warn_impcast_integer_precision : Warning< "implicit conversion loses integer precision: %0 to %1">, - InGroup<Conversion>, DefaultIgnore; + InGroup<ImplicitIntConversion>, DefaultIgnore; +def warn_impcast_high_order_zero_bits : Warning< + "higher order bits are zeroes after implicit conversion">, + InGroup<ImplicitIntConversion>, DefaultIgnore; +def warn_impcast_nonnegative_result : Warning< + "the resulting value is always non-negative after implicit conversion">, + InGroup<SignConversion>, DefaultIgnore; def warn_impcast_integer_64_32 : Warning< "implicit conversion loses integer precision: %0 to %1">, InGroup<Shorten64To32>, DefaultIgnore; @@ -3247,6 +3258,10 @@ def warn_address_of_reference_null_compare : Warning< InGroup<TautologicalUndefinedCompare>; def note_reference_is_return_value : Note<"%0 returns a reference">; +def warn_division_sizeof_ptr : Warning< + "'%0' will return the size of the pointer, not the array itself">, + InGroup<DiagGroup<"sizeof-pointer-div">>; + def note_function_warning_silence : Note< "prefix with the address-of operator to silence this warning">; def note_function_to_function_call : Note< @@ -3410,7 +3425,7 @@ def err_ns_attribute_wrong_parameter_type : Error< "%select{Objective-C object|pointer|pointer-to-CF-pointer}1 parameters">; def warn_ns_attribute_wrong_parameter_type : Warning< "%0 attribute only applies to " - "%select{Objective-C object|pointer|pointer-to-CF-pointer}1 parameters">, + "%select{Objective-C object|pointer|pointer-to-CF-pointer|pointer/reference-to-OSObject-pointer}1 parameters">, InGroup<IgnoredAttributes>; def warn_objc_requires_super_protocol : Warning< "%0 attribute cannot be applied to %select{methods in protocols|dealloc}1">, @@ -3470,6 +3485,11 @@ def err_objc_bridged_related_known_method : Error< def err_objc_attr_protocol_requires_definition : Error< "attribute %0 can only be applied to @protocol definitions, not forward declarations">; +def warn_ignored_objc_externally_retained : Warning< + "'objc_externally_retained' can only be applied to local variables " + "%select{of retainable type|with strong ownership}0">, + InGroup<IgnoredAttributes>; + // Function Parameter Semantic Analysis. def err_param_with_void_type : Error<"argument may not have 'void' type">; def err_void_only_param : Error< @@ -3574,11 +3594,7 @@ def note_ovl_candidate : Note< "| has type mismatch at %ordinal5 parameter" "%diff{ (expected $ but has $)|}6,7" "| has different return type%diff{ ($ expected but has $)|}5,6" - "| has different qualifiers (expected " - "%select{none|const|restrict|const and restrict|volatile|const and volatile" - "|volatile and restrict|const, volatile, and restrict}5 but found " - "%select{none|const|restrict|const and restrict|volatile|const and volatile" - "|volatile and restrict|const, volatile, and restrict}6)" + "| has different qualifiers (expected %5 but found %6)" "| has different exception specification}4">; def note_ovl_candidate_inherited_constructor : Note< @@ -3630,7 +3646,7 @@ def warn_diagnose_if_succeeded : Warning<"%0">, InGroup<UserDefinedWarnings>, def note_ovl_candidate_disabled_by_function_cond_attr : Note< "candidate disabled: %0">; def note_ovl_candidate_disabled_by_extension : Note< - "candidate disabled due to OpenCL extension">; + "candidate unavailable as it requires OpenCL extension '%0' to be enabled">; def err_addrof_function_disabled_by_enable_if_attr : Error< "cannot take address of function %0 because it has one or more " "non-tautological enable_if conditions">; @@ -4255,6 +4271,8 @@ def note_forward_template_decl : Note< def note_inst_declaration_hint : Note<"add an explicit instantiation " "declaration to suppress this warning if %q0 is explicitly instantiated in " "another translation unit">; +def note_evaluating_exception_spec_here : Note< + "in evaluation of exception specification for %q0 needed here">; def note_default_arg_instantiation_here : Note< "in instantiation of default argument for '%0' required here">; @@ -4547,7 +4565,10 @@ def warn_unavailable_fwdclass_message : Warning< InGroup<UnavailableDeclarations>; def note_availability_specified_here : Note< "%0 has been explicitly marked " - "%select{unavailable|deleted|deprecated|partial}1 here">; + "%select{unavailable|deleted|deprecated}1 here">; +def note_partial_availability_specified_here : Note< + "%0 has been marked as being introduced in %1 %2 here, " + "but the deployment target is %1 %3">; def note_implicitly_deleted : Note< "explicitly defaulted function was implicitly deleted here">; def warn_not_enough_argument : Warning< @@ -4750,16 +4771,18 @@ def err_nested_redefinition : Error<"nested redefinition of %0">; def err_use_with_wrong_tag : Error< "use of %0 with tag type that does not match previous declaration">; def warn_struct_class_tag_mismatch : Warning< - "%select{struct|interface|class}0%select{| template}1 %2 was previously " - "declared as a %select{struct|interface|class}3%select{| template}1">, - InGroup<MismatchedTags>, DefaultIgnore; + "%select{struct|interface|class}0%select{| template}1 %2 was previously " + "declared as a %select{struct|interface|class}3%select{| template}1; " + "this is valid, but may result in linker errors under the Microsoft C++ ABI">, + InGroup<MismatchedTags>, DefaultIgnore; def warn_struct_class_previous_tag_mismatch : Warning< - "%2 defined as %select{a struct|an interface|a class}0%select{| template}1 " - "here but previously declared as " - "%select{a struct|an interface|a class}3%select{| template}1">, - InGroup<MismatchedTags>, DefaultIgnore; + "%2 defined as %select{a struct|an interface|a class}0%select{| template}1 " + "here but previously declared as " + "%select{a struct|an interface|a class}3%select{| template}1; " + "this is valid, but may result in linker errors under the Microsoft C++ ABI">, + InGroup<MismatchedTags>, DefaultIgnore; def note_struct_class_suggestion : Note< - "did you mean %select{struct|interface|class}0 here?">; + "did you mean %select{struct|interface|class}0 here?">; def ext_forward_ref_enum : Extension< "ISO C forbids forward references to 'enum' types">; def err_forward_ref_enum : Error< @@ -4804,21 +4827,6 @@ def err_vm_func_decl : Error< def err_array_too_large : Error< "array is too large (%0 elements)">; -// -Wpadded, -Wpacked -def warn_padded_struct_field : Warning< - "padding %select{struct|interface|class}0 %1 with %2 " - "%select{byte|bit}3%s2 to align %4">, - InGroup<Padded>, DefaultIgnore; -def warn_padded_struct_anon_field : Warning< - "padding %select{struct|interface|class}0 %1 with %2 " - "%select{byte|bit}3%s2 to align anonymous bit-field">, - InGroup<Padded>, DefaultIgnore; -def warn_padded_struct_size : Warning< - "padding size of %0 with %1 %select{byte|bit}2%s1 to alignment boundary">, - InGroup<Padded>, DefaultIgnore; -def warn_unnecessary_packed : Warning< - "packed attribute is unnecessary for %0">, InGroup<Packed>, DefaultIgnore; - def err_typecheck_negative_array_size : Error<"array size is negative">; def warn_typecheck_function_qualifiers_ignored : Warning< "'%0' qualifier on function type %1 has no effect">, @@ -4873,7 +4881,7 @@ def warn_braces_around_scalar_init : Warning< "braces around scalar initializer">, InGroup<DiagGroup<"braced-scalar-init">>; def ext_many_braces_around_scalar_init : ExtWarn< "too many braces around scalar initializer">, - InGroup<DiagGroup<"many-braces-around-scalar-init">>; + InGroup<DiagGroup<"many-braces-around-scalar-init">>, SFINAEFailure; def ext_complex_component_init : Extension< "complex initialization specifying real and imaginary components " "is an extension">, InGroup<DiagGroup<"complex-component-init">>; @@ -5254,6 +5262,9 @@ def err_typecheck_arc_assign_self_class_method : Error< def err_typecheck_arr_assign_enumeration : Error< "fast enumeration variables cannot be modified in ARC by default; " "declare the variable __strong to allow this">; +def err_typecheck_arc_assign_externally_retained : Error< + "variable declared with 'objc_externally_retained' " + "cannot be modified in ARC">; def warn_arc_retained_assign : Warning< "assigning retained object to %select{weak|unsafe_unretained}0 " "%select{property|variable}1" @@ -5428,20 +5439,24 @@ def err_atomic_specifier_bad_type : Error< "%1 %select{||||||which is not trivially copyable}0">; // Expressions. +def select_unary_expr_or_type_trait_kind : TextSubstitution< + "%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align|" + "__alignof}0">; def ext_sizeof_alignof_function_type : Extension< - "invalid application of '%select{sizeof|alignof|vec_step}0' to a " - "function type">, InGroup<PointerArith>; + "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' " + "to a function type">, InGroup<PointerArith>; def ext_sizeof_alignof_void_type : Extension< - "invalid application of '%select{sizeof|alignof|vec_step}0' to a void " - "type">, InGroup<PointerArith>; + "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' " + "to a void type">, InGroup<PointerArith>; def err_opencl_sizeof_alignof_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to a void type">; + "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' " + "to a void type">; def err_sizeof_alignof_incomplete_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to an " - "incomplete type %1">; + "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' " + "to an incomplete type %1">; def err_sizeof_alignof_function_type : Error< - "invalid application of '%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align}0' to a " - "function type">; + "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' " + "to a function type">; def err_openmp_default_simd_align_expr : Error< "invalid application of '__builtin_omp_required_simd_align' to an expression, only type is allowed">; def err_sizeof_alignof_typeof_bitfield : Error< @@ -5749,8 +5764,14 @@ def err_array_init_plain_string_into_char8_t : Error< def note_array_init_plain_string_into_char8_t : Note< "add 'u8' prefix to form a 'char8_t' string literal">; def err_array_init_utf8_string_into_char : Error< - "initialization of char array with UTF-8 string literal is not permitted " - "by '-fchar8_t'">; + "%select{|ISO C++20 does not permit }0initialization of char array with " + "UTF-8 string literal%select{ is not permitted by '-fchar8_t'|}0">; +def warn_cxx2a_compat_utf8_string : Warning< + "type of UTF-8 string literal will change from array of const char to " + "array of const char8_t in C++2a">, InGroup<CXX2aCompat>, DefaultIgnore; +def note_cxx2a_compat_utf8_string_remove_u8 : Note< + "remove 'u8' prefix to avoid a change of behavior; " + "Clang encodes unprefixed narrow string literals as UTF-8">; def err_array_init_different_type : Error< "cannot initialize array %diff{of type $ with array of type $|" "with different type of array}0,1">; @@ -5857,7 +5878,8 @@ def ext_typecheck_comparison_of_fptr_to_void : Extension< def err_typecheck_comparison_of_fptr_to_void : Error< "equality comparison between function pointer and void pointer (%0 and %1)">; def ext_typecheck_comparison_of_pointer_integer : ExtWarn< - "comparison between pointer and integer (%0 and %1)">; + "comparison between pointer and integer (%0 and %1)">, + InGroup<DiagGroup<"pointer-integer-compare">>; def err_typecheck_comparison_of_pointer_integer : Error< "comparison between pointer and integer (%0 and %1)">; def ext_typecheck_comparison_of_distinct_pointers : ExtWarn< @@ -6437,12 +6459,12 @@ def warn_non_virtual_dtor : Warning< def warn_delete_non_virtual_dtor : Warning< "%select{delete|destructor}0 called on non-final %1 that has " "virtual functions but non-virtual destructor">, - InGroup<DeleteNonVirtualDtor>, DefaultIgnore, ShowInSystemHeader; + InGroup<DeleteNonAbstractNonVirtualDtor>, DefaultIgnore, ShowInSystemHeader; def note_delete_non_virtual : Note< "qualify call to silence this warning">; def warn_delete_abstract_non_virtual_dtor : Warning< "%select{delete|destructor}0 called on %1 that is abstract but has " - "non-virtual destructor">, InGroup<DeleteNonVirtualDtor>, ShowInSystemHeader; + "non-virtual destructor">, InGroup<DeleteAbstractNonVirtualDtor>, ShowInSystemHeader; def warn_overloaded_virtual : Warning< "%q0 hides overloaded virtual %select{function|functions}1">, InGroup<OverloadedVirtual>, DefaultIgnore; @@ -6452,11 +6474,7 @@ def note_hidden_overloaded_virtual_declared_here : Note< "|: different number of parameters (%2 vs %3)" "|: type mismatch at %ordinal2 parameter%diff{ ($ vs $)|}3,4" "|: different return type%diff{ ($ vs $)|}2,3" - "|: different qualifiers (" - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}2 vs " - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}3)" + "|: different qualifiers (%2 vs %3)" "|: different exception specifications}1">; def warn_using_directive_in_header : Warning< "using namespace directive in global context in header">, @@ -6465,12 +6483,12 @@ def warn_overaligned_type : Warning< "type %0 requires %1 bytes of alignment and the default allocator only " "guarantees %2 bytes">, InGroup<OveralignedType>, DefaultIgnore; -def warn_aligned_allocation_unavailable :Warning< +def err_aligned_allocation_unavailable : Error< "aligned %select{allocation|deallocation}0 function of type '%1' is only " - "available on %2 %3 or newer">, InGroup<AlignedAllocationUnavailable>, DefaultError; -def note_silence_unligned_allocation_unavailable : Note< + "available on %2 %3 or newer">; +def note_silence_aligned_allocation_unavailable : Note< "if you supply your own aligned allocation functions, use " - "-Wno-aligned-allocation-unavailable to silence this diagnostic">; + "-faligned-allocation to silence this diagnostic">; def err_conditional_void_nonvoid : Error< "%select{left|right}1 operand to ? is void, but %select{right|left}1 operand " @@ -6572,6 +6590,11 @@ let CategoryName = "Lambda Issue" in { def err_init_capture_deduction_failure_from_init_list : Error< "cannot deduce type for lambda capture %0 from initializer list">; + // C++14 generic lambdas. + def warn_cxx11_compat_generic_lambda : Warning< + "generic lambdas are incompatible with C++11">, + InGroup<CXXPre14Compat>, DefaultIgnore; + // C++17 '*this' captures. def warn_cxx14_compat_star_this_lambda_capture : Warning< "by value capture of '*this' is incompatible with C++ standards before C++17">, @@ -6579,6 +6602,10 @@ let CategoryName = "Lambda Issue" in { def ext_star_this_lambda_capture_cxx17 : ExtWarn< "capture of '*this' by copy is a C++17 extension">, InGroup<CXX17>; + // C++17 parameter shadows capture + def err_parameter_shadow_capture : Error< + "a lambda parameter cannot shadow an explicitly captured entity">; + // C++2a [=, this] captures. def warn_cxx17_compat_equals_this_lambda_capture : Warning< "explicit capture of 'this' with a capture default of '=' is incompatible " @@ -6591,6 +6618,11 @@ let CategoryName = "Lambda Issue" in { InGroup<DeprecatedThisCapture>, DefaultIgnore; def note_deprecated_this_capture : Note< "add an explicit capture of 'this' to capture '*this' by reference">; + + // C++2a default constructible / assignable lambdas. + def warn_cxx17_compat_lambda_def_ctor_assign : Warning< + "%select{default construction|assignment}0 of lambda is incompatible with " + "C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore; } def err_return_in_captured_stmt : Error< @@ -6716,11 +6748,7 @@ def err_typecheck_convert_incompatible : Error< "|: different number of parameters (%5 vs %6)" "|: type mismatch at %ordinal5 parameter%diff{ ($ vs $)|}6,7" "|: different return type%diff{ ($ vs $)|}5,6" - "|: different qualifiers (" - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}5 vs " - "%select{none|const|restrict|const and restrict|volatile|const and volatile|" - "volatile and restrict|const, volatile, and restrict}6)" + "|: different qualifiers (%5 vs %6)" "|: different exception specifications}4">; def err_typecheck_missing_return_type_incompatible : Error< "%diff{return type $ must match previous return type $|" @@ -7063,9 +7091,9 @@ def warn_atomic_op_has_invalid_memory_order : Warning< InGroup<DiagGroup<"atomic-memory-ordering">>; def err_atomic_op_has_invalid_synch_scope : Error< "synchronization scope argument to atomic operation is invalid">; -def warn_atomic_op_misaligned : Warning< - "misaligned or large atomic operation may incur significant performance penalty">, - InGroup<DiagGroup<"atomic-alignment">>; +def warn_atomic_implicit_seq_cst : Warning< + "implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary">, + InGroup<DiagGroup<"atomic-implicit-seq-cst">>, DefaultIgnore; def err_overflow_builtin_must_be_int : Error< "operand argument to overflow builtin must be an integer (%0 invalid)">; @@ -7326,8 +7354,6 @@ let CategoryName = "Inline Assembly Issue" in { "invalid input constraint '%0' in asm">; def err_asm_immediate_expected : Error<"constraint '%0' expects " "an integer constant expression">; - def err_asm_invalid_type_in_input : Error< - "invalid type %0 in asm input for constraint '%1'">; def err_asm_tying_incompatible_types : Error< "unsupported inline asm: input with type " "%diff{$ matching output with type $|}0,1">; @@ -7451,8 +7477,6 @@ def note_in_class_initializer_not_yet_parsed : Note< "default member initializer declared here">; def err_in_class_initializer_cycle : Error<"default member initializer for %0 uses itself">; -def err_exception_spec_cycle - : Error<"exception specification of %0 uses itself">; def ext_in_class_initializer_non_constant : Extension< "in-class initializer for static data member is not a constant expression; " @@ -7712,9 +7736,19 @@ def err_incorrect_defaulted_exception_spec : Error< def err_incorrect_defaulted_constexpr : Error< "defaulted definition of %sub{select_special_member_kind}0 " "is not constexpr">; +def warn_defaulted_method_deleted : Warning< + "explicitly defaulted %sub{select_special_member_kind}0 is implicitly " + "deleted">, InGroup<DiagGroup<"defaulted-function-deleted">>; def err_out_of_line_default_deletes : Error< "defaulting this %sub{select_special_member_kind}0 " "would delete it after its first declaration">; +def note_deleted_type_mismatch : Note< + "function is implicitly deleted because its declared type does not match " + "the type of an implicit %sub{select_special_member_kind}0">; +def warn_cxx17_compat_defaulted_method_type_mismatch : Warning< + "explicitly defaulting this %sub{select_special_member_kind}0 with a type " + "different from the implicit type is incompatible with C++ standards before " + "C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore; def warn_vbase_moved_multiple_times : Warning< "defaulted move assignment operator of %0 will move assign virtual base " "class %1 multiple times">, InGroup<DiagGroup<"multiple-move-vbase">>; @@ -7820,6 +7854,8 @@ def warn_format_non_standard: Warning< def warn_format_non_standard_conversion_spec: Warning< "using length modifier '%0' with conversion specifier '%1' is not supported by ISO C">, InGroup<FormatNonStandard>, DefaultIgnore; +def err_invalid_mask_type_size : Error< + "mask type size must be between 1-byte and 8-bytes">; def warn_format_invalid_annotation : Warning< "using '%0' format specifier annotation outside of os_log()/os_trace()">, InGroup<Format>; @@ -8518,6 +8554,8 @@ def err_opencl_scalar_type_rank_greater_than_vector_type : Error< "element. (%0 and %1)">; def err_bad_kernel_param_type : Error< "%0 cannot be used as the type of a kernel parameter">; +def err_opencl_implicit_function_decl : Error< + "implicit declaration of function %0 is invalid in OpenCL">; def err_record_with_pointers_kernel_param : Error< "%select{struct|union}0 kernel parameters may not contain pointers">; def note_within_field_of_type : Note< @@ -8575,6 +8613,10 @@ def err_opencl_variadic_function : Error< "invalid prototype, variadic arguments are not allowed in OpenCL">; def err_opencl_requires_extension : Error< "use of %select{type|declaration}0 %1 requires %2 extension to be enabled">; +def warn_opencl_generic_address_space_arg : Warning< + "passing non-generic address space pointer to %0" + " may cause dynamic conversion affecting performance">, + InGroup<Conversion>, DefaultIgnore; // OpenCL v2.0 s6.13.6 -- Builtin Pipe Functions def err_opencl_builtin_pipe_first_arg : Error< @@ -8596,11 +8638,6 @@ def err_opencl_multiple_access_qualifiers : Error< def note_opencl_typedef_access_qualifier : Note< "previously declared '%0' here">; -// OpenCL Section 6.8.g -def err_opencl_unknown_type_specifier : Error< - "OpenCL %select{C|C++}0 version %1 does not support the '%2' " - "%select{type qualifier|storage class specifier}3">; - // OpenCL v2.0 s6.12.5 Blocks restrictions def err_opencl_block_storage_type : Error< "the __block storage type is not permitted">; @@ -8685,6 +8722,8 @@ def err_omp_expected_access_to_data_field : Error< "expected access to data field">; def err_omp_multiple_array_items_in_map_clause : Error< "multiple array elements associated with the same variable are not allowed in map clauses of the same construct">; +def err_omp_duplicate_map_type_modifier : Error< + "same map type modifier has been specified more than once">; def err_omp_pointer_mapped_along_with_derived_section : Error< "pointer cannot be mapped along with a section derived from itself">; def err_omp_original_storage_is_shared_and_does_not_contain : Error< @@ -8743,8 +8782,10 @@ def err_omp_required_access : Error< "%0 variable must be %1">; def err_omp_const_variable : Error< "const-qualified variable cannot be %0">; -def err_omp_const_reduction_list_item : Error< - "const-qualified list item cannot be reduction">; +def err_omp_const_not_mutable_variable : Error< + "const-qualified variable without mutable fields cannot be %0">; +def err_omp_const_list_item : Error< + "const-qualified list item cannot be %0">; def err_omp_linear_incomplete_type : Error< "a linear variable with incomplete type %0">; def err_omp_linear_expected_int_or_ptr : Error< @@ -8756,8 +8797,6 @@ def warn_omp_linear_step_zero : Warning< def warn_omp_alignment_not_power_of_two : Warning< "aligned clause will be ignored because the requested alignment is not a power of 2">, InGroup<OpenMPClauses>; -def err_omp_enclosed_declare_target : Error< - "declare target region may not be enclosed within another declare target region">; def err_omp_invalid_target_decl : Error< "%0 used in declare target directive is not a variable or a function name">; def err_omp_declare_target_multiple : Error< @@ -9029,6 +9068,20 @@ def err_omp_linear_distribute_var_non_loop_iteration : Error< def warn_omp_non_trivial_type_mapped : Warning< "Non-trivial type %0 is mapped, only trivial types are guaranteed to be mapped correctly">, InGroup<OpenMPTarget>; +def err_omp_requires_clause_redeclaration : Error < + "Only one %0 clause can appear on a requires directive in a single translation unit">; +def note_omp_requires_previous_clause : Note < + "%0 clause previously used here">; +def err_omp_invalid_scope : Error < + "'#pragma omp %0' directive must appear only in file scope">; +def note_omp_invalid_length_on_this_ptr_mapping : Note < + "expected length on mapping of 'this' array section expression to be '1'">; +def note_omp_invalid_lower_bound_on_this_ptr_mapping : Note < + "expected lower bound on mapping of 'this' array section expression to be '0' or not specified">; +def note_omp_invalid_subscript_on_this_ptr_map : Note < + "expected 'this' subscript expression on map clause to be 'this[0]'">; +def err_omp_invalid_map_this_expr : Error < + "invalid 'this' expression on 'map' clause">; } // end of OpenMP category let CategoryName = "Related Result Type Issue" in { @@ -9061,6 +9114,8 @@ def err_invalid_type_for_program_scope_var : Error< let CategoryName = "Modules Issue" in { def err_module_decl_in_module_map_module : Error< "'module' declaration found while building module from module map">; +def err_module_decl_in_header_module : Error< + "'module' declaration found while building header module">; def err_module_interface_implementation_mismatch : Error< "missing 'export' specifier in module declaration while " "building module interface">; @@ -9209,22 +9264,6 @@ def warn_not_a_doxygen_trailing_member_comment : Warning< "not a Doxygen trailing comment">, InGroup<Documentation>, DefaultIgnore; } // end of documentation issue category -let CategoryName = "Instrumentation Issue" in { -def warn_profile_data_out_of_date : Warning< - "profile data may be out of date: of %0 function%s0, %1 %plural{1:has|:have}1" - " mismatched data that will be ignored">, - InGroup<ProfileInstrOutOfDate>; -def warn_profile_data_missing : Warning< - "profile data may be incomplete: of %0 function%s0, %1 %plural{1:has|:have}1" - " no data">, - InGroup<ProfileInstrMissing>, - DefaultIgnore; -def warn_profile_data_unprofiled : Warning< - "no profile data available for file \"%0\"">, - InGroup<ProfileInstrUnprofiled>; - -} // end of instrumentation issue category - let CategoryName = "Nullability Issue" in { def warn_mismatched_nullability_attr : Warning< @@ -9372,14 +9411,9 @@ def warn_block_literal_qualifiers_on_omitted_return_type : Warning< "'%0' qualifier on omitted return type %1 has no effect">, InGroup<IgnoredQualifiers>; -def ext_warn_gnu_final : ExtWarn< - "__final is a GNU extension, consider using C++11 final">, - InGroup<GccCompat>; - -def warn_shadow_field : - Warning<"non-static data member %0 of %1 shadows member inherited from " - "type %2">, - InGroup<ShadowField>, DefaultIgnore; +def warn_shadow_field : Warning< + "%select{parameter|non-static data member}3 %0 %select{|of %1 }3shadows " + "member inherited from type %2">, InGroup<ShadowField>, DefaultIgnore; def note_shadow_field : Note<"declared here">; def err_multiversion_required_in_redecl : Error< @@ -9440,4 +9474,18 @@ def err_std_compare_type_not_supported : Error< "member '%2' is missing|" "the type is not trivially copyable|" "the type does not have the expected form}1">; + +def warn_dereference_of_noderef_type : Warning< + "dereferencing %0; was declared with a 'noderef' type">, InGroup<NoDeref>; +def warn_dereference_of_noderef_type_no_decl : Warning< + "dereferencing expression marked as 'noderef'">, InGroup<NoDeref>; +def warn_noderef_on_non_pointer_or_array : Warning< + "'noderef' can only be used on an array or pointer type">, InGroup<IgnoredAttributes>; +def warn_noderef_to_dereferenceable_pointer : Warning< + "casting to dereferenceable pointer removes 'noderef' attribute">, InGroup<NoDeref>; + +def err_builtin_launder_invalid_arg : Error< + "%select{non-pointer|function pointer|void pointer}0 argument to " + "'__builtin_launder' is not allowed">; + } // end of sema component. diff --git a/include/clang/Basic/DiagnosticSerialization.h b/include/clang/Basic/DiagnosticSerialization.h new file mode 100644 index 000000000000..d19e638dcf13 --- /dev/null +++ b/include/clang/Basic/DiagnosticSerialization.h @@ -0,0 +1,29 @@ +//===--- DiagnosticSerialization.h - Serialization Diagnostics -*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICSERIALIZATION_H +#define LLVM_CLANG_BASIC_DIAGNOSTICSERIALIZATION_H + +#include "clang/Basic/Diagnostic.h" + +namespace clang { +namespace diag { +enum { +#define DIAG(ENUM, FLAGS, DEFAULT_MAPPING, DESC, GROUP, SFINAE, NOWERROR, \ + SHOWINSYSHEADER, CATEGORY) \ + ENUM, +#define SERIALIZATIONSTART +#include "clang/Basic/DiagnosticSerializationKinds.inc" +#undef DIAG + NUM_BUILTIN_SERIALIZATION_DIAGNOSTICS +}; +} // end namespace diag +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_DIAGNOSTICSERIALIZATION_H diff --git a/include/clang/Basic/Features.def b/include/clang/Basic/Features.def index a0e0ce4560ab..05464ed85f13 100644 --- a/include/clang/Basic/Features.def +++ b/include/clang/Basic/Features.def @@ -17,6 +17,12 @@ // // The Predicate field dictates the conditions under which the feature or // extension will be made available. +// +// FEATURE(...) should be used to advertise support for standard language +// features, whereas EXTENSION(...) should be used for clang extensions. Note +// that many of the identifiers in this file don't follow this rule for backward +// compatibility reasons. +// //===----------------------------------------------------------------------===// #if !defined(FEATURE) && !defined(EXTENSION) @@ -37,6 +43,9 @@ FEATURE(address_sanitizer, FEATURE(hwaddress_sanitizer, LangOpts.Sanitize.hasOneOf(SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress)) +FEATURE(xray_instrument, LangOpts.XRayInstrument) +FEATURE(undefined_behavior_sanitizer, + LangOpts.Sanitize.hasOneOf(SanitizerKind::Undefined)) FEATURE(assume_nonnull, true) FEATURE(attribute_analyzer_noreturn, true) FEATURE(attribute_availability, true) @@ -48,6 +57,7 @@ FEATURE(attribute_availability_watchos, true) FEATURE(attribute_availability_with_strict, true) FEATURE(attribute_availability_with_replacement, true) FEATURE(attribute_availability_in_templates, true) +FEATURE(attribute_availability_swift, true) FEATURE(attribute_cf_returns_not_retained, true) FEATURE(attribute_cf_returns_retained, true) FEATURE(attribute_cf_returns_on_parameters, true) @@ -72,7 +82,9 @@ FEATURE(cxx_rtti, LangOpts.RTTI &&LangOpts.RTTIData) FEATURE(enumerator_attributes, true) FEATURE(nullability, true) FEATURE(nullability_on_arrays, true) -FEATURE(memory_sanitizer, LangOpts.Sanitize.has(SanitizerKind::Memory)) +FEATURE(memory_sanitizer, + LangOpts.Sanitize.hasOneOf(SanitizerKind::Memory | + SanitizerKind::KernelMemory)) FEATURE(thread_sanitizer, LangOpts.Sanitize.has(SanitizerKind::Thread)) FEATURE(dataflow_sanitizer, LangOpts.Sanitize.has(SanitizerKind::DataFlow)) FEATURE(efficiency_sanitizer, @@ -83,11 +95,11 @@ FEATURE(objc_arr, LangOpts.ObjCAutoRefCount) // FIXME: REMOVE? FEATURE(objc_arc, LangOpts.ObjCAutoRefCount) FEATURE(objc_arc_fields, true) FEATURE(objc_arc_weak, LangOpts.ObjCWeak) -FEATURE(objc_default_synthesize_properties, LangOpts.ObjC2) -FEATURE(objc_fixed_enum, LangOpts.ObjC2) -FEATURE(objc_instancetype, LangOpts.ObjC2) -FEATURE(objc_kindof, LangOpts.ObjC2) -FEATURE(objc_modules, LangOpts.ObjC2 &&LangOpts.Modules) +FEATURE(objc_default_synthesize_properties, LangOpts.ObjC) +FEATURE(objc_fixed_enum, true) +FEATURE(objc_instancetype, LangOpts.ObjC) +FEATURE(objc_kindof, LangOpts.ObjC) +FEATURE(objc_modules, LangOpts.ObjC && LangOpts.Modules) FEATURE(objc_nonfragile_abi, LangOpts.ObjCRuntime.isNonFragile()) FEATURE(objc_property_explicit_atomic, true) FEATURE(objc_protocol_qualifier_mangling, true) @@ -97,16 +109,16 @@ FEATURE(ownership_returns, true) FEATURE(ownership_takes, true) FEATURE(objc_bool, true) FEATURE(objc_subscripting, LangOpts.ObjCRuntime.isNonFragile()) -FEATURE(objc_array_literals, LangOpts.ObjC2) -FEATURE(objc_dictionary_literals, LangOpts.ObjC2) -FEATURE(objc_boxed_expressions, LangOpts.ObjC2) -FEATURE(objc_boxed_nsvalue_expressions, LangOpts.ObjC2) +FEATURE(objc_array_literals, LangOpts.ObjC) +FEATURE(objc_dictionary_literals, LangOpts.ObjC) +FEATURE(objc_boxed_expressions, LangOpts.ObjC) +FEATURE(objc_boxed_nsvalue_expressions, LangOpts.ObjC) FEATURE(arc_cf_code_audited, true) FEATURE(objc_bridge_id, true) FEATURE(objc_bridge_id_on_typedefs, true) -FEATURE(objc_generics, LangOpts.ObjC2) -FEATURE(objc_generics_variance, LangOpts.ObjC2) -FEATURE(objc_class_property, LangOpts.ObjC2) +FEATURE(objc_generics, LangOpts.ObjC) +FEATURE(objc_generics_variance, LangOpts.ObjC) +FEATURE(objc_class_property, LangOpts.ObjC) // C11 features FEATURE(c_alignas, LangOpts.C11) FEATURE(c_alignof, LangOpts.C11) @@ -227,12 +239,14 @@ EXTENSION(cxx_range_for, LangOpts.CPlusPlus) EXTENSION(cxx_reference_qualified_functions, LangOpts.CPlusPlus) EXTENSION(cxx_rvalue_references, LangOpts.CPlusPlus) EXTENSION(cxx_variadic_templates, LangOpts.CPlusPlus) +EXTENSION(cxx_fixed_enum, true) // C++14 features supported by other languages as extensions. EXTENSION(cxx_binary_literals, true) EXTENSION(cxx_init_captures, LangOpts.CPlusPlus11) EXTENSION(cxx_variable_templates, LangOpts.CPlusPlus) // Miscellaneous language extensions EXTENSION(overloadable_unmarked, true) +EXTENSION(pragma_clang_attribute_namespaces, true) #undef EXTENSION #undef FEATURE diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index ab5dfca71639..e7891baf5304 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -16,7 +16,7 @@ #define LLVM_CLANG_BASIC_FILEMANAGER_H #include "clang/Basic/FileSystemOptions.h" -#include "clang/Basic/VirtualFileSystem.h" +#include "clang/Basic/LLVM.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/SmallVector.h" @@ -25,9 +25,10 @@ #include "llvm/Support/Allocator.h" #include "llvm/Support/ErrorOr.h" #include "llvm/Support/FileSystem.h" +#include "llvm/Support/VirtualFileSystem.h" #include <ctime> -#include <memory> #include <map> +#include <memory> #include <string> namespace llvm { @@ -69,14 +70,15 @@ class FileEntry { bool IsNamedPipe; bool InPCH; bool IsValid; // Is this \c FileEntry initialized and valid? + bool DeferredOpen; // Created by getFile(OpenFile=0); may open later. /// The open file, if it is owned by the \p FileEntry. - mutable std::unique_ptr<vfs::File> File; + mutable std::unique_ptr<llvm::vfs::File> File; public: FileEntry() - : UniqueID(0, 0), IsNamedPipe(false), InPCH(false), IsValid(false) - {} + : UniqueID(0, 0), IsNamedPipe(false), InPCH(false), IsValid(false), + DeferredOpen(false) {} FileEntry(const FileEntry &) = delete; FileEntry &operator=(const FileEntry &) = delete; @@ -102,6 +104,10 @@ public: void closeFile() const { File.reset(); // rely on destructor to close File } + + // Only for use in tests to see if deferred opens are happening, rather than + // relying on RealPathName being empty. + bool isOpenForTests() const { return File != nullptr; } }; struct FileData; @@ -114,7 +120,7 @@ struct FileData; /// as a single file. /// class FileManager : public RefCountedBase<FileManager> { - IntrusiveRefCntPtr<vfs::FileSystem> FS; + IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; FileSystemOptions FileSystemOpts; /// Cache for existing real directories. @@ -165,15 +171,18 @@ class FileManager : public RefCountedBase<FileManager> { std::unique_ptr<FileSystemStatCache> StatCache; bool getStatValue(StringRef Path, FileData &Data, bool isFile, - std::unique_ptr<vfs::File> *F); + std::unique_ptr<llvm::vfs::File> *F); /// Add all ancestors of the given path (pointing to either a file /// or a directory) as virtual directories. void addAncestorsAsVirtualDirs(StringRef Path); + /// Fills the RealPathName in file entry. + void fillRealPathName(FileEntry *UFE, llvm::StringRef FileName); + public: FileManager(const FileSystemOptions &FileSystemOpts, - IntrusiveRefCntPtr<vfs::FileSystem> FS = nullptr); + IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = nullptr); ~FileManager(); /// Installs the provided FileSystemStatCache object within @@ -183,18 +192,10 @@ public: /// /// \param statCache the new stat cache to install. Ownership of this /// object is transferred to the FileManager. - /// - /// \param AtBeginning whether this new stat cache must be installed at the - /// beginning of the chain of stat caches. Otherwise, it will be added to - /// the end of the chain. - void addStatCache(std::unique_ptr<FileSystemStatCache> statCache, - bool AtBeginning = false); - - /// Removes the specified FileSystemStatCache object from the manager. - void removeStatCache(FileSystemStatCache *statCache); + void setStatCache(std::unique_ptr<FileSystemStatCache> statCache); - /// Removes all FileSystemStatCache objects from the manager. - void clearStatCaches(); + /// Removes the FileSystemStatCache object from the manager. + void clearStatCache(); /// Lookup, cache, and verify the specified directory (real or /// virtual). @@ -222,7 +223,7 @@ public: FileSystemOptions &getFileSystemOpts() { return FileSystemOpts; } const FileSystemOptions &getFileSystemOpts() const { return FileSystemOpts; } - IntrusiveRefCntPtr<vfs::FileSystem> getVirtualFileSystem() const { + IntrusiveRefCntPtr<llvm::vfs::FileSystem> getVirtualFileSystem() const { return FS; } @@ -247,8 +248,7 @@ public: /// FileManager's FileSystemOptions. /// /// \returns false on success, true on error. - bool getNoncachedStatValue(StringRef Path, - vfs::Status &Result); + bool getNoncachedStatValue(StringRef Path, llvm::vfs::Status &Result); /// Remove the real file \p Entry from the cache. void invalidateCache(const FileEntry *Entry); diff --git a/include/clang/Basic/FileSystemStatCache.h b/include/clang/Basic/FileSystemStatCache.h index 1ec344623a0d..f93170c754d5 100644 --- a/include/clang/Basic/FileSystemStatCache.h +++ b/include/clang/Basic/FileSystemStatCache.h @@ -26,7 +26,7 @@ #include <string> #include <utility> -namespace clang { +namespace llvm { namespace vfs { @@ -34,6 +34,9 @@ class File; class FileSystem; } // namespace vfs +} // namespace llvm + +namespace clang { // FIXME: should probably replace this with vfs::Status struct FileData { @@ -57,9 +60,6 @@ struct FileData { class FileSystemStatCache { virtual void anchor(); -protected: - std::unique_ptr<FileSystemStatCache> NextStatCache; - public: virtual ~FileSystemStatCache() = default; @@ -82,42 +82,16 @@ public: /// implementation can optionally fill in \p F with a valid \p File object and /// the client guarantees that it will close it. static bool get(StringRef Path, FileData &Data, bool isFile, - std::unique_ptr<vfs::File> *F, FileSystemStatCache *Cache, - vfs::FileSystem &FS); - - /// Sets the next stat call cache in the chain of stat caches. - /// Takes ownership of the given stat cache. - void setNextStatCache(std::unique_ptr<FileSystemStatCache> Cache) { - NextStatCache = std::move(Cache); - } - - /// Retrieve the next stat call cache in the chain. - FileSystemStatCache *getNextStatCache() { return NextStatCache.get(); } - - /// Retrieve the next stat call cache in the chain, transferring - /// ownership of this cache (and, transitively, all of the remaining caches) - /// to the caller. - std::unique_ptr<FileSystemStatCache> takeNextStatCache() { - return std::move(NextStatCache); - } + std::unique_ptr<llvm::vfs::File> *F, + FileSystemStatCache *Cache, llvm::vfs::FileSystem &FS); protected: // FIXME: The pointer here is a non-owning/optional reference to the // unique_ptr. Optional<unique_ptr<vfs::File>&> might be nicer, but // Optional needs some work to support references so this isn't possible yet. virtual LookupResult getStat(StringRef Path, FileData &Data, bool isFile, - std::unique_ptr<vfs::File> *F, - vfs::FileSystem &FS) = 0; - - LookupResult statChained(StringRef Path, FileData &Data, bool isFile, - std::unique_ptr<vfs::File> *F, vfs::FileSystem &FS) { - if (FileSystemStatCache *Next = getNextStatCache()) - return Next->getStat(Path, Data, isFile, F, FS); - - // If we hit the end of the list of stat caches to try, just compute and - // return it without a cache. - return get(Path, Data, isFile, F, nullptr, FS) ? CacheMissing : CacheExists; - } + std::unique_ptr<llvm::vfs::File> *F, + llvm::vfs::FileSystem &FS) = 0; }; /// A stat "cache" that can be used by FileManager to keep @@ -135,8 +109,8 @@ public: iterator end() const { return StatCalls.end(); } LookupResult getStat(StringRef Path, FileData &Data, bool isFile, - std::unique_ptr<vfs::File> *F, - vfs::FileSystem &FS) override; + std::unique_ptr<llvm::vfs::File> *F, + llvm::vfs::FileSystem &FS) override; }; } // namespace clang diff --git a/include/clang/Basic/FixedPoint.h b/include/clang/Basic/FixedPoint.h new file mode 100644 index 000000000000..9a9b7cc9c1fb --- /dev/null +++ b/include/clang/Basic/FixedPoint.h @@ -0,0 +1,138 @@ +//===- FixedPoint.h - Fixed point constant handling -------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Defines the fixed point number interface. +/// This is a class for abstracting various operations performed on fixed point +/// types described in ISO/IEC JTC1 SC22 WG14 N1169 starting at clause 4. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_FIXEDPOINT_H +#define LLVM_CLANG_BASIC_FIXEDPOINT_H + +#include "llvm/ADT/APSInt.h" + +namespace clang { + +class ASTContext; +class QualType; + +/// The fixed point semantics work similarly to llvm::fltSemantics. The width +/// specifies the whole bit width of the underlying scaled integer (with padding +/// if any). The scale represents the number of fractional bits in this type. +/// When HasUnsignedPadding is true and this type is signed, the first bit +/// in the value this represents is treaded as padding. +class FixedPointSemantics { +public: + FixedPointSemantics(unsigned Width, unsigned Scale, bool IsSigned, + bool IsSaturated, bool HasUnsignedPadding) + : Width(Width), Scale(Scale), IsSigned(IsSigned), + IsSaturated(IsSaturated), HasUnsignedPadding(HasUnsignedPadding) { + assert(Width >= Scale && "Not enough room for the scale"); + } + + unsigned getWidth() const { return Width; } + unsigned getScale() const { return Scale; } + bool isSigned() const { return IsSigned; } + bool isSaturated() const { return IsSaturated; } + bool hasUnsignedPadding() const { return HasUnsignedPadding; } + + void setSaturated(bool Saturated) { IsSaturated = Saturated; } + + unsigned getIntegralBits() const { + if (IsSigned || (!IsSigned && HasUnsignedPadding)) + return Width - Scale - 1; + else + return Width - Scale; + } + +private: + unsigned Width; + unsigned Scale; + bool IsSigned; + bool IsSaturated; + bool HasUnsignedPadding; +}; + +/// The APFixedPoint class works similarly to APInt/APSInt in that it is a +/// functional replacement for a scaled integer. It is meant to replicate the +/// fixed point types proposed in ISO/IEC JTC1 SC22 WG14 N1169. The class carries +/// info about the fixed point type's width, sign, scale, and saturation, and +/// provides different operations that would normally be performed on fixed point +/// types. +/// +/// Semantically this does not represent any existing C type other than fixed +/// point types and should eventually be moved to LLVM if fixed point types gain +/// native IR support. +class APFixedPoint { + public: + APFixedPoint(const llvm::APInt &Val, const FixedPointSemantics &Sema) + : Val(Val, !Sema.isSigned()), Sema(Sema) { + assert(Val.getBitWidth() == Sema.getWidth() && + "The value should have a bit width that matches the Sema width"); + } + + APFixedPoint(uint64_t Val, const FixedPointSemantics &Sema) + : APFixedPoint(llvm::APInt(Sema.getWidth(), Val, Sema.isSigned()), + Sema) {} + + llvm::APSInt getValue() const { return llvm::APSInt(Val, !Sema.isSigned()); } + inline unsigned getWidth() const { return Sema.getWidth(); } + inline unsigned getScale() const { return Sema.getScale(); } + inline bool isSaturated() const { return Sema.isSaturated(); } + inline bool isSigned() const { return Sema.isSigned(); } + inline bool hasPadding() const { return Sema.hasUnsignedPadding(); } + + // Convert this number to match the semantics provided. + APFixedPoint convert(const FixedPointSemantics &DstSema) const; + + APFixedPoint shr(unsigned Amt) const { + return APFixedPoint(Val >> Amt, Sema); + } + + APFixedPoint shl(unsigned Amt) const { + return APFixedPoint(Val << Amt, Sema); + } + + llvm::APSInt getIntPart() const { + if (Val < 0 && Val != -Val) // Cover the case when we have the min val + return -(-Val >> getScale()); + else + return Val >> getScale(); + } + + // If LHS > RHS, return 1. If LHS == RHS, return 0. If LHS < RHS, return -1. + int compare(const APFixedPoint &Other) const; + bool operator==(const APFixedPoint &Other) const { + return compare(Other) == 0; + } + bool operator!=(const APFixedPoint &Other) const { + return compare(Other) != 0; + } + bool operator>(const APFixedPoint &Other) const { return compare(Other) > 0; } + bool operator<(const APFixedPoint &Other) const { return compare(Other) < 0; } + bool operator>=(const APFixedPoint &Other) const { + return compare(Other) >= 0; + } + bool operator<=(const APFixedPoint &Other) const { + return compare(Other) <= 0; + } + + static APFixedPoint getMax(const FixedPointSemantics &Sema); + static APFixedPoint getMin(const FixedPointSemantics &Sema); + +private: + llvm::APSInt Val; + FixedPointSemantics Sema; +}; + +} // namespace clang + +#endif diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h index c2e9c71b0f0d..82e8c8c34951 100644 --- a/include/clang/Basic/IdentifierTable.h +++ b/include/clang/Basic/IdentifierTable.h @@ -34,6 +34,8 @@ namespace clang { +class DeclarationName; +class DeclarationNameTable; class IdentifierInfo; class LangOptions; class MultiKeywordSelector; @@ -42,52 +44,91 @@ class SourceLocation; /// A simple pair of identifier info and location. using IdentifierLocPair = std::pair<IdentifierInfo *, SourceLocation>; +/// IdentifierInfo and other related classes are aligned to +/// 8 bytes so that DeclarationName can use the lower 3 bits +/// of a pointer to one of these classes. +enum { IdentifierInfoAlignment = 8 }; + /// One of these records is kept for each identifier that /// is lexed. This contains information about whether the token was \#define'd, /// is a language keyword, or if it is a front-end token of some sort (e.g. a /// variable or function name). The preprocessor keeps this information in a /// set, and all tok::identifier tokens have a pointer to one of these. -class IdentifierInfo { +/// It is aligned to 8 bytes because DeclarationName needs the lower 3 bits. +class alignas(IdentifierInfoAlignment) IdentifierInfo { friend class IdentifierTable; - unsigned TokenID : 9; // Front-end token ID or tok::identifier. - // Objective-C keyword ('protocol' in '@protocol') or builtin (__builtin_inf). - // First NUM_OBJC_KEYWORDS values are for Objective-C, the remaining values - // are for builtins. - unsigned ObjCOrBuiltinID :13; - bool HasMacro : 1; // True if there is a #define for this. - bool HadMacro : 1; // True if there was a #define for this. - bool IsExtension : 1; // True if identifier is a lang extension. - bool IsFutureCompatKeyword : 1; // True if identifier is a keyword in a - // newer Standard or proposed Standard. - bool IsPoisoned : 1; // True if identifier is poisoned. - bool IsCPPOperatorKeyword : 1; // True if ident is a C++ operator keyword. - bool NeedsHandleIdentifier : 1; // See "RecomputeNeedsHandleIdentifier". - bool IsFromAST : 1; // True if identifier was loaded (at least - // partially) from an AST file. - bool ChangedAfterLoad : 1; // True if identifier has changed from the - // definition loaded from an AST file. - bool FEChangedAfterLoad : 1; // True if identifier's frontend information - // has changed from the definition loaded - // from an AST file. - bool RevertedTokenID : 1; // True if revertTokenIDToIdentifier was - // called. - bool OutOfDate : 1; // True if there may be additional - // information about this identifier - // stored externally. - bool IsModulesImport : 1; // True if this is the 'import' contextual - // keyword. - // 29 bit left in 64-bit word. + // Front-end token ID or tok::identifier. + unsigned TokenID : 9; + + // ObjC keyword ('protocol' in '@protocol') or builtin (__builtin_inf). + // First NUM_OBJC_KEYWORDS values are for Objective-C, + // the remaining values are for builtins. + unsigned ObjCOrBuiltinID : 13; + + // True if there is a #define for this. + unsigned HasMacro : 1; + + // True if there was a #define for this. + unsigned HadMacro : 1; + + // True if the identifier is a language extension. + unsigned IsExtension : 1; + + // True if the identifier is a keyword in a newer or proposed Standard. + unsigned IsFutureCompatKeyword : 1; + + // True if the identifier is poisoned. + unsigned IsPoisoned : 1; + + // True if the identifier is a C++ operator keyword. + unsigned IsCPPOperatorKeyword : 1; + + // Internal bit set by the member function RecomputeNeedsHandleIdentifier. + // See comment about RecomputeNeedsHandleIdentifier for more info. + unsigned NeedsHandleIdentifier : 1; + + // True if the identifier was loaded (at least partially) from an AST file. + unsigned IsFromAST : 1; + + // True if the identifier has changed from the definition + // loaded from an AST file. + unsigned ChangedAfterLoad : 1; + + // True if the identifier's frontend information has changed from the + // definition loaded from an AST file. + unsigned FEChangedAfterLoad : 1; + + // True if revertTokenIDToIdentifier was called. + unsigned RevertedTokenID : 1; + + // True if there may be additional information about + // this identifier stored externally. + unsigned OutOfDate : 1; + + // True if this is the 'import' contextual keyword. + unsigned IsModulesImport : 1; + + // 29 bits left in a 64-bit word. // Managed by the language front-end. void *FETokenInfo = nullptr; llvm::StringMapEntry<IdentifierInfo *> *Entry = nullptr; + IdentifierInfo() + : TokenID(tok::identifier), ObjCOrBuiltinID(0), HasMacro(false), + HadMacro(false), IsExtension(false), IsFutureCompatKeyword(false), + IsPoisoned(false), IsCPPOperatorKeyword(false), + NeedsHandleIdentifier(false), IsFromAST(false), ChangedAfterLoad(false), + FEChangedAfterLoad(false), RevertedTokenID(false), OutOfDate(false), + IsModulesImport(false) {} + public: - IdentifierInfo(); IdentifierInfo(const IdentifierInfo &) = delete; IdentifierInfo &operator=(const IdentifierInfo &) = delete; + IdentifierInfo(IdentifierInfo &&) = delete; + IdentifierInfo &operator=(IdentifierInfo &&) = delete; /// Return true if this is the identifier for the specified string. /// @@ -106,31 +147,10 @@ public: /// Return the beginning of the actual null-terminated string for this /// identifier. - const char *getNameStart() const { - if (Entry) return Entry->getKeyData(); - // FIXME: This is gross. It would be best not to embed specific details - // of the PTH file format here. - // The 'this' pointer really points to a - // std::pair<IdentifierInfo, const char*>, where internal pointer - // points to the external string data. - using actualtype = std::pair<IdentifierInfo, const char *>; - - return ((const actualtype*) this)->second; - } + const char *getNameStart() const { return Entry->getKeyData(); } /// Efficiently return the length of this identifier info. - unsigned getLength() const { - if (Entry) return Entry->getKeyLength(); - // FIXME: This is gross. It would be best not to embed specific details - // of the PTH file format here. - // The 'this' pointer really points to a - // std::pair<IdentifierInfo, const char*>, where internal pointer - // points to the external string data. - using actualtype = std::pair<IdentifierInfo, const char *>; - - const char* p = ((const actualtype*) this)->second - 2; - return (((unsigned) p[0]) | (((unsigned) p[1]) << 8)) - 1; - } + unsigned getLength() const { return Entry->getKeyLength(); } /// Return the actual identifier string. StringRef getName() const { @@ -284,10 +304,9 @@ public: /// language. bool isCPlusPlusKeyword(const LangOptions &LangOpts) const; - /// getFETokenInfo/setFETokenInfo - The language front-end is allowed to - /// associate arbitrary metadata with this token. - template<typename T> - T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); } + /// Get and set FETokenInfo. The language front-end is allowed to associate + /// arbitrary metadata with this token. + void *getFETokenInfo() const { return FETokenInfo; } void setFETokenInfo(void *T) { FETokenInfo = T; } /// Return true if the Preprocessor::HandleIdentifier must be called @@ -653,16 +672,22 @@ enum ObjCStringFormatFamily { /// accounts for 78% of all selectors in Cocoa.h. class Selector { friend class Diagnostic; + friend class SelectorTable; // only the SelectorTable can create these + friend class DeclarationName; // and the AST's DeclarationName. enum IdentifierInfoFlag { - // Empty selector = 0. - ZeroArg = 0x1, - OneArg = 0x2, - MultiArg = 0x3, - ArgFlags = ZeroArg|OneArg + // Empty selector = 0. Note that these enumeration values must + // correspond to the enumeration values of DeclarationName::StoredNameKind + ZeroArg = 0x01, + OneArg = 0x02, + MultiArg = 0x07, + ArgFlags = 0x07 }; - // a pointer to the MultiKeywordSelector or IdentifierInfo. + /// A pointer to the MultiKeywordSelector or IdentifierInfo. We use the low + /// three bits of InfoPtr to store an IdentifierInfoFlag. Note that in any + /// case IdentifierInfo and MultiKeywordSelector are already aligned to + /// 8 bytes even on 32 bits archs because of DeclarationName. uintptr_t InfoPtr = 0; Selector(IdentifierInfo *II, unsigned nArgs) { @@ -697,13 +722,10 @@ class Selector { static ObjCStringFormatFamily getStringFormatFamilyImpl(Selector sel); public: - friend class SelectorTable; // only the SelectorTable can create these - friend class DeclarationName; // and the AST's DeclarationName. - /// The default ctor should only be used when creating data structures that /// will contain selectors. Selector() = default; - Selector(uintptr_t V) : InfoPtr(V) {} + explicit Selector(uintptr_t V) : InfoPtr(V) {} /// operator==/!= - Indicate whether the specified selectors are identical. bool operator==(Selector RHS) const { @@ -832,39 +854,68 @@ public: static std::string getPropertyNameFromSetterSelector(Selector Sel); }; -/// DeclarationNameExtra - Common base of the MultiKeywordSelector, -/// CXXSpecialName, and CXXOperatorIdName classes, all of which are -/// private classes that describe different kinds of names. -class DeclarationNameExtra { -public: - /// ExtraKind - The kind of "extra" information stored in the - /// DeclarationName. See @c ExtraKindOrNumArgs for an explanation of - /// how these enumerator values are used. +namespace detail { + +/// DeclarationNameExtra is used as a base of various uncommon special names. +/// This class is needed since DeclarationName has not enough space to store +/// the kind of every possible names. Therefore the kind of common names is +/// stored directly in DeclarationName, and the kind of uncommon names is +/// stored in DeclarationNameExtra. It is aligned to 8 bytes because +/// DeclarationName needs the lower 3 bits to store the kind of common names. +/// DeclarationNameExtra is tightly coupled to DeclarationName and any change +/// here is very likely to require changes in DeclarationName(Table). +class alignas(IdentifierInfoAlignment) DeclarationNameExtra { + friend class clang::DeclarationName; + friend class clang::DeclarationNameTable; + +protected: + /// The kind of "extra" information stored in the DeclarationName. See + /// @c ExtraKindOrNumArgs for an explanation of how these enumerator values + /// are used. Note that DeclarationName depends on the numerical values + /// of the enumerators in this enum. See DeclarationName::StoredNameKind + /// for more info. enum ExtraKind { - CXXConstructor = 0, - CXXDestructor, - CXXConversionFunction, -#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ - CXXOperator##Name, -#include "clang/Basic/OperatorKinds.def" - CXXDeductionGuide, - CXXLiteralOperator, + CXXDeductionGuideName, + CXXLiteralOperatorName, CXXUsingDirective, - NUM_EXTRA_KINDS + ObjCMultiArgSelector }; - /// ExtraKindOrNumArgs - Either the kind of C++ special name or - /// operator-id (if the value is one of the CXX* enumerators of - /// ExtraKind), in which case the DeclarationNameExtra is also a - /// CXXSpecialName, (for CXXConstructor, CXXDestructor, or - /// CXXConversionFunction) CXXOperatorIdName, or CXXLiteralOperatorName, - /// it may be also name common to C++ using-directives (CXXUsingDirective), - /// otherwise it is NUM_EXTRA_KINDS+NumArgs, where NumArgs is the number of - /// arguments in the Objective-C selector, in which case the - /// DeclarationNameExtra is also a MultiKeywordSelector. + /// ExtraKindOrNumArgs has one of the following meaning: + /// * The kind of an uncommon C++ special name. This DeclarationNameExtra + /// is in this case in fact either a CXXDeductionGuideNameExtra or + /// a CXXLiteralOperatorIdName. + /// + /// * It may be also name common to C++ using-directives (CXXUsingDirective), + /// + /// * Otherwise it is ObjCMultiArgSelector+NumArgs, where NumArgs is + /// the number of arguments in the Objective-C selector, in which + /// case the DeclarationNameExtra is also a MultiKeywordSelector. unsigned ExtraKindOrNumArgs; + + DeclarationNameExtra(ExtraKind Kind) : ExtraKindOrNumArgs(Kind) {} + DeclarationNameExtra(unsigned NumArgs) + : ExtraKindOrNumArgs(ObjCMultiArgSelector + NumArgs) {} + + /// Return the corresponding ExtraKind. + ExtraKind getKind() const { + return static_cast<ExtraKind>(ExtraKindOrNumArgs > + (unsigned)ObjCMultiArgSelector + ? (unsigned)ObjCMultiArgSelector + : ExtraKindOrNumArgs); + } + + /// Return the number of arguments in an ObjC selector. Only valid when this + /// is indeed an ObjCMultiArgSelector. + unsigned getNumArgs() const { + assert(ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector && + "getNumArgs called but this is not an ObjC selector!"); + return ExtraKindOrNumArgs - (unsigned)ObjCMultiArgSelector; + } }; +} // namespace detail + } // namespace clang namespace llvm { diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index fc38af5b03f6..49961856c965 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -92,8 +92,7 @@ LANGOPT(CPlusPlus11 , 1, 0, "C++11") LANGOPT(CPlusPlus14 , 1, 0, "C++14") LANGOPT(CPlusPlus17 , 1, 0, "C++17") LANGOPT(CPlusPlus2a , 1, 0, "C++2a") -LANGOPT(ObjC1 , 1, 0, "Objective-C 1") -LANGOPT(ObjC2 , 1, 0, "Objective-C 2") +LANGOPT(ObjC , 1, 0, "Objective-C") BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0, "Objective-C auto-synthesized properties") BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0, @@ -139,6 +138,7 @@ LANGOPT(NoBuiltin , 1, 0, "disable builtin functions") LANGOPT(NoMathBuiltin , 1, 0, "disable math builtin functions") LANGOPT(GNUAsm , 1, 1, "GNU-style inline assembly") LANGOPT(CoroutinesTS , 1, 0, "C++ coroutines TS") +LANGOPT(DllExportInlines , 1, 1, "dllexported classes dllexport inline methods") LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments") LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes") @@ -203,14 +203,18 @@ LANGOPT(OpenMPSimd , 1, 0, "Use SIMD only OpenMP support.") LANGOPT(OpenMPUseTLS , 1, 0, "Use TLS for threadprivates or runtime calls") LANGOPT(OpenMPIsDevice , 1, 0, "Generate code only for OpenMP target device") LANGOPT(OpenMPCUDAMode , 1, 0, "Generate code for OpenMP pragmas in SIMT/SPMD mode") +LANGOPT(OpenMPCUDAForceFullRuntime , 1, 0, "Force to use full runtime in all constructs when offloading to CUDA devices") LANGOPT(OpenMPHostCXXExceptions , 1, 0, "C++ exceptions handling in the host code.") +LANGOPT(OpenMPCUDANumSMs , 32, 0, "Number of SMs for CUDA devices.") +LANGOPT(OpenMPCUDABlocksPerSM , 32, 0, "Number of blocks per SM for CUDA devices.") +LANGOPT(OpenMPOptimisticCollapse , 1, 0, "Use at most 32 bits to represent the collapsed loop nest counter.") LANGOPT(RenderScript , 1, 0, "RenderScript") LANGOPT(CUDAIsDevice , 1, 0, "compiling for CUDA device") LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code") LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__") LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions") -LANGOPT(CUDARelocatableDeviceCode, 1, 0, "generate relocatable device code") +LANGOPT(GPURelocatableDeviceCode, 1, 0, "generate relocatable device code") LANGOPT(SizedDeallocation , 1, 0, "sized deallocation") LANGOPT(AlignedAllocation , 1, 0, "aligned allocation") @@ -224,7 +228,8 @@ BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records" BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form") BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables") LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings") -BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden default visibility for inline C++ methods") +BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden visibility for inline C++ methods") +LANGOPT(GlobalAllocationFunctionVisibilityHidden , 1, 0, "hidden visibility for global operator new and delete declaration") BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype") BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support") BENIGN_LANGOPT(DebuggerCastResultToId, 1, 0, "for 'po' in the debugger, cast the result to id if it is of unknown type") @@ -259,6 +264,8 @@ ENUM_LANGOPT(TypeVisibilityMode, Visibility, 3, DefaultVisibility, "type symbol visibility") ENUM_LANGOPT(StackProtector, StackProtectorMode, 2, SSPOff, "stack protector mode") +ENUM_LANGOPT(TrivialAutoVarInit, TrivialAutoVarInitKind, 2, TrivialAutoVarInitKind::Uninitialized, + "trivial automatic variable initialization") ENUM_LANGOPT(SignedOverflowBehavior, SignedOverflowBehaviorTy, 2, SOB_Undefined, "signed integer overflow handling") @@ -308,6 +315,8 @@ LANGOPT(FixedPoint, 1, 0, "fixed point types") LANGOPT(PaddingOnUnsignedFixedPoint, 1, 0, "unsigned fixed point types having one extra padding bit") +LANGOPT(RegisterStaticDestructors, 1, 1, "Register C++ static destructors") + #undef LANGOPT #undef COMPATIBLE_LANGOPT #undef BENIGN_LANGOPT diff --git a/include/clang/Basic/LangOptions.h b/include/clang/Basic/LangOptions.h index a1396f84352f..9cff7c516043 100644 --- a/include/clang/Basic/LangOptions.h +++ b/include/clang/Basic/LangOptions.h @@ -54,6 +54,11 @@ public: enum GCMode { NonGC, GCOnly, HybridGC }; enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq }; + // Automatic variables live on the stack, and when trivial they're usually + // uninitialized because it's undefined behavior to use them without + // initializing them. + enum class TrivialAutoVarInitKind { Uninitialized, Zero, Pattern }; + enum SignedOverflowBehaviorTy { // Default C standard behavior. SOB_Undefined, @@ -73,8 +78,11 @@ public: /// Compiling a module from a module map. CMK_ModuleMap, + /// Compiling a module from a list of header files. + CMK_HeaderModule, + /// Compiling a C++ modules TS module interface unit. - CMK_ModuleInterface + CMK_ModuleInterface, }; enum PragmaMSPointersToMembersKind { @@ -95,11 +103,14 @@ public: enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off }; + // Corresponds to _MSC_VER enum MSVCMajorVersion { - MSVC2010 = 16, - MSVC2012 = 17, - MSVC2013 = 18, - MSVC2015 = 19 + MSVC2010 = 1600, + MSVC2012 = 1700, + MSVC2013 = 1800, + MSVC2015 = 1900, + MSVC2017 = 1910, + MSVC2017_5 = 1912 }; /// Clang versions with different platform ABI conformance. @@ -121,11 +132,34 @@ public: /// whether we reuse base class tail padding in some ABIs. Ver6, + /// Attempt to be ABI-compatible with code generated by Clang 7.0.x + /// (SVN r338536). This causes alignof (C++) and _Alignof (C11) to be + /// compatible with __alignof (i.e., return the preferred alignment) + /// rather than returning the required alignment. + Ver7, + /// Conform to the underlying platform's C and C++ ABIs as closely /// as we can. Latest }; + enum class CoreFoundationABI { + /// No interoperability ABI has been specified + Unspecified, + /// CoreFoundation does not have any language interoperability + Standalone, + /// Interoperability with the ObjectiveC runtime + ObjectiveC, + /// Interoperability with the latest known version of the Swift runtime + Swift, + /// Interoperability with the Swift 5.0 runtime + Swift5_0, + /// Interoperability with the Swift 4.2 runtime + Swift4_2, + /// Interoperability with the Swift 4.1 runtime + Swift4_1, + }; + enum FPContractModeKind { // Form fused FP ops only where result will not be affected. FPC_Off, @@ -137,6 +171,14 @@ public: FPC_Fast }; + // TODO: merge FEnvAccessModeKind and FPContractModeKind + enum FEnvAccessModeKind { + FEA_Off, + + FEA_On + }; + + public: /// Set of enabled sanitizers. SanitizerSet Sanitize; @@ -164,6 +206,8 @@ public: clang::ObjCRuntime ObjCRuntime; + CoreFoundationABI CFRuntime = CoreFoundationABI::Unspecified; + std::string ObjCConstantStringClass; /// The name of the handler function to be called when -ftrapv is @@ -235,7 +279,7 @@ public: } bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const { - return MSCompatibilityVersion >= MajorVersion * 10000000U; + return MSCompatibilityVersion >= MajorVersion * 100000U; } /// Reset all of the options that are not considered when building a @@ -262,14 +306,19 @@ public: /// Floating point control options class FPOptions { public: - FPOptions() : fp_contract(LangOptions::FPC_Off) {} + FPOptions() : fp_contract(LangOptions::FPC_Off), + fenv_access(LangOptions::FEA_Off) {} // Used for serializing. explicit FPOptions(unsigned I) - : fp_contract(static_cast<LangOptions::FPContractModeKind>(I)) {} + : fp_contract(static_cast<LangOptions::FPContractModeKind>(I & 3)), + fenv_access(static_cast<LangOptions::FEnvAccessModeKind>((I >> 2) & 1)) + {} explicit FPOptions(const LangOptions &LangOpts) - : fp_contract(LangOpts.getDefaultFPContractMode()) {} + : fp_contract(LangOpts.getDefaultFPContractMode()), + fenv_access(LangOptions::FEA_Off) {} + // FIXME: Use getDefaultFEnvAccessMode() when available. bool allowFPContractWithinStatement() const { return fp_contract == LangOptions::FPC_On; @@ -289,12 +338,24 @@ public: void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; } + bool allowFEnvAccess() const { + return fenv_access == LangOptions::FEA_On; + } + + void setAllowFEnvAccess() { + fenv_access = LangOptions::FEA_On; + } + + void setDisallowFEnvAccess() { fenv_access = LangOptions::FEA_Off; } + /// Used to serialize this. - unsigned getInt() const { return fp_contract; } + unsigned getInt() const { return fp_contract | (fenv_access << 2); } private: - /// Adjust BinaryOperator::FPFeatures to match the bit-field size of this. + /// Adjust BinaryOperator::FPFeatures to match the total bit-field size + /// of these two. unsigned fp_contract : 2; + unsigned fenv_access : 1; }; /// Describes the kind of translation unit being processed. diff --git a/include/clang/Basic/MSP430Target.def b/include/clang/Basic/MSP430Target.def new file mode 100644 index 000000000000..758113c5f575 --- /dev/null +++ b/include/clang/Basic/MSP430Target.def @@ -0,0 +1,247 @@ +//===--- MSP430Target.def - MSP430 Feature/Processor Database----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the MSP430 devices and their features. +// +//===----------------------------------------------------------------------===// + +#ifndef MSP430_MCU_FEAT +#define MSP430_MCU_FEAT(NAME, HWMULT) MSP430_MCU(NAME) +#endif + +#ifndef MSP430_MCU +#define MSP430_MCU(NAME) +#endif + +MSP430_MCU("msp430c111") +MSP430_MCU("msp430c1111") +MSP430_MCU("msp430c112") +MSP430_MCU("msp430c1121") +MSP430_MCU("msp430c1331") +MSP430_MCU("msp430c1351") +MSP430_MCU("msp430e112") +MSP430_MCU("msp430f110") +MSP430_MCU("msp430f1101") +MSP430_MCU("msp430f1101a") +MSP430_MCU("msp430f1111") +MSP430_MCU("msp430f1111a") +MSP430_MCU("msp430f112") +MSP430_MCU("msp430f1121") +MSP430_MCU("msp430f1121a") +MSP430_MCU("msp430f1122") +MSP430_MCU("msp430f1132") +MSP430_MCU("msp430f122") +MSP430_MCU("msp430f1222") +MSP430_MCU("msp430f123") +MSP430_MCU("msp430f1232") +MSP430_MCU("msp430f133") +MSP430_MCU("msp430f135") +MSP430_MCU("msp430f155") +MSP430_MCU("msp430f156") +MSP430_MCU("msp430f157") +MSP430_MCU("msp430p112") +MSP430_MCU("msp430f2001") +MSP430_MCU("msp430f2011") +MSP430_MCU("msp430f2002") +MSP430_MCU("msp430f2012") +MSP430_MCU("msp430f2003") +MSP430_MCU("msp430f2013") +MSP430_MCU("msp430f2101") +MSP430_MCU("msp430f2111") +MSP430_MCU("msp430f2121") +MSP430_MCU("msp430f2131") +MSP430_MCU("msp430f2112") +MSP430_MCU("msp430f2122") +MSP430_MCU("msp430f2132") +MSP430_MCU("msp430f2232") +MSP430_MCU("msp430f2252") +MSP430_MCU("msp430f2272") +MSP430_MCU("msp430f2234") +MSP430_MCU("msp430f2254") +MSP430_MCU("msp430f2274") +MSP430_MCU("msp430g2211") +MSP430_MCU("msp430g2201") +MSP430_MCU("msp430g2111") +MSP430_MCU("msp430g2101") +MSP430_MCU("msp430g2001") +MSP430_MCU("msp430g2231") +MSP430_MCU("msp430g2221") +MSP430_MCU("msp430g2131") +MSP430_MCU("msp430g2121") +MSP430_MCU("msp430g2102") +MSP430_MCU("msp430g2202") +MSP430_MCU("msp430g2302") +MSP430_MCU("msp430g2402") +MSP430_MCU("msp430g2132") +MSP430_MCU("msp430g2232") +MSP430_MCU("msp430g2332") +MSP430_MCU("msp430g2432") +MSP430_MCU("msp430g2112") +MSP430_MCU("msp430g2212") +MSP430_MCU("msp430g2312") +MSP430_MCU("msp430g2412") +MSP430_MCU("msp430g2152") +MSP430_MCU("msp430g2252") +MSP430_MCU("msp430g2352") +MSP430_MCU("msp430g2452") +MSP430_MCU("msp430g2113") +MSP430_MCU("msp430g2213") +MSP430_MCU("msp430g2313") +MSP430_MCU("msp430g2413") +MSP430_MCU("msp430g2513") +MSP430_MCU("msp430g2153") +MSP430_MCU("msp430g2253") +MSP430_MCU("msp430g2353") +MSP430_MCU("msp430g2453") +MSP430_MCU("msp430g2553") +MSP430_MCU("msp430g2203") +MSP430_MCU("msp430g2303") +MSP430_MCU("msp430g2403") +MSP430_MCU("msp430g2233") +MSP430_MCU("msp430g2333") +MSP430_MCU("msp430g2433") +MSP430_MCU("msp430g2533") +MSP430_MCU("msp430tch5e") +MSP430_MCU("msp430g2444") +MSP430_MCU("msp430g2544") +MSP430_MCU("msp430g2744") +MSP430_MCU("msp430g2755") +MSP430_MCU("msp430g2855") +MSP430_MCU("msp430g2955") +MSP430_MCU("msp430g2230") +MSP430_MCU("msp430g2210") +MSP430_MCU("msp430c311s") +MSP430_MCU("msp430c312") +MSP430_MCU("msp430c313") +MSP430_MCU("msp430c314") +MSP430_MCU("msp430c315") +MSP430_MCU("msp430c323") +MSP430_MCU("msp430c325") +MSP430_MCU("msp430c412") +MSP430_MCU("msp430c413") +MSP430_MCU("msp430e313") +MSP430_MCU("msp430e315") +MSP430_MCU("msp430e325") +MSP430_MCU("msp430p313") +MSP430_MCU("msp430p315") +MSP430_MCU("msp430p315s") +MSP430_MCU("msp430p325") +MSP430_MCU("msp430f412") +MSP430_MCU("msp430f413") +MSP430_MCU("msp430f415") +MSP430_MCU("msp430f417") +MSP430_MCU("msp430f4132") +MSP430_MCU("msp430f4152") +MSP430_MCU("msp430f435") +MSP430_MCU("msp430f436") +MSP430_MCU("msp430f437") +MSP430_MCU("msp430f4351") +MSP430_MCU("msp430f4361") +MSP430_MCU("msp430f4371") +MSP430_MCU("msp430fe423") +MSP430_MCU("msp430fe425") +MSP430_MCU("msp430fe427") +MSP430_MCU("msp430fe423a") +MSP430_MCU("msp430fe425a") +MSP430_MCU("msp430fe427a") +MSP430_MCU("msp430fe4232") +MSP430_MCU("msp430fe4242") +MSP430_MCU("msp430fe4252") +MSP430_MCU("msp430fe4272") +MSP430_MCU("msp430f4250") +MSP430_MCU("msp430f4260") +MSP430_MCU("msp430f4270") +MSP430_MCU("msp430fg4250") +MSP430_MCU("msp430fg4260") +MSP430_MCU("msp430fg4270") +MSP430_MCU("msp430fw423") +MSP430_MCU("msp430fw425") +MSP430_MCU("msp430fw427") +MSP430_MCU("msp430fw428") +MSP430_MCU("msp430fw429") +MSP430_MCU("msp430fg437") +MSP430_MCU("msp430fg438") +MSP430_MCU("msp430fg439") +MSP430_MCU("msp430f438") +MSP430_MCU("msp430f439") +MSP430_MCU("msp430f477") +MSP430_MCU("msp430f478") +MSP430_MCU("msp430f479") +MSP430_MCU("msp430fg477") +MSP430_MCU("msp430fg478") +MSP430_MCU("msp430fg479") + +// With 16-bit hardware multiplier +MSP430_MCU_FEAT("msp430f147", "16bit") +MSP430_MCU_FEAT("msp430f148", "16bit") +MSP430_MCU_FEAT("msp430f149", "16bit") +MSP430_MCU_FEAT("msp430f1471", "16bit") +MSP430_MCU_FEAT("msp430f1481", "16bit") +MSP430_MCU_FEAT("msp430f1491", "16bit") +MSP430_MCU_FEAT("msp430f167", "16bit") +MSP430_MCU_FEAT("msp430f168", "16bit") +MSP430_MCU_FEAT("msp430f169", "16bit") +MSP430_MCU_FEAT("msp430f1610", "16bit") +MSP430_MCU_FEAT("msp430f1611", "16bit") +MSP430_MCU_FEAT("msp430f1612", "16bit") +MSP430_MCU_FEAT("msp430c336", "16bit") +MSP430_MCU_FEAT("msp430c337", "16bit") +MSP430_MCU_FEAT("msp430e337", "16bit") +MSP430_MCU_FEAT("msp430p337", "16bit") +MSP430_MCU_FEAT("msp430f423", "16bit") +MSP430_MCU_FEAT("msp430f425", "16bit") +MSP430_MCU_FEAT("msp430f427", "16bit") +MSP430_MCU_FEAT("msp430f423a", "16bit") +MSP430_MCU_FEAT("msp430f425a", "16bit") +MSP430_MCU_FEAT("msp430f427a", "16bit") +MSP430_MCU_FEAT("msp430f4481", "16bit") +MSP430_MCU_FEAT("msp430f4491", "16bit") +MSP430_MCU_FEAT("msp430f447", "16bit") +MSP430_MCU_FEAT("msp430f448", "16bit") +MSP430_MCU_FEAT("msp430f449", "16bit") +MSP430_MCU_FEAT("msp430f2330", "16bit") +MSP430_MCU_FEAT("msp430f2350", "16bit") +MSP430_MCU_FEAT("msp430f2370", "16bit") +MSP430_MCU_FEAT("msp430f233", "16bit") +MSP430_MCU_FEAT("msp430f235", "16bit") +MSP430_MCU_FEAT("msp430f247", "16bit") +MSP430_MCU_FEAT("msp430f248", "16bit") +MSP430_MCU_FEAT("msp430f249", "16bit") +MSP430_MCU_FEAT("msp430f2410", "16bit") +MSP430_MCU_FEAT("msp430f2471", "16bit") +MSP430_MCU_FEAT("msp430f2481", "16bit") +MSP430_MCU_FEAT("msp430f2491", "16bit") +MSP430_MCU_FEAT("msp430i2020", "16bit") +MSP430_MCU_FEAT("msp430i2021", "16bit") +MSP430_MCU_FEAT("msp430i2030", "16bit") +MSP430_MCU_FEAT("msp430i2031", "16bit") +MSP430_MCU_FEAT("msp430i2040", "16bit") +MSP430_MCU_FEAT("msp430i2041", "16bit") +MSP430_MCU_FEAT("msp430afe221", "16bit") +MSP430_MCU_FEAT("msp430afe231", "16bit") +MSP430_MCU_FEAT("msp430afe251", "16bit") +MSP430_MCU_FEAT("msp430afe222", "16bit") +MSP430_MCU_FEAT("msp430afe232", "16bit") +MSP430_MCU_FEAT("msp430afe252", "16bit") +MSP430_MCU_FEAT("msp430afe223", "16bit") +MSP430_MCU_FEAT("msp430afe233", "16bit") +MSP430_MCU_FEAT("msp430afe253", "16bit") + +// With 32 Bit Hardware Multiplier +MSP430_MCU_FEAT("msp430f4783", "32bit") +MSP430_MCU_FEAT("msp430f4793", "32bit") +MSP430_MCU_FEAT("msp430f4784", "32bit") +MSP430_MCU_FEAT("msp430f4794", "32bit") + +// Generic MSUs +MSP430_MCU("msp430") +MSP430_MCU("msp430i2xxgeneric") + +#undef MSP430_MCU +#undef MSP430_MCU_FEAT diff --git a/include/clang/Basic/ObjCRuntime.h b/include/clang/Basic/ObjCRuntime.h index c307c9643390..fcfbe56b496f 100644 --- a/include/clang/Basic/ObjCRuntime.h +++ b/include/clang/Basic/ObjCRuntime.h @@ -173,6 +173,80 @@ public: llvm_unreachable("bad kind"); } + /// Does this runtime provide ARC entrypoints that are likely to be faster + /// than an ordinary message send of the appropriate selector? + /// + /// The ARC entrypoints are guaranteed to be equivalent to just sending the + /// corresponding message. If the entrypoint is implemented naively as just a + /// message send, using it is a trade-off: it sacrifices a few cycles of + /// overhead to save a small amount of code. However, it's possible for + /// runtimes to detect and special-case classes that use "standard" + /// retain/release behavior; if that's dynamically a large proportion of all + /// retained objects, using the entrypoint will also be faster than using a + /// message send. + /// + /// When this method returns true, Clang will turn non-super message sends of + /// certain selectors into calls to the correspond entrypoint: + /// retain => objc_retain + /// release => objc_release + /// autorelease => objc_autorelease + bool shouldUseARCFunctionsForRetainRelease() const { + switch (getKind()) { + case FragileMacOSX: + return false; + case MacOSX: + return getVersion() >= VersionTuple(10, 10); + case iOS: + return getVersion() >= VersionTuple(8); + case WatchOS: + return true; + case GCC: + return false; + case GNUstep: + return false; + case ObjFW: + return false; + } + llvm_unreachable("bad kind"); + } + + /// Does this runtime provide entrypoints that are likely to be faster + /// than an ordinary message send of the "alloc" selector? + /// + /// The "alloc" entrypoint is guaranteed to be equivalent to just sending the + /// corresponding message. If the entrypoint is implemented naively as just a + /// message send, using it is a trade-off: it sacrifices a few cycles of + /// overhead to save a small amount of code. However, it's possible for + /// runtimes to detect and special-case classes that use "standard" + /// alloc behavior; if that's dynamically a large proportion of all + /// objects, using the entrypoint will also be faster than using a message + /// send. + /// + /// When this method returns true, Clang will turn non-super message sends of + /// certain selectors into calls to the corresponding entrypoint: + /// alloc => objc_alloc + /// allocWithZone:nil => objc_allocWithZone + bool shouldUseRuntimeFunctionsForAlloc() const { + switch (getKind()) { + case FragileMacOSX: + return false; + case MacOSX: + return getVersion() >= VersionTuple(10, 10); + case iOS: + return getVersion() >= VersionTuple(8); + case WatchOS: + return true; + + case GCC: + return false; + case GNUstep: + return false; + case ObjFW: + return false; + } + llvm_unreachable("bad kind"); + } + /// Does this runtime supports optimized setter entrypoints? bool hasOptimizedSetter() const { switch (getKind()) { diff --git a/include/clang/Basic/OpenCLExtensionTypes.def b/include/clang/Basic/OpenCLExtensionTypes.def new file mode 100644 index 000000000000..b72f7efd6f28 --- /dev/null +++ b/include/clang/Basic/OpenCLExtensionTypes.def @@ -0,0 +1,41 @@ +//===-- OpenCLExtensionTypes.def - Metadata about BuiltinTypes ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// This file extends builtin types database with OpenCL extension types. +// Custom code should define this macro: +// EXT_OPAQUE_TYPE(Name, Id, Ext) + +#ifdef EXT_OPAQUE_TYPE + +#ifndef INTEL_SUBGROUP_AVC_TYPE +#define INTEL_SUBGROUP_AVC_TYPE(Name, Id) \ + EXT_OPAQUE_TYPE(intel_sub_group_avc_##Name, OCLIntelSubgroupAVC##Id, \ + cl_intel_device_side_avc_motion_estimation) +#endif + +#endif + +#ifdef INTEL_SUBGROUP_AVC_TYPE +INTEL_SUBGROUP_AVC_TYPE(mce_payload_t, McePayload) +INTEL_SUBGROUP_AVC_TYPE(ime_payload_t, ImePayload) +INTEL_SUBGROUP_AVC_TYPE(ref_payload_t, RefPayload) +INTEL_SUBGROUP_AVC_TYPE(sic_payload_t, SicPayload) +INTEL_SUBGROUP_AVC_TYPE(mce_result_t, MceResult) +INTEL_SUBGROUP_AVC_TYPE(ime_result_t, ImeResult) +INTEL_SUBGROUP_AVC_TYPE(ref_result_t, RefResult) +INTEL_SUBGROUP_AVC_TYPE(sic_result_t, SicResult) +INTEL_SUBGROUP_AVC_TYPE(ime_result_single_reference_streamout_t, ImeResultSingleRefStreamout) +INTEL_SUBGROUP_AVC_TYPE(ime_result_dual_reference_streamout_t, ImeResultDualRefStreamout) +INTEL_SUBGROUP_AVC_TYPE(ime_single_reference_streamin_t, ImeSingleRefStreamin) +INTEL_SUBGROUP_AVC_TYPE(ime_dual_reference_streamin_t, ImeDualRefStreamin) + +#undef INTEL_SUBGROUP_AVC_TYPE +#endif // INTEL_SUBGROUP_AVC_TYPE + +#undef EXT_OPAQUE_TYPE + diff --git a/include/clang/Basic/OpenCLExtensions.def b/include/clang/Basic/OpenCLExtensions.def index 13cb12e7c581..5e7d2cb473c7 100644 --- a/include/clang/Basic/OpenCLExtensions.def +++ b/include/clang/Basic/OpenCLExtensions.def @@ -85,6 +85,7 @@ OPENCLEXT_INTERNAL(cl_amd_media_ops2, 100, ~0U) // Intel OpenCL extensions OPENCLEXT_INTERNAL(cl_intel_subgroups, 120, ~0U) OPENCLEXT_INTERNAL(cl_intel_subgroups_short, 120, ~0U) +OPENCLEXT_INTERNAL(cl_intel_device_side_avc_motion_estimation, 120, ~0U) #undef OPENCLEXT_INTERNAL diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def index 4ed7053b679b..f86721b1b07e 100644 --- a/include/clang/Basic/OpenMPKinds.def +++ b/include/clang/Basic/OpenMPKinds.def @@ -57,6 +57,9 @@ #ifndef OPENMP_TARGET_CLAUSE # define OPENMP_TARGET_CLAUSE(Name) #endif +#ifndef OPENMP_REQUIRES_CLAUSE +# define OPENMP_REQUIRES_CLAUSE(Name) +#endif #ifndef OPENMP_TARGET_DATA_CLAUSE # define OPENMP_TARGET_DATA_CLAUSE(Name) #endif @@ -117,12 +120,18 @@ #ifndef OPENMP_MAP_KIND #define OPENMP_MAP_KIND(Name) #endif +#ifndef OPENMP_MAP_MODIFIER_KIND +#define OPENMP_MAP_MODIFIER_KIND(Name) +#endif #ifndef OPENMP_DIST_SCHEDULE_KIND #define OPENMP_DIST_SCHEDULE_KIND(Name) #endif #ifndef OPENMP_DEFAULTMAP_KIND #define OPENMP_DEFAULTMAP_KIND(Name) #endif +#ifndef OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND +#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) +#endif #ifndef OPENMP_DEFAULTMAP_MODIFIER #define OPENMP_DEFAULTMAP_MODIFIER(Name) #endif @@ -193,6 +202,7 @@ OPENMP_DIRECTIVE(atomic) OPENMP_DIRECTIVE(target) OPENMP_DIRECTIVE(teams) OPENMP_DIRECTIVE(cancel) +OPENMP_DIRECTIVE(requires) OPENMP_DIRECTIVE_EXT(target_data, "target data") OPENMP_DIRECTIVE_EXT(target_enter_data, "target enter data") OPENMP_DIRECTIVE_EXT(target_exit_data, "target exit data") @@ -275,6 +285,11 @@ OPENMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause) OPENMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause) OPENMP_CLAUSE(task_reduction, OMPTaskReductionClause) OPENMP_CLAUSE(in_reduction, OMPInReductionClause) +OPENMP_CLAUSE(unified_address, OMPUnifiedAddressClause) +OPENMP_CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause) +OPENMP_CLAUSE(reverse_offload, OMPReverseOffloadClause) +OPENMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause) +OPENMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause) // Clauses allowed for OpenMP directive 'parallel'. OPENMP_PARALLEL_CLAUSE(if) @@ -456,6 +471,18 @@ OPENMP_TARGET_CLAUSE(firstprivate) OPENMP_TARGET_CLAUSE(is_device_ptr) OPENMP_TARGET_CLAUSE(reduction) +// Clauses allowed for OpenMP directive 'requires'. +OPENMP_REQUIRES_CLAUSE(unified_address) +OPENMP_REQUIRES_CLAUSE(unified_shared_memory) +OPENMP_REQUIRES_CLAUSE(reverse_offload) +OPENMP_REQUIRES_CLAUSE(dynamic_allocators) +OPENMP_REQUIRES_CLAUSE(atomic_default_mem_order) + +// Modifiers for 'atomic_default_mem_order' clause. +OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(seq_cst) +OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(acq_rel) +OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(relaxed) + // Clauses allowed for OpenMP directive 'target data'. OPENMP_TARGET_DATA_CLAUSE(if) OPENMP_TARGET_DATA_CLAUSE(device) @@ -535,14 +562,17 @@ OPENMP_ORDERED_CLAUSE(threads) OPENMP_ORDERED_CLAUSE(simd) OPENMP_ORDERED_CLAUSE(depend) -// Map types and map type modifier for 'map' clause. +// Map types for 'map' clause. OPENMP_MAP_KIND(alloc) OPENMP_MAP_KIND(to) OPENMP_MAP_KIND(from) OPENMP_MAP_KIND(tofrom) OPENMP_MAP_KIND(delete) OPENMP_MAP_KIND(release) -OPENMP_MAP_KIND(always) + +// Map-type-modifiers for 'map' clause. +OPENMP_MAP_MODIFIER_KIND(always) +OPENMP_MAP_MODIFIER_KIND(close) // Clauses allowed for OpenMP directive 'taskloop'. OPENMP_TASKLOOP_CLAUSE(if) @@ -883,6 +913,8 @@ OPENMP_TASKGROUP_CLAUSE(task_reduction) #undef OPENMP_TASK_CLAUSE #undef OPENMP_ATOMIC_CLAUSE #undef OPENMP_TARGET_CLAUSE +#undef OPENMP_REQUIRES_CLAUSE +#undef OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND #undef OPENMP_TARGET_DATA_CLAUSE #undef OPENMP_TARGET_ENTER_DATA_CLAUSE #undef OPENMP_TARGET_EXIT_DATA_CLAUSE @@ -893,6 +925,7 @@ OPENMP_TASKGROUP_CLAUSE(task_reduction) #undef OPENMP_FOR_CLAUSE #undef OPENMP_FOR_SIMD_CLAUSE #undef OPENMP_MAP_KIND +#undef OPENMP_MAP_MODIFIER_KIND #undef OPENMP_DISTRIBUTE_CLAUSE #undef OPENMP_DIST_SCHEDULE_KIND #undef OPENMP_DEFAULTMAP_KIND diff --git a/include/clang/Basic/OpenMPKinds.h b/include/clang/Basic/OpenMPKinds.h index c47973e53a8a..3e03a48cf68e 100644 --- a/include/clang/Basic/OpenMPKinds.h +++ b/include/clang/Basic/OpenMPKinds.h @@ -96,6 +96,15 @@ enum OpenMPMapClauseKind { OMPC_MAP_unknown }; +/// OpenMP modifier kind for 'map' clause. +enum OpenMPMapModifierKind { + OMPC_MAP_MODIFIER_unknown = OMPC_MAP_unknown, +#define OPENMP_MAP_MODIFIER_KIND(Name) \ + OMPC_MAP_MODIFIER_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_MAP_MODIFIER_last +}; + /// OpenMP attributes for 'dist_schedule' clause. enum OpenMPDistScheduleClauseKind { #define OPENMP_DIST_SCHEDULE_KIND(Name) OMPC_DIST_SCHEDULE_##Name, @@ -120,6 +129,14 @@ enum OpenMPDefaultmapClauseModifier { OMPC_DEFAULTMAP_MODIFIER_last }; +/// OpenMP attributes for 'atomic_default_mem_order' clause. +enum OpenMPAtomicDefaultMemOrderClauseKind { +#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ + OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown +}; + /// Scheduling data for loop-based OpenMP directives. struct OpenMPScheduleTy final { OpenMPScheduleClauseKind Schedule = OMPC_SCHEDULE_unknown; diff --git a/include/clang/Basic/PlistSupport.h b/include/clang/Basic/PlistSupport.h index be92bbfde185..e41c24737798 100644 --- a/include/clang/Basic/PlistSupport.h +++ b/include/clang/Basic/PlistSupport.h @@ -25,24 +25,35 @@ namespace markup { using FIDMap = llvm::DenseMap<FileID, unsigned>; -inline void AddFID(FIDMap &FIDs, SmallVectorImpl<FileID> &V, - const SourceManager &SM, SourceLocation L) { - FileID FID = SM.getFileID(SM.getExpansionLoc(L)); +inline unsigned AddFID(FIDMap &FIDs, SmallVectorImpl<FileID> &V, + FileID FID) { FIDMap::iterator I = FIDs.find(FID); if (I != FIDs.end()) - return; - FIDs[FID] = V.size(); + return I->second; + unsigned NewValue = V.size(); + FIDs[FID] = NewValue; V.push_back(FID); + return NewValue; } -inline unsigned GetFID(const FIDMap &FIDs, const SourceManager &SM, - SourceLocation L) { +inline unsigned AddFID(FIDMap &FIDs, SmallVectorImpl<FileID> &V, + const SourceManager &SM, SourceLocation L) { FileID FID = SM.getFileID(SM.getExpansionLoc(L)); + return AddFID(FIDs, V, FID); +} + +inline unsigned GetFID(const FIDMap &FIDs, FileID FID) { FIDMap::const_iterator I = FIDs.find(FID); assert(I != FIDs.end()); return I->second; } +inline unsigned GetFID(const FIDMap &FIDs, const SourceManager &SM, + SourceLocation L) { + FileID FID = SM.getFileID(SM.getExpansionLoc(L)); + return GetFID(FIDs, FID); +} + inline raw_ostream &Indent(raw_ostream &o, const unsigned indent) { for (unsigned i = 0; i < indent; ++i) o << ' '; diff --git a/include/clang/Basic/Sanitizers.def b/include/clang/Basic/Sanitizers.def index ae5c75fc5bbd..0287468d71f5 100644 --- a/include/clang/Basic/Sanitizers.def +++ b/include/clang/Basic/Sanitizers.def @@ -53,6 +53,9 @@ SANITIZER("kernel-hwaddress", KernelHWAddress) // MemorySanitizer SANITIZER("memory", Memory) +// Kernel MemorySanitizer (KMSAN) +SANITIZER("kernel-memory", KernelMemory) + // libFuzzer SANITIZER("fuzzer", Fuzzer) @@ -132,12 +135,32 @@ SANITIZER_GROUP("undefined", Undefined, SANITIZER_GROUP("undefined-trap", UndefinedTrap, Undefined) // ImplicitConversionSanitizer -SANITIZER("implicit-integer-truncation", ImplicitIntegerTruncation) +SANITIZER("implicit-unsigned-integer-truncation", + ImplicitUnsignedIntegerTruncation) +SANITIZER("implicit-signed-integer-truncation", ImplicitSignedIntegerTruncation) +SANITIZER_GROUP("implicit-integer-truncation", ImplicitIntegerTruncation, + ImplicitUnsignedIntegerTruncation | + ImplicitSignedIntegerTruncation) + +SANITIZER("implicit-integer-sign-change", ImplicitIntegerSignChange) + +SANITIZER_GROUP("implicit-integer-arithmetic-value-change", + ImplicitIntegerArithmeticValueChange, + ImplicitIntegerSignChange | ImplicitSignedIntegerTruncation) + +// FIXME: +//SANITIZER_GROUP("implicit-integer-conversion", ImplicitIntegerConversion, +// ImplicitIntegerArithmeticValueChange | +// ImplicitUnsignedIntegerTruncation) +//SANITIZER_GROUP("implicit-conversion", ImplicitConversion, +// ImplicitIntegerConversion) + SANITIZER_GROUP("implicit-conversion", ImplicitConversion, - ImplicitIntegerTruncation) + ImplicitIntegerArithmeticValueChange | + ImplicitUnsignedIntegerTruncation) SANITIZER_GROUP("integer", Integer, - ImplicitIntegerTruncation | IntegerDivideByZero | Shift | + ImplicitConversion | IntegerDivideByZero | Shift | SignedIntegerOverflow | UnsignedIntegerOverflow) SANITIZER("local-bounds", LocalBounds) diff --git a/include/clang/Basic/Sanitizers.h b/include/clang/Basic/Sanitizers.h index 2ecbde821599..fe9e76a1e325 100644 --- a/include/clang/Basic/Sanitizers.h +++ b/include/clang/Basic/Sanitizers.h @@ -66,7 +66,7 @@ struct SanitizerSet { /// Disable the sanitizers specified in \p K. void clear(SanitizerMask K = SanitizerKind::All) { Mask &= ~K; } - /// Returns true if at least one sanitizer is enabled. + /// Returns true if no sanitizers are enabled. bool empty() const { return Mask == 0; } /// Bitmask of enabled sanitizers. diff --git a/include/clang/Basic/SourceLocation.h b/include/clang/Basic/SourceLocation.h index 488a604a452f..014bdc3f3f0b 100644 --- a/include/clang/Basic/SourceLocation.h +++ b/include/clang/Basic/SourceLocation.h @@ -220,6 +220,10 @@ public: bool operator!=(const SourceRange &X) const { return B != X.B || E != X.E; } + + void print(raw_ostream &OS, const SourceManager &SM) const; + std::string printToString(const SourceManager &SM) const; + void dump(const SourceManager &SM) const; }; /// Represents a character-granular source range. diff --git a/include/clang/Basic/SourceManager.h b/include/clang/Basic/SourceManager.h index af7dbbc13ca7..dcc4a37e239c 100644 --- a/include/clang/Basic/SourceManager.h +++ b/include/clang/Basic/SourceManager.h @@ -449,7 +449,7 @@ namespace SrcMgr { } static SLocEntry get(unsigned Offset, const FileInfo &FI) { - assert(!(Offset & (1 << 31)) && "Offset is too large"); + assert(!(Offset & (1u << 31)) && "Offset is too large"); SLocEntry E; E.Offset = Offset; E.IsExpansion = false; @@ -458,7 +458,7 @@ namespace SrcMgr { } static SLocEntry get(unsigned Offset, const ExpansionInfo &Expansion) { - assert(!(Offset & (1 << 31)) && "Offset is too large"); + assert(!(Offset & (1u << 31)) && "Offset is too large"); SLocEntry E; E.Offset = Offset; E.IsExpansion = true; @@ -1024,13 +1024,14 @@ public: /// Set the number of FileIDs (files and macros) that were created /// during preprocessing of \p FID, including it. - void setNumCreatedFIDsForFileID(FileID FID, unsigned NumFIDs) const { + void setNumCreatedFIDsForFileID(FileID FID, unsigned NumFIDs, + bool Force = false) const { bool Invalid = false; const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid); if (Invalid || !Entry.isFile()) return; - assert(Entry.getFile().NumCreatedFIDs == 0 && "Already set!"); + assert((Force || Entry.getFile().NumCreatedFIDs == 0) && "Already set!"); const_cast<SrcMgr::FileInfo &>(Entry.getFile()).NumCreatedFIDs = NumFIDs; } @@ -1428,6 +1429,18 @@ public: return getFileID(Loc) == getMainFileID(); } + /// Returns whether \p Loc is located in a <built-in> file. + bool isWrittenInBuiltinFile(SourceLocation Loc) const { + StringRef Filename(getPresumedLoc(Loc).getFilename()); + return Filename.equals("<built-in>"); + } + + /// Returns whether \p Loc is located in a <command line> file. + bool isWrittenInCommandLineFile(SourceLocation Loc) const { + StringRef Filename(getPresumedLoc(Loc).getFilename()); + return Filename.equals("<command line>"); + } + /// Returns if a SourceLocation is in a system header. bool isInSystemHeader(SourceLocation Loc) const { return isSystem(getFileCharacteristic(Loc)); diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index cd8213f6cfd4..0af01e45437d 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -251,6 +251,7 @@ namespace clang { CC_Swift, // __attribute__((swiftcall)) CC_PreserveMost, // __attribute__((preserve_most)) CC_PreserveAll, // __attribute__((preserve_all)) + CC_AArch64VectorCall, // __attribute__((aarch64_vector_pcs)) }; /// Checks whether the given calling convention supports variadic diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index 1517d741cb3c..9054fb11a6ff 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -93,6 +93,10 @@ def VAArgExpr : DStmt<Expr>; def GenericSelectionExpr : DStmt<Expr>; def PseudoObjectExpr : DStmt<Expr>; +// Wrapper expressions +def FullExpr : DStmt<Expr, 1>; +def ConstantExpr : DStmt<FullExpr>; + // Atomic expressions def AtomicExpr : DStmt<Expr>; @@ -131,7 +135,7 @@ def DependentScopeDeclRefExpr : DStmt<Expr>; def CXXConstructExpr : DStmt<Expr>; def CXXInheritedCtorInitExpr : DStmt<Expr>; def CXXBindTemporaryExpr : DStmt<Expr>; -def ExprWithCleanups : DStmt<Expr>; +def ExprWithCleanups : DStmt<FullExpr>; def CXXTemporaryObjectExpr : DStmt<CXXConstructExpr>; def CXXUnresolvedConstructExpr : DStmt<Expr>; def CXXDependentScopeMemberExpr : DStmt<Expr>; diff --git a/include/clang/Basic/TargetBuiltins.h b/include/clang/Basic/TargetBuiltins.h index 75a3811007cc..ab4b1c43f7cf 100644 --- a/include/clang/Basic/TargetBuiltins.h +++ b/include/clang/Basic/TargetBuiltins.h @@ -150,16 +150,6 @@ namespace clang { }; } - /// Nios2 builtins - namespace Nios2 { - enum { - LastTIBuiltin = clang::Builtin::FirstTSBuiltin - 1, -#define BUILTIN(ID, TYPE, ATTRS) BI##ID, -#include "clang/Basic/BuiltinsNios2.def" - LastTSBuiltin - }; - } - /// MIPS builtins namespace Mips { enum { diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index 958b9106bc99..786b1c251ca8 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -312,6 +312,14 @@ public: } } + /// In the event this target uses the same number of fractional bits for its + /// unsigned types as it does with its signed counterparts, there will be + /// exactly one bit of padding. + /// Return true if unsigned fixed point types have padding for this target. + bool doUnsignedFixedPointTypesHavePadding() const { + return PaddingOnUnsignedFixedPoint; + } + /// Return the width (in bits) of the specified integer type enum. /// /// For example, SignedInt -> getIntWidth(). @@ -1074,9 +1082,15 @@ public: return false; } - /// Identify whether this taret supports multiversioning of functions, + /// Identify whether this target supports multiversioning of functions, /// which requires support for cpu_supports and cpu_is functionality. - virtual bool supportsMultiVersioning() const { return false; } + bool supportsMultiVersioning() const { + return getTriple().getArch() == llvm::Triple::x86 || + getTriple().getArch() == llvm::Triple::x86_64; + } + + /// Identify whether this target supports IFuncs. + bool supportsIFunc() const { return getTriple().isOSBinFormatELF(); } // Validate the contents of the __builtin_cpu_supports(const char*) // argument. @@ -1168,6 +1182,18 @@ public: const LangASMap &getAddressSpaceMap() const { return *AddrSpaceMap; } + /// Map from the address space field in builtin description strings to the + /// language address space. + virtual LangAS getOpenCLBuiltinAddressSpace(unsigned AS) const { + return getLangASFromTargetAS(AS); + } + + /// Map from the address space field in builtin description strings to the + /// language address space. + virtual LangAS getCUDABuiltinAddressSpace(unsigned AS) const { + return getLangASFromTargetAS(AS); + } + /// Return an AST address space which can be used opportunistically /// for constant global memory. It must be possible to convert pointers into /// this address space to LangAS::Default. If no such address space exists, @@ -1295,6 +1321,12 @@ public: return None; } + /// \returns The version of the SDK which was used during the compilation if + /// one was specified, or an empty version otherwise. + 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; diff --git a/include/clang/Basic/TargetOptions.h b/include/clang/Basic/TargetOptions.h index 31a674287915..fcccc5331a97 100644 --- a/include/clang/Basic/TargetOptions.h +++ b/include/clang/Basic/TargetOptions.h @@ -15,10 +15,11 @@ #ifndef LLVM_CLANG_BASIC_TARGETOPTIONS_H #define LLVM_CLANG_BASIC_TARGETOPTIONS_H -#include <string> -#include <vector> #include "clang/Basic/OpenCLOptions.h" +#include "llvm/Support/VersionTuple.h" #include "llvm/Target/TargetOptions.h" +#include <string> +#include <vector> namespace clang { @@ -67,6 +68,15 @@ public: /// \brief If enabled, use 32-bit pointers for accessing const/local/shared /// address space. bool NVPTXUseShortPointers = false; + + // The code model to be used as specified by the user. Corresponds to + // CodeModel::Model enum defined in include/llvm/Support/CodeGen.h, plus + // "default" for the case when the user has not explicitly specified a + // code model. + std::string CodeModel; + + /// The version of the SDK which was used during the compilation. + llvm::VersionTuple SDKVersion; }; } // end namespace clang diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index 30cb022f1cba..e4616c9a6ab4 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -57,11 +57,8 @@ #ifndef CXX_KEYWORD_OPERATOR #define CXX_KEYWORD_OPERATOR(X,Y) #endif -#ifndef OBJC1_AT_KEYWORD -#define OBJC1_AT_KEYWORD(X) -#endif -#ifndef OBJC2_AT_KEYWORD -#define OBJC2_AT_KEYWORD(X) +#ifndef OBJC_AT_KEYWORD +#define OBJC_AT_KEYWORD(X) #endif #ifndef TESTING_KEYWORD #define TESTING_KEYWORD(X, L) KEYWORD(X, L) @@ -579,15 +576,15 @@ ALIAS("__fp16", half , KEYALL) KEYWORD(half , HALFSUPPORT) // Objective-C ARC keywords. -KEYWORD(__bridge , KEYARC) -KEYWORD(__bridge_transfer , KEYARC) -KEYWORD(__bridge_retained , KEYARC) -KEYWORD(__bridge_retain , KEYARC) +KEYWORD(__bridge , KEYOBJC) +KEYWORD(__bridge_transfer , KEYOBJC) +KEYWORD(__bridge_retained , KEYOBJC) +KEYWORD(__bridge_retain , KEYOBJC) // Objective-C keywords. -KEYWORD(__covariant , KEYOBJC2) -KEYWORD(__contravariant , KEYOBJC2) -KEYWORD(__kindof , KEYOBJC2) +KEYWORD(__covariant , KEYOBJC) +KEYWORD(__contravariant , KEYOBJC) +KEYWORD(__kindof , KEYOBJC) // Alternate spelling for various tokens. There are GCC extensions in all // languages, but should not be disabled in strict conformance mode. @@ -677,34 +674,34 @@ TESTING_KEYWORD(__unknown_anytype , KEYALL) // These have meaning after an '@' in Objective-C mode. These define enums in // the tok::objc_* namespace. -OBJC1_AT_KEYWORD(not_keyword) -OBJC1_AT_KEYWORD(class) -OBJC1_AT_KEYWORD(compatibility_alias) -OBJC1_AT_KEYWORD(defs) -OBJC1_AT_KEYWORD(encode) -OBJC1_AT_KEYWORD(end) -OBJC1_AT_KEYWORD(implementation) -OBJC1_AT_KEYWORD(interface) -OBJC1_AT_KEYWORD(private) -OBJC1_AT_KEYWORD(protected) -OBJC1_AT_KEYWORD(protocol) -OBJC1_AT_KEYWORD(public) -OBJC1_AT_KEYWORD(selector) -OBJC1_AT_KEYWORD(throw) -OBJC1_AT_KEYWORD(try) -OBJC1_AT_KEYWORD(catch) -OBJC1_AT_KEYWORD(finally) -OBJC1_AT_KEYWORD(synchronized) -OBJC1_AT_KEYWORD(autoreleasepool) - -OBJC2_AT_KEYWORD(property) -OBJC2_AT_KEYWORD(package) -OBJC2_AT_KEYWORD(required) -OBJC2_AT_KEYWORD(optional) -OBJC2_AT_KEYWORD(synthesize) -OBJC2_AT_KEYWORD(dynamic) -OBJC2_AT_KEYWORD(import) -OBJC2_AT_KEYWORD(available) +OBJC_AT_KEYWORD(not_keyword) +OBJC_AT_KEYWORD(class) +OBJC_AT_KEYWORD(compatibility_alias) +OBJC_AT_KEYWORD(defs) +OBJC_AT_KEYWORD(encode) +OBJC_AT_KEYWORD(end) +OBJC_AT_KEYWORD(implementation) +OBJC_AT_KEYWORD(interface) +OBJC_AT_KEYWORD(private) +OBJC_AT_KEYWORD(protected) +OBJC_AT_KEYWORD(protocol) +OBJC_AT_KEYWORD(public) +OBJC_AT_KEYWORD(selector) +OBJC_AT_KEYWORD(throw) +OBJC_AT_KEYWORD(try) +OBJC_AT_KEYWORD(catch) +OBJC_AT_KEYWORD(finally) +OBJC_AT_KEYWORD(synchronized) +OBJC_AT_KEYWORD(autoreleasepool) + +OBJC_AT_KEYWORD(property) +OBJC_AT_KEYWORD(package) +OBJC_AT_KEYWORD(required) +OBJC_AT_KEYWORD(optional) +OBJC_AT_KEYWORD(synthesize) +OBJC_AT_KEYWORD(dynamic) +OBJC_AT_KEYWORD(import) +OBJC_AT_KEYWORD(available) // TODO: What to do about context-sensitive keywords like: // bycopy/byref/in/inout/oneway/out? @@ -780,6 +777,11 @@ ANNOTATION(pragma_redefine_extname) // handles them. ANNOTATION(pragma_fp_contract) +// Annotation for #pragma STDC FENV_ACCESS +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_fenv_access) + // Annotation for #pragma pointers_to_members... // The lexer produces these so that they only take effect when the parser // handles them. @@ -823,8 +825,7 @@ ANNOTATION(module_end) #undef ANNOTATION #undef TESTING_KEYWORD -#undef OBJC2_AT_KEYWORD -#undef OBJC1_AT_KEYWORD +#undef OBJC_AT_KEYWORD #undef CXX_KEYWORD_OPERATOR #undef PPKEYWORD #undef ALIAS diff --git a/include/clang/Basic/TokenKinds.h b/include/clang/Basic/TokenKinds.h index fb4b5252b70b..e046f0027044 100644 --- a/include/clang/Basic/TokenKinds.h +++ b/include/clang/Basic/TokenKinds.h @@ -39,8 +39,7 @@ enum PPKeywordKind { /// Provides a namespace for Objective-C keywords which start with /// an '@'. enum ObjCKeywordKind { -#define OBJC1_AT_KEYWORD(X) objc_##X, -#define OBJC2_AT_KEYWORD(X) objc_##X, +#define OBJC_AT_KEYWORD(X) objc_##X, #include "clang/Basic/TokenKinds.def" NUM_OBJC_KEYWORDS }; diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h index bdb426834a8c..8b8b2cbbd4a7 100644 --- a/include/clang/Basic/TypeTraits.h +++ b/include/clang/Basic/TypeTraits.h @@ -96,9 +96,15 @@ namespace clang { /// Names for the "expression or type" traits. enum UnaryExprOrTypeTrait { UETT_SizeOf, + /// Used for C's _Alignof and C++'s alignof. + /// _Alignof and alignof return the required ABI alignment. UETT_AlignOf, UETT_VecStep, UETT_OpenMPRequiredSimdAlign, + /// Used for GCC's __alignof. + /// __alignof returns the preferred alignment of a type, the alignment + /// clang will attempt to give an object of the type if allowed by ABI. + UETT_PreferredAlignOf, }; } diff --git a/include/clang/Basic/VirtualFileSystem.h b/include/clang/Basic/VirtualFileSystem.h deleted file mode 100644 index 2480b91123c1..000000000000 --- a/include/clang/Basic/VirtualFileSystem.h +++ /dev/null @@ -1,454 +0,0 @@ -//===- VirtualFileSystem.h - Virtual File System Layer ----------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -/// \file -/// Defines the virtual file system interface vfs::FileSystem. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CLANG_BASIC_VIRTUALFILESYSTEM_H -#define LLVM_CLANG_BASIC_VIRTUALFILESYSTEM_H - -#include "clang/Basic/LLVM.h" -#include "llvm/ADT/IntrusiveRefCntPtr.h" -#include "llvm/ADT/None.h" -#include "llvm/ADT/Optional.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/ADT/Twine.h" -#include "llvm/Support/Chrono.h" -#include "llvm/Support/ErrorOr.h" -#include "llvm/Support/FileSystem.h" -#include "llvm/Support/SourceMgr.h" -#include <cassert> -#include <cstdint> -#include <ctime> -#include <memory> -#include <stack> -#include <string> -#include <system_error> -#include <utility> -#include <vector> - -namespace llvm { - -class MemoryBuffer; - -} // namespace llvm - -namespace clang { -namespace vfs { - -/// The result of a \p status operation. -class Status { - std::string Name; - llvm::sys::fs::UniqueID UID; - llvm::sys::TimePoint<> MTime; - uint32_t User; - uint32_t Group; - uint64_t Size; - llvm::sys::fs::file_type Type = llvm::sys::fs::file_type::status_error; - llvm::sys::fs::perms Perms; - -public: - // FIXME: remove when files support multiple names - bool IsVFSMapped = false; - - Status() = default; - Status(const llvm::sys::fs::file_status &Status); - Status(StringRef Name, llvm::sys::fs::UniqueID UID, - llvm::sys::TimePoint<> MTime, uint32_t User, uint32_t Group, - uint64_t Size, llvm::sys::fs::file_type Type, - llvm::sys::fs::perms Perms); - - /// Get a copy of a Status with a different name. - static Status copyWithNewName(const Status &In, StringRef NewName); - static Status copyWithNewName(const llvm::sys::fs::file_status &In, - StringRef NewName); - - /// Returns the name that should be used for this file or directory. - StringRef getName() const { return Name; } - - /// @name Status interface from llvm::sys::fs - /// @{ - llvm::sys::fs::file_type getType() const { return Type; } - llvm::sys::fs::perms getPermissions() const { return Perms; } - llvm::sys::TimePoint<> getLastModificationTime() const { return MTime; } - llvm::sys::fs::UniqueID getUniqueID() const { return UID; } - uint32_t getUser() const { return User; } - uint32_t getGroup() const { return Group; } - uint64_t getSize() const { return Size; } - /// @} - /// @name Status queries - /// These are static queries in llvm::sys::fs. - /// @{ - bool equivalent(const Status &Other) const; - bool isDirectory() const; - bool isRegularFile() const; - bool isOther() const; - bool isSymlink() const; - bool isStatusKnown() const; - bool exists() const; - /// @} -}; - -/// Represents an open file. -class File { -public: - /// Destroy the file after closing it (if open). - /// Sub-classes should generally call close() inside their destructors. We - /// cannot do that from the base class, since close is virtual. - virtual ~File(); - - /// Get the status of the file. - virtual llvm::ErrorOr<Status> status() = 0; - - /// Get the name of the file - virtual llvm::ErrorOr<std::string> getName() { - if (auto Status = status()) - return Status->getName().str(); - else - return Status.getError(); - } - - /// Get the contents of the file as a \p MemoryBuffer. - virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> - getBuffer(const Twine &Name, int64_t FileSize = -1, - bool RequiresNullTerminator = true, bool IsVolatile = false) = 0; - - /// Closes the file. - virtual std::error_code close() = 0; -}; - -namespace detail { - -/// An interface for virtual file systems to provide an iterator over the -/// (non-recursive) contents of a directory. -struct DirIterImpl { - virtual ~DirIterImpl(); - - /// Sets \c CurrentEntry to the next entry in the directory on success, - /// or returns a system-defined \c error_code. - virtual std::error_code increment() = 0; - - Status CurrentEntry; -}; - -} // namespace detail - -/// An input iterator over the entries in a virtual path, similar to -/// llvm::sys::fs::directory_iterator. -class directory_iterator { - std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy - -public: - directory_iterator(std::shared_ptr<detail::DirIterImpl> I) - : Impl(std::move(I)) { - assert(Impl.get() != nullptr && "requires non-null implementation"); - if (!Impl->CurrentEntry.isStatusKnown()) - Impl.reset(); // Normalize the end iterator to Impl == nullptr. - } - - /// Construct an 'end' iterator. - directory_iterator() = default; - - /// Equivalent to operator++, with an error code. - directory_iterator &increment(std::error_code &EC) { - assert(Impl && "attempting to increment past end"); - EC = Impl->increment(); - if (!Impl->CurrentEntry.isStatusKnown()) - Impl.reset(); // Normalize the end iterator to Impl == nullptr. - return *this; - } - - const Status &operator*() const { return Impl->CurrentEntry; } - const Status *operator->() const { return &Impl->CurrentEntry; } - - bool operator==(const directory_iterator &RHS) const { - if (Impl && RHS.Impl) - return Impl->CurrentEntry.equivalent(RHS.Impl->CurrentEntry); - return !Impl && !RHS.Impl; - } - bool operator!=(const directory_iterator &RHS) const { - return !(*this == RHS); - } -}; - -class FileSystem; - -/// An input iterator over the recursive contents of a virtual path, -/// similar to llvm::sys::fs::recursive_directory_iterator. -class recursive_directory_iterator { - using IterState = - std::stack<directory_iterator, std::vector<directory_iterator>>; - - FileSystem *FS; - std::shared_ptr<IterState> State; // Input iterator semantics on copy. - -public: - recursive_directory_iterator(FileSystem &FS, const Twine &Path, - std::error_code &EC); - - /// Construct an 'end' iterator. - recursive_directory_iterator() = default; - - /// Equivalent to operator++, with an error code. - recursive_directory_iterator &increment(std::error_code &EC); - - const Status &operator*() const { return *State->top(); } - const Status *operator->() const { return &*State->top(); } - - bool operator==(const recursive_directory_iterator &Other) const { - return State == Other.State; // identity - } - bool operator!=(const recursive_directory_iterator &RHS) const { - return !(*this == RHS); - } - - /// Gets the current level. Starting path is at level 0. - int level() const { - assert(!State->empty() && "Cannot get level without any iteration state"); - return State->size()-1; - } -}; - -/// The virtual file system interface. -class FileSystem : public llvm::ThreadSafeRefCountedBase<FileSystem> { -public: - virtual ~FileSystem(); - - /// Get the status of the entry at \p Path, if one exists. - virtual llvm::ErrorOr<Status> status(const Twine &Path) = 0; - - /// Get a \p File object for the file at \p Path, if one exists. - virtual llvm::ErrorOr<std::unique_ptr<File>> - openFileForRead(const Twine &Path) = 0; - - /// This is a convenience method that opens a file, gets its content and then - /// closes the file. - llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> - getBufferForFile(const Twine &Name, int64_t FileSize = -1, - bool RequiresNullTerminator = true, bool IsVolatile = false); - - /// Get a directory_iterator for \p Dir. - /// \note The 'end' iterator is directory_iterator(). - virtual directory_iterator dir_begin(const Twine &Dir, - std::error_code &EC) = 0; - - /// Set the working directory. This will affect all following operations on - /// this file system and may propagate down for nested file systems. - virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) = 0; - - /// Get the working directory of this file system. - virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const = 0; - - /// Gets real path of \p Path e.g. collapse all . and .. patterns, resolve - /// symlinks. For real file system, this uses `llvm::sys::fs::real_path`. - /// This returns errc::operation_not_permitted if not implemented by subclass. - virtual std::error_code getRealPath(const Twine &Path, - SmallVectorImpl<char> &Output) const; - - /// Check whether a file exists. Provided for convenience. - bool exists(const Twine &Path); - - /// Make \a Path an absolute path. - /// - /// Makes \a Path absolute using the current directory if it is not already. - /// An empty \a Path will result in the current directory. - /// - /// /absolute/path => /absolute/path - /// relative/../path => <current-directory>/relative/../path - /// - /// \param Path A path that is modified to be an absolute path. - /// \returns success if \a path has been made absolute, otherwise a - /// platform-specific error_code. - std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const; -}; - -/// Gets an \p vfs::FileSystem for the 'real' file system, as seen by -/// the operating system. -IntrusiveRefCntPtr<FileSystem> getRealFileSystem(); - -/// A file system that allows overlaying one \p AbstractFileSystem on top -/// of another. -/// -/// Consists of a stack of >=1 \p FileSystem objects, which are treated as being -/// one merged file system. When there is a directory that exists in more than -/// one file system, the \p OverlayFileSystem contains a directory containing -/// the union of their contents. The attributes (permissions, etc.) of the -/// top-most (most recently added) directory are used. When there is a file -/// that exists in more than one file system, the file in the top-most file -/// system overrides the other(s). -class OverlayFileSystem : public FileSystem { - using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>; - - /// The stack of file systems, implemented as a list in order of - /// their addition. - FileSystemList FSList; - -public: - OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> Base); - - /// Pushes a file system on top of the stack. - void pushOverlay(IntrusiveRefCntPtr<FileSystem> FS); - - llvm::ErrorOr<Status> status(const Twine &Path) override; - llvm::ErrorOr<std::unique_ptr<File>> - openFileForRead(const Twine &Path) override; - directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override; - llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override; - std::error_code setCurrentWorkingDirectory(const Twine &Path) override; - std::error_code getRealPath(const Twine &Path, - SmallVectorImpl<char> &Output) const override; - - using iterator = FileSystemList::reverse_iterator; - using const_iterator = FileSystemList::const_reverse_iterator; - - /// Get an iterator pointing to the most recently added file system. - iterator overlays_begin() { return FSList.rbegin(); } - const_iterator overlays_begin() const { return FSList.rbegin(); } - - /// Get an iterator pointing one-past the least recently added file - /// system. - iterator overlays_end() { return FSList.rend(); } - const_iterator overlays_end() const { return FSList.rend(); } -}; - -namespace detail { - -class InMemoryDirectory; - -} // namespace detail - -/// An in-memory file system. -class InMemoryFileSystem : public FileSystem { - std::unique_ptr<detail::InMemoryDirectory> Root; - std::string WorkingDirectory; - bool UseNormalizedPaths = true; - -public: - explicit InMemoryFileSystem(bool UseNormalizedPaths = true); - ~InMemoryFileSystem() override; - - /// Add a file containing a buffer or a directory to the VFS with a - /// path. The VFS owns the buffer. If present, User, Group, Type - /// and Perms apply to the newly-created file or directory. - /// \return true if the file or directory was successfully added, - /// false if the file or directory already exists in the file system with - /// different contents. - bool addFile(const Twine &Path, time_t ModificationTime, - std::unique_ptr<llvm::MemoryBuffer> Buffer, - Optional<uint32_t> User = None, Optional<uint32_t> Group = None, - Optional<llvm::sys::fs::file_type> Type = None, - Optional<llvm::sys::fs::perms> Perms = None); - - /// Add a buffer to the VFS with a path. The VFS does not own the buffer. - /// If present, User, Group, Type and Perms apply to the newly-created file - /// or directory. - /// \return true if the file or directory was successfully added, - /// false if the file or directory already exists in the file system with - /// different contents. - bool addFileNoOwn(const Twine &Path, time_t ModificationTime, - llvm::MemoryBuffer *Buffer, - Optional<uint32_t> User = None, - Optional<uint32_t> Group = None, - Optional<llvm::sys::fs::file_type> Type = None, - Optional<llvm::sys::fs::perms> Perms = None); - - std::string toString() const; - - /// Return true if this file system normalizes . and .. in paths. - bool useNormalizedPaths() const { return UseNormalizedPaths; } - - llvm::ErrorOr<Status> status(const Twine &Path) override; - llvm::ErrorOr<std::unique_ptr<File>> - openFileForRead(const Twine &Path) override; - directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override; - - llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override { - return WorkingDirectory; - } - /// Canonicalizes \p Path by combining with the current working - /// directory and normalizing the path (e.g. remove dots). If the current - /// working directory is not set, this returns errc::operation_not_permitted. - /// - /// This doesn't resolve symlinks as they are not supported in in-memory file - /// system. - std::error_code getRealPath(const Twine &Path, - SmallVectorImpl<char> &Output) const override; - - std::error_code setCurrentWorkingDirectory(const Twine &Path) override; -}; - -/// Get a globally unique ID for a virtual file or directory. -llvm::sys::fs::UniqueID getNextVirtualUniqueID(); - -/// Gets a \p FileSystem for a virtual file system described in YAML -/// format. -IntrusiveRefCntPtr<FileSystem> -getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer, - llvm::SourceMgr::DiagHandlerTy DiagHandler, - StringRef YAMLFilePath, - void *DiagContext = nullptr, - IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem()); - -struct YAMLVFSEntry { - template <typename T1, typename T2> YAMLVFSEntry(T1 &&VPath, T2 &&RPath) - : VPath(std::forward<T1>(VPath)), RPath(std::forward<T2>(RPath)) {} - std::string VPath; - std::string RPath; -}; - -/// Collect all pairs of <virtual path, real path> entries from the -/// \p YAMLFilePath. This is used by the module dependency collector to forward -/// the entries into the reproducer output VFS YAML file. -void collectVFSFromYAML( - std::unique_ptr<llvm::MemoryBuffer> Buffer, - llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, - SmallVectorImpl<YAMLVFSEntry> &CollectedEntries, - void *DiagContext = nullptr, - IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem()); - -class YAMLVFSWriter { - std::vector<YAMLVFSEntry> Mappings; - Optional<bool> IsCaseSensitive; - Optional<bool> IsOverlayRelative; - Optional<bool> UseExternalNames; - Optional<bool> IgnoreNonExistentContents; - std::string OverlayDir; - -public: - YAMLVFSWriter() = default; - - void addFileMapping(StringRef VirtualPath, StringRef RealPath); - - void setCaseSensitivity(bool CaseSensitive) { - IsCaseSensitive = CaseSensitive; - } - - void setUseExternalNames(bool UseExtNames) { - UseExternalNames = UseExtNames; - } - - void setIgnoreNonExistentContents(bool IgnoreContents) { - IgnoreNonExistentContents = IgnoreContents; - } - - void setOverlayDir(StringRef OverlayDirectory) { - IsOverlayRelative = true; - OverlayDir.assign(OverlayDirectory.str()); - } - - void write(llvm::raw_ostream &OS); -}; - -} // namespace vfs -} // namespace clang - -#endif // LLVM_CLANG_BASIC_VIRTUALFILESYSTEM_H diff --git a/include/clang/Basic/X86Target.def b/include/clang/Basic/X86Target.def index d2d2540e5005..8c203c4db21e 100644 --- a/include/clang/Basic/X86Target.def +++ b/include/clang/Basic/X86Target.def @@ -154,6 +154,10 @@ PROC_WITH_FEAT(SkylakeClient, "skylake", PROC_64_BIT, FEATURE_AVX2) PROC_WITH_FEAT(SkylakeServer, "skylake-avx512", PROC_64_BIT, FEATURE_AVX512F) PROC_ALIAS(SkylakeServer, "skx") +/// \name Cascadelake Server +/// Cascadelake Server microarchitecture based processors. +PROC_WITH_FEAT(Cascadelake, "cascadelake", PROC_64_BIT, FEATURE_AVX512VNNI) + /// \name Cannonlake Client /// Cannonlake client microarchitecture based processors. PROC_WITH_FEAT(Cannonlake, "cannonlake", PROC_64_BIT, FEATURE_AVX512VBMI) @@ -283,6 +287,11 @@ FEATURE(FEATURE_AVX512IFMA) FEATURE(FEATURE_AVX5124VNNIW) FEATURE(FEATURE_AVX5124FMAPS) FEATURE(FEATURE_AVX512VPOPCNTDQ) +FEATURE(FEATURE_AVX512VBMI2) +FEATURE(FEATURE_GFNI) +FEATURE(FEATURE_VPCLMULQDQ) +FEATURE(FEATURE_AVX512VNNI) +FEATURE(FEATURE_AVX512BITALG) // FIXME: When commented out features are supported in LLVM, enable them here. diff --git a/include/clang/Basic/XRayInstr.h b/include/clang/Basic/XRayInstr.h index 13c3032a5cca..6efefcb33ac8 100644 --- a/include/clang/Basic/XRayInstr.h +++ b/include/clang/Basic/XRayInstr.h @@ -60,6 +60,8 @@ struct XRayInstrSet { bool empty() const { return Mask == 0; } + bool full() const { return Mask == XRayInstrKind::All; } + XRayInstrMask Mask = 0; }; diff --git a/include/clang/Basic/arm_neon.td b/include/clang/Basic/arm_neon.td index c35336166c39..af049be7e295 100644 --- a/include/clang/Basic/arm_neon.td +++ b/include/clang/Basic/arm_neon.td @@ -206,6 +206,15 @@ def OP_DOT_LNQ : Op<(call "vdot", $p0, $p1, (bitcast $p1, (splat(bitcast "uint32x4_t", $p2), $p3)))>; +def OP_FMLAL_LN : Op<(call "vfmlal_low", $p0, $p1, + (dup_typed $p1, (call "vget_lane", $p2, $p3)))>; +def OP_FMLSL_LN : Op<(call "vfmlsl_low", $p0, $p1, + (dup_typed $p1, (call "vget_lane", $p2, $p3)))>; +def OP_FMLAL_LN_Hi : Op<(call "vfmlal_high", $p0, $p1, + (dup_typed $p1, (call "vget_lane", $p2, $p3)))>; +def OP_FMLSL_LN_Hi : Op<(call "vfmlsl_high", $p0, $p1, + (dup_typed $p1, (call "vget_lane", $p2, $p3)))>; + //===----------------------------------------------------------------------===// // Instructions //===----------------------------------------------------------------------===// @@ -337,48 +346,78 @@ def VSLI_N : WInst<"vsli_n", "dddi", //////////////////////////////////////////////////////////////////////////////// // E.3.14 Loads and stores of a single vector def VLD1 : WInst<"vld1", "dc", - "QUcQUsQUiQUlQcQsQiQlQhQfQPcQPsUcUsUiUlcsilhfPcPs">; + "QUcQUsQUiQUlQcQsQiQlQfQPcQPsUcUsUiUlcsilfPcPs">; def VLD1_X2 : WInst<"vld1_x2", "2c", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VLD1_X3 : WInst<"vld1_x3", "3c", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VLD1_X4 : WInst<"vld1_x4", "4c", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VLD1_LANE : WInst<"vld1_lane", "dcdi", - "QUcQUsQUiQUlQcQsQiQlQhQfQPcQPsUcUsUiUlcsilhfPcPs">; + "QUcQUsQUiQUlQcQsQiQlQfQPcQPsUcUsUiUlcsilfPcPs">; def VLD1_DUP : WInst<"vld1_dup", "dc", - "QUcQUsQUiQUlQcQsQiQlQhQfQPcQPsUcUsUiUlcsilhfPcPs">; + "QUcQUsQUiQUlQcQsQiQlQfQPcQPsUcUsUiUlcsilfPcPs">; def VST1 : WInst<"vst1", "vpd", - "QUcQUsQUiQUlQcQsQiQlQhQfQPcQPsUcUsUiUlcsilhfPcPs">; + "QUcQUsQUiQUlQcQsQiQlQfQPcQPsUcUsUiUlcsilfPcPs">; def VST1_X2 : WInst<"vst1_x2", "vp2", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VST1_X3 : WInst<"vst1_x3", "vp3", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VST1_X4 : WInst<"vst1_x4", "vp4", - "cfhilsUcUiUlUsQcQfQhQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; + "cfilsUcUiUlUsQcQfQiQlQsQUcQUiQUlQUsPcPsQPcQPs">; def VST1_LANE : WInst<"vst1_lane", "vpdi", - "QUcQUsQUiQUlQcQsQiQlQhQfQPcQPsUcUsUiUlcsilhfPcPs">; + "QUcQUsQUiQUlQcQsQiQlQfQPcQPsUcUsUiUlcsilfPcPs">; +let ArchGuard = "(__ARM_FP & 2)" in { +def VLD1_F16 : WInst<"vld1", "dc", "hQh">; +def VLD1_X2_F16 : WInst<"vld1_x2", "2c", "hQh">; +def VLD1_X3_F16 : WInst<"vld1_x3", "3c", "hQh">; +def VLD1_X4_F16 : WInst<"vld1_x4", "4c", "hQh">; +def VLD1_LANE_F16 : WInst<"vld1_lane", "dcdi", "hQh">; +def VLD1_DUP_F16 : WInst<"vld1_dup", "dc", "hQh">; +def VST1_F16 : WInst<"vst1", "vpd", "hQh">; +def VST1_X2_F16 : WInst<"vst1_x2", "vp2", "hQh">; +def VST1_X3_F16 : WInst<"vst1_x3", "vp3", "hQh">; +def VST1_X4_F16 : WInst<"vst1_x4", "vp4", "hQh">; +def VST1_LANE_F16 : WInst<"vst1_lane", "vpdi", "hQh">; +} //////////////////////////////////////////////////////////////////////////////// // E.3.15 Loads and stores of an N-element structure -def VLD2 : WInst<"vld2", "2c", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; -def VLD3 : WInst<"vld3", "3c", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; -def VLD4 : WInst<"vld4", "4c", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; +def VLD2 : WInst<"vld2", "2c", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; +def VLD3 : WInst<"vld3", "3c", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; +def VLD4 : WInst<"vld4", "4c", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; def VLD2_DUP : WInst<"vld2_dup", "2c", - "UcUsUiUlcsilhfPcPsQcQfQhQiQlQsQPcQPsQUcQUiQUlQUs">; + "UcUsUiUlcsilfPcPsQcQfQiQlQsQPcQPsQUcQUiQUlQUs">; def VLD3_DUP : WInst<"vld3_dup", "3c", - "UcUsUiUlcsilhfPcPsQcQfQhQiQlQsQPcQPsQUcQUiQUlQUs">; + "UcUsUiUlcsilfPcPsQcQfQiQlQsQPcQPsQUcQUiQUlQUs">; def VLD4_DUP : WInst<"vld4_dup", "4c", - "UcUsUiUlcsilhfPcPsQcQfQhQiQlQsQPcQPsQUcQUiQUlQUs">; -def VLD2_LANE : WInst<"vld2_lane", "2c2i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; -def VLD3_LANE : WInst<"vld3_lane", "3c3i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; -def VLD4_LANE : WInst<"vld4_lane", "4c4i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; -def VST2 : WInst<"vst2", "vp2", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; -def VST3 : WInst<"vst3", "vp3", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; -def VST4 : WInst<"vst4", "vp4", "QUcQUsQUiQcQsQiQhQfQPcQPsUcUsUiUlcsilhfPcPs">; -def VST2_LANE : WInst<"vst2_lane", "vp2i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; -def VST3_LANE : WInst<"vst3_lane", "vp3i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; -def VST4_LANE : WInst<"vst4_lane", "vp4i", "QUsQUiQsQiQhQfQPsUcUsUicsihfPcPs">; + "UcUsUiUlcsilfPcPsQcQfQiQlQsQPcQPsQUcQUiQUlQUs">; +def VLD2_LANE : WInst<"vld2_lane", "2c2i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +def VLD3_LANE : WInst<"vld3_lane", "3c3i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +def VLD4_LANE : WInst<"vld4_lane", "4c4i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +def VST2 : WInst<"vst2", "vp2", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; +def VST3 : WInst<"vst3", "vp3", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; +def VST4 : WInst<"vst4", "vp4", "QUcQUsQUiQcQsQiQfQPcQPsUcUsUiUlcsilfPcPs">; +def VST2_LANE : WInst<"vst2_lane", "vp2i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +def VST3_LANE : WInst<"vst3_lane", "vp3i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +def VST4_LANE : WInst<"vst4_lane", "vp4i", "QUsQUiQsQiQfQPsUcUsUicsifPcPs">; +let ArchGuard = "(__ARM_FP & 2)" in { +def VLD2_F16 : WInst<"vld2", "2c", "hQh">; +def VLD3_F16 : WInst<"vld3", "3c", "hQh">; +def VLD4_F16 : WInst<"vld4", "4c", "hQh">; +def VLD2_DUP_F16 : WInst<"vld2_dup", "2c", "hQh">; +def VLD3_DUP_F16 : WInst<"vld3_dup", "3c", "hQh">; +def VLD4_DUP_F16 : WInst<"vld4_dup", "4c", "hQh">; +def VLD2_LANE_F16 : WInst<"vld2_lane", "2c2i", "hQh">; +def VLD3_LANE_F16 : WInst<"vld3_lane", "3c3i", "hQh">; +def VLD4_LANE_F16 : WInst<"vld4_lane", "4c4i", "hQh">; +def VST2_F16 : WInst<"vst2", "vp2", "hQh">; +def VST3_F16 : WInst<"vst3", "vp3", "hQh">; +def VST4_F16 : WInst<"vst4", "vp4", "hQh">; +def VST2_LANE_F16 : WInst<"vst2_lane", "vp2i", "hQh">; +def VST3_LANE_F16 : WInst<"vst3_lane", "vp3i", "hQh">; +def VST4_LANE_F16 : WInst<"vst4_lane", "vp4i", "hQh">; +} //////////////////////////////////////////////////////////////////////////////// // E.3.16 Extract lanes from a vector @@ -1610,3 +1649,21 @@ let ArchGuard = "defined(__ARM_FEATURE_DOTPROD) && defined(__aarch64__)" in { // Variants indexing into a 128-bit vector are A64 only. def UDOT_LANEQ : SOpInst<"vdot_laneq", "dd89i", "iUiQiQUi", OP_DOT_LNQ>; } + +// v8.2-A FP16 fused multiply-add long instructions. +let ArchGuard = "defined(__ARM_FEATURE_FP16FML) && defined(__aarch64__)" in { + def VFMLAL_LOW : SInst<"vfmlal_low", "ffHH", "UiQUi">; + def VFMLSL_LOW : SInst<"vfmlsl_low", "ffHH", "UiQUi">; + def VFMLAL_HIGH : SInst<"vfmlal_high", "ffHH", "UiQUi">; + def VFMLSL_HIGH : SInst<"vfmlsl_high", "ffHH", "UiQUi">; + + def VFMLAL_LANE_LOW : SOpInst<"vfmlal_lane_low", "ffH0i", "UiQUi", OP_FMLAL_LN>; + def VFMLSL_LANE_LOW : SOpInst<"vfmlsl_lane_low", "ffH0i", "UiQUi", OP_FMLSL_LN>; + def VFMLAL_LANE_HIGH : SOpInst<"vfmlal_lane_high", "ffH0i", "UiQUi", OP_FMLAL_LN_Hi>; + def VFMLSL_LANE_HIGH : SOpInst<"vfmlsl_lane_high", "ffH0i", "UiQUi", OP_FMLSL_LN_Hi>; + + def VFMLAL_LANEQ_LOW : SOpInst<"vfmlal_laneq_low", "ffH1i", "UiQUi", OP_FMLAL_LN>; + def VFMLSL_LANEQ_LOW : SOpInst<"vfmlsl_laneq_low", "ffH1i", "UiQUi", OP_FMLSL_LN>; + def VFMLAL_LANEQ_HIGH : SOpInst<"vfmlal_laneq_high", "ffH1i", "UiQUi", OP_FMLAL_LN_Hi>; + def VFMLSL_LANEQ_HIGH : SOpInst<"vfmlsl_laneq_high", "ffH1i", "UiQUi", OP_FMLSL_LN_Hi>; +} diff --git a/include/clang/Basic/arm_neon_incl.td b/include/clang/Basic/arm_neon_incl.td index 5f3aa6fc0221..09df22ea5ca2 100644 --- a/include/clang/Basic/arm_neon_incl.td +++ b/include/clang/Basic/arm_neon_incl.td @@ -96,6 +96,11 @@ def bitcast; // example: (dup $p1) -> "(uint32x2_t) {__p1, __p1}" (assuming the base type // is uint32x2_t). def dup; +// dup_typed - Take a vector and a scalar argument, and create a new vector of +// the same type by duplicating the scalar value into all lanes. +// example: (dup_typed $p1, $p2) -> "(float16x4_t) {__p2, __p2, __p2, __p2}" +// (assuming __p1 is float16x4_t, and __p2 is a compatible scalar). +def dup_typed; // splat - Take a vector and a lane index, and return a vector of the same type // containing repeated instances of the source vector at the lane index. // example: (splat $p0, $p1) -> @@ -229,6 +234,8 @@ def OP_UNAVAILABLE : Operation { // f: float (int args) // F: double (int args) // H: half (int args) +// 0: half (int args), ignore 'Q' size modifier. +// 1: half (int args), force 'Q' size modifier. // d: default // g: default, ignore 'Q' size modifier. // j: default, force 'Q' size modifier. |