diff options
Diffstat (limited to 'include/clang/Basic')
55 files changed, 4574 insertions, 1025 deletions
diff --git a/include/clang/Basic/AddressSpaces.h b/include/clang/Basic/AddressSpaces.h index 8dd75660c672..63df61bedbc6 100644 --- a/include/clang/Basic/AddressSpaces.h +++ b/include/clang/Basic/AddressSpaces.h @@ -25,7 +25,7 @@ namespace LangAS { /// This uses a high starting offset so as not to conflict with any address /// space used by a target. enum ID { - Offset = 0xFFFF00, + Offset = 0x7FFF00, opencl_global = Offset, opencl_local, diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index d5ba72261644..7da1efe5ff40 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -82,6 +82,8 @@ def NormalVar : SubsetSubject<Var, S->getKind() != Decl::ImplicitParam && S->getKind() != Decl::ParmVar && S->getKind() != Decl::NonTypeTemplateParm}]>; +def NonParmVar : SubsetSubject<Var, + [{S->getKind() != Decl::ParmVar}]>; def NonBitField : SubsetSubject<Field, [{!S->isBitField()}]>; @@ -239,6 +241,8 @@ def MicrosoftExt : LangOpt<"MicrosoftExt">; def Borland : LangOpt<"Borland">; def CUDA : LangOpt<"CUDA">; def COnly : LangOpt<"CPlusPlus", 1>; +def OpenCL : LangOpt<"OpenCL">; +def RenderScript : LangOpt<"RenderScript">; // Defines targets for target-specific attributes. The list of strings should // specify architectures for which the target applies, based off the ArchType @@ -252,6 +256,7 @@ def TargetARM : TargetArch<["arm", "thumb"]>; def TargetMips : TargetArch<["mips", "mipsel"]>; def TargetMSP430 : TargetArch<["msp430"]>; def TargetX86 : TargetArch<["x86"]>; +def TargetAnyX86 : TargetArch<["x86", "x86_64"]>; def TargetWindows : TargetArch<["x86", "x86_64", "arm", "thumb"]> { let OSes = ["Win32"]; } @@ -310,6 +315,9 @@ class TypeAttr : Attr { let ASTNode = 0; } +/// A stmt attribute is not processed on a declaration or a type. +class StmtAttr : Attr; + /// An inheritable attribute is inherited by later redeclarations. class InheritableAttr : Attr; @@ -337,6 +345,11 @@ class TargetSpecificAttr<TargetArch target> { /// redeclarations, even when it's written on a parameter. class InheritableParamAttr : InheritableAttr; +/// An attribute which changes the ABI rules for a specific parameter. +class ParameterABIAttr : InheritableParamAttr { + let Subjects = SubjectList<[ParmVar]>; +} + /// An ignored attribute, which we parse but discard with no checking. class IgnoredAttr : Attr { let Ignored = 1; @@ -349,6 +362,14 @@ class IgnoredAttr : Attr { // Attributes begin here // +def AbiTag : Attr { + let Spellings = [GCC<"abi_tag">]; + let Args = [VariadicStringArgument<"Tags">]; + let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag, + "ExpectedStructClassVariableFunctionOrInlineNamespace">; + let Documentation = [AbiTagsDocs]; +} + def AddressSpace : TypeAttr { let Spellings = [GNU<"address_space">]; let Args = [IntArgument<"AddressSpace">]; @@ -407,6 +428,22 @@ def AlwaysInline : InheritableAttr { let Documentation = [Undocumented]; } +def XRayInstrument : InheritableAttr { + let Spellings = [GNU<"xray_always_instrument">, + CXX11<"clang", "xray_always_instrument">, + GNU<"xray_never_instrument">, + CXX11<"clang", "xray_never_instrument">]; + let Subjects = SubjectList<[CXXMethod, ObjCMethod, Function], WarnDiag, + "ExpectedFunctionOrMethod">; + let Accessors = [Accessor<"alwaysXRayInstrument", + [GNU<"xray_always_instrument">, + CXX11<"clang", "xray_always_instrument">]>, + Accessor<"neverXRayInstrument", + [GNU<"xray_never_instrument">, + CXX11<"clang", "xray_never_instrument">]>]; + let Documentation = [XRayDocs]; +} + def TLSModel : InheritableAttr { let Spellings = [GCC<"tls_model">]; let Subjects = SubjectList<[TLSVar], ErrorDiag, "ExpectedTLSVar">; @@ -426,8 +463,8 @@ def Annotate : InheritableParamAttr { } def ARMInterrupt : InheritableAttr, TargetSpecificAttr<TargetARM> { - // NOTE: If you add any additional spellings, MSP430Interrupt's and - // MipsInterrupt's spellings must match. + // NOTE: If you add any additional spellings, MSP430Interrupt's, + // MipsInterrupt's and AnyX86Interrupt's spellings must match. let Spellings = [GNU<"interrupt">]; let Args = [EnumArgument<"Interrupt", "InterruptType", ["IRQ", "FIQ", "SWI", "ABORT", "UNDEF", ""], @@ -449,17 +486,18 @@ def Availability : InheritableAttr { let Spellings = [GNU<"availability">]; let Args = [IdentifierArgument<"platform">, VersionArgument<"introduced">, VersionArgument<"deprecated">, VersionArgument<"obsoleted">, - BoolArgument<"unavailable">, StringArgument<"message">]; + BoolArgument<"unavailable">, StringArgument<"message">, + BoolArgument<"strict">, StringArgument<"replacement">]; let AdditionalMembers = [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { return llvm::StringSwitch<llvm::StringRef>(Platform) .Case("android", "Android") .Case("ios", "iOS") - .Case("macosx", "OS X") + .Case("macos", "macOS") .Case("tvos", "tvOS") .Case("watchos", "watchOS") .Case("ios_app_extension", "iOS (App Extension)") - .Case("macosx_app_extension", "OS X (App Extension)") + .Case("macos_app_extension", "macOS (App Extension)") .Case("tvos_app_extension", "tvOS (App Extension)") .Case("watchos_app_extension", "watchOS (App Extension)") .Default(llvm::StringRef()); @@ -654,20 +692,27 @@ def OpenCLKernel : InheritableAttr { let Documentation = [Undocumented]; } +def OpenCLUnrollHint : InheritableAttr { + let Spellings = [GNU<"opencl_unroll_hint">]; + let Args = [UnsignedArgument<"UnrollHint">]; + let Documentation = [OpenCLUnrollHintDocs]; +} + // This attribute is both a type attribute, and a declaration attribute (for // parameter variables). -def OpenCLImageAccess : Attr { +def OpenCLAccess : Attr { let Spellings = [Keyword<"__read_only">, Keyword<"read_only">, Keyword<"__write_only">, Keyword<"write_only">, Keyword<"__read_write">, Keyword<"read_write">]; - let Subjects = SubjectList<[ParmVar], ErrorDiag>; + let Subjects = SubjectList<[ParmVar, TypedefName], ErrorDiag, + "ExpectedParameterOrTypedef">; let Accessors = [Accessor<"isReadOnly", [Keyword<"__read_only">, Keyword<"read_only">]>, Accessor<"isReadWrite", [Keyword<"__read_write">, Keyword<"read_write">]>, Accessor<"isWriteOnly", [Keyword<"__write_only">, Keyword<"write_only">]>]; - let Documentation = [Undocumented]; + let Documentation = [OpenCLAccessDocs]; } def OpenCLPrivateAddressSpace : TypeAttr { @@ -695,11 +740,29 @@ def OpenCLGenericAddressSpace : TypeAttr { let Documentation = [OpenCLAddressSpaceGenericDocs]; } +def OpenCLNoSVM : Attr { + let Spellings = [GNU<"nosvm">]; + let Subjects = SubjectList<[Var]>; + let Documentation = [OpenCLNoSVMDocs]; + let LangOpts = [OpenCL]; + let ASTNode = 0; +} + +def RenderScriptKernel : Attr { + let Spellings = [GNU<"kernel">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [RenderScriptKernelAttributeDocs]; + let LangOpts = [RenderScript]; +} + def Deprecated : InheritableAttr { let Spellings = [GCC<"deprecated">, Declspec<"deprecated">, CXX11<"","deprecated", 201309>]; - let Args = [StringArgument<"Message", 1>]; - let Documentation = [Undocumented]; + let Args = [StringArgument<"Message", 1>, + // An optional string argument that enables us to provide a + // Fix-It. + StringArgument<"Replacement", 1>]; + let Documentation = [DeprecatedDocs]; } def Destructor : InheritableAttr { @@ -709,6 +772,12 @@ def Destructor : InheritableAttr { let Documentation = [Undocumented]; } +def EmptyBases : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> { + let Spellings = [Declspec<"empty_bases">]; + let Subjects = SubjectList<[CXXRecord]>; + let Documentation = [EmptyBasesDocs]; +} + def EnableIf : InheritableAttr { let Spellings = [GNU<"enable_if">]; let Subjects = SubjectList<[Function]>; @@ -725,8 +794,9 @@ def ExtVectorType : Attr { let Documentation = [Undocumented]; } -def FallThrough : Attr { - let Spellings = [CXX11<"clang", "fallthrough">]; +def FallThrough : StmtAttr { + let Spellings = [CXX11<"", "fallthrough", 201603>, + CXX11<"clang", "fallthrough">]; // let Subjects = [NullStmt]; let Documentation = [FallthroughDocs]; } @@ -818,12 +888,26 @@ def IBOutletCollection : InheritableAttr { let Documentation = [Undocumented]; } +def IFunc : Attr { + let Spellings = [GCC<"ifunc">]; + let Args = [StringArgument<"Resolver">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [IFuncDocs]; +} + def Restrict : InheritableAttr { let Spellings = [Declspec<"restrict">, GCC<"malloc">]; let Subjects = SubjectList<[Function]>; let Documentation = [Undocumented]; } +def LayoutVersion : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> { + let Spellings = [Declspec<"layout_version">]; + let Args = [UnsignedArgument<"Version">]; + let Subjects = SubjectList<[CXXRecord]>; + let Documentation = [LayoutVersionDocs]; +} + def MaxFieldAlignment : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; @@ -845,8 +929,8 @@ def MSABI : InheritableAttr { } def MSP430Interrupt : InheritableAttr, TargetSpecificAttr<TargetMSP430> { - // NOTE: If you add any additional spellings, ARMInterrupt's and - // MipsInterrupt's spellings must match. + // NOTE: If you add any additional spellings, ARMInterrupt's, MipsInterrupt's + // and AnyX86Interrupt's spellings must match. let Spellings = [GNU<"interrupt">]; let Args = [UnsignedArgument<"Number">]; let ParseKind = "Interrupt"; @@ -861,8 +945,8 @@ def Mips16 : InheritableAttr, TargetSpecificAttr<TargetMips> { } def MipsInterrupt : InheritableAttr, TargetSpecificAttr<TargetMips> { - // NOTE: If you add any additional spellings, ARMInterrupt's and - // MSP430Interrupt's spellings must match. + // NOTE: If you add any additional spellings, ARMInterrupt's, + // MSP430Interrupt's and AnyX86Interrupt's spellings must match. let Spellings = [GNU<"interrupt">]; let Subjects = SubjectList<[Function]>; let Args = [EnumArgument<"Interrupt", "InterruptType", @@ -878,6 +962,8 @@ def MipsInterrupt : InheritableAttr, TargetSpecificAttr<TargetMips> { def Mode : Attr { let Spellings = [GCC<"mode">]; + let Subjects = SubjectList<[Var, Enum, TypedefName, Field], ErrorDiag, + "ExpectedVariableEnumFieldOrTypedef">; let Args = [IdentifierArgument<"Mode">]; let Documentation = [Undocumented]; } @@ -927,7 +1013,9 @@ def NoCommon : InheritableAttr { def NoDebug : InheritableAttr { let Spellings = [GCC<"nodebug">]; - let Documentation = [Undocumented]; + let Subjects = SubjectList<[FunctionLike, ObjCMethod, NonParmVar], WarnDiag, + "ExpectedVariableOrFunction">; + let Documentation = [NoDebugDocs]; } def NoDuplicate : InheritableAttr { @@ -1202,6 +1290,12 @@ def ObjCRuntimeName : Attr { let Documentation = [ObjCRuntimeNameDocs]; } +def ObjCRuntimeVisible : Attr { + let Spellings = [GNU<"objc_runtime_visible">]; + let Subjects = SubjectList<[ObjCInterface], ErrorDiag>; + let Documentation = [ObjCRuntimeVisibleDocs]; +} + def ObjCBoxable : Attr { let Spellings = [GNU<"objc_boxable">]; let Subjects = SubjectList<[Record], ErrorDiag, "ExpectedStructOrUnion">; @@ -1325,6 +1419,27 @@ def StdCall : InheritableAttr { let Documentation = [StdCallDocs]; } +def SwiftCall : InheritableAttr { + let Spellings = [GCC<"swiftcall">]; +// let Subjects = SubjectList<[Function]>; + let Documentation = [SwiftCallDocs]; +} + +def SwiftContext : ParameterABIAttr { + let Spellings = [GCC<"swift_context">]; + let Documentation = [SwiftContextDocs]; +} + +def SwiftErrorResult : ParameterABIAttr { + let Spellings = [GCC<"swift_error_result">]; + let Documentation = [SwiftErrorResultDocs]; +} + +def SwiftIndirectResult : ParameterABIAttr { + let Spellings = [GCC<"swift_indirect_result">]; + let Documentation = [SwiftIndirectResultDocs]; +} + def SysVABI : InheritableAttr { let Spellings = [GCC<"sysv_abi">]; // let Subjects = [Function, ObjCMethod]; @@ -1351,6 +1466,16 @@ def Pascal : InheritableAttr { let Documentation = [Undocumented]; } +def PreserveMost : InheritableAttr { + let Spellings = [GNU<"preserve_most">]; + let Documentation = [PreserveMostDocs]; +} + +def PreserveAll : InheritableAttr { + let Spellings = [GNU<"preserve_all">]; + let Documentation = [PreserveAllDocs]; +} + def Target : InheritableAttr { let Spellings = [GCC<"target">]; let Args = [StringArgument<"featuresStr">]; @@ -1436,11 +1561,11 @@ def ObjCRequiresPropertyDefs : InheritableAttr { } def Unused : InheritableAttr { - let Spellings = [GCC<"unused">]; - let Subjects = SubjectList<[Var, ObjCIvar, Type, Label, Field, ObjCMethod, - FunctionLike], WarnDiag, - "ExpectedVariableFunctionOrLabel">; - let Documentation = [Undocumented]; + let Spellings = [CXX11<"", "maybe_unused", 201603>, GCC<"unused">]; + let Subjects = SubjectList<[Var, ObjCIvar, Type, Enum, EnumConstant, Label, + Field, ObjCMethod, FunctionLike], WarnDiag, + "ExpectedForMaybeUnused">; + let Documentation = [WarnMaybeUnusedDocs]; } def Used : InheritableAttr { @@ -1501,11 +1626,12 @@ def WarnUnused : InheritableAttr { } def WarnUnusedResult : InheritableAttr { - let Spellings = [GCC<"warn_unused_result">, - CXX11<"clang", "warn_unused_result">]; - let Subjects = SubjectList<[ObjCMethod, CXXRecord, FunctionLike], WarnDiag, - "ExpectedFunctionMethodOrClass">; - let Documentation = [Undocumented]; + let Spellings = [CXX11<"", "nodiscard", 201603>, + CXX11<"clang", "warn_unused_result">, + GCC<"warn_unused_result">]; + let Subjects = SubjectList<[ObjCMethod, Enum, CXXRecord, FunctionLike], + WarnDiag, "ExpectedFunctionMethodEnumOrClass">; + let Documentation = [WarnUnusedResultsDocs]; } def Weak : InheritableAttr { @@ -1527,6 +1653,22 @@ def WeakRef : InheritableAttr { let Documentation = [Undocumented]; } +def LTOVisibilityPublic : InheritableAttr { + let Spellings = [CXX11<"clang", "lto_visibility_public">]; + let Subjects = SubjectList<[Record]>; + let Documentation = [LTOVisibilityDocs]; +} + +def AnyX86Interrupt : InheritableAttr, TargetSpecificAttr<TargetAnyX86> { + // NOTE: If you add any additional spellings, ARMInterrupt's, + // MSP430Interrupt's and MipsInterrupt's spellings must match. + let Spellings = [GNU<"interrupt">]; + let Subjects = SubjectList<[HasFunctionProto]>; + let ParseKind = "Interrupt"; + let HasCustomParsing = 1; + let Documentation = [AnyX86InterruptDocs]; +} + def X86ForceAlignArgPointer : InheritableAttr, TargetSpecificAttr<TargetX86> { let Spellings = [GNU<"force_align_arg_pointer">]; // Technically, this appertains to a FunctionDecl, but the target-specific @@ -1945,14 +2087,14 @@ def MSStruct : InheritableAttr { def DLLExport : InheritableAttr, TargetSpecificAttr<TargetWindows> { let Spellings = [Declspec<"dllexport">, GCC<"dllexport">]; - let Subjects = SubjectList<[Function, Var, CXXRecord]>; - let Documentation = [Undocumented]; + let Subjects = SubjectList<[Function, Var, CXXRecord, ObjCInterface]>; + let Documentation = [DLLExportDocs]; } def DLLImport : InheritableAttr, TargetSpecificAttr<TargetWindows> { let Spellings = [Declspec<"dllimport">, GCC<"dllimport">]; - let Subjects = SubjectList<[Function, Var, CXXRecord]>; - let Documentation = [Undocumented]; + let Subjects = SubjectList<[Function, Var, CXXRecord, ObjCInterface]>; + let Documentation = [DLLImportDocs]; } def SelectAny : InheritableAttr { @@ -2055,10 +2197,6 @@ def InitSeg : Attr { }]; } -def Unaligned : IgnoredAttr { - let Spellings = [Keyword<"__unaligned">]; -} - def LoopHint : Attr { /// #pragma clang loop <option> directive /// vectorize: vectorizes loop operations if State == Enable. @@ -2067,6 +2205,7 @@ def LoopHint : Attr { /// interleave_count: interleaves 'Value' loop interations. /// unroll: fully unroll loop if State == Enable. /// unroll_count: unrolls loop 'Value' times. + /// distribute: attempt to distribute loop if State == Enable /// #pragma unroll <argument> directive /// <no arg>: fully unrolls loop. @@ -2079,9 +2218,9 @@ def LoopHint : Attr { /// State of the loop optimization specified by the spelling. let Args = [EnumArgument<"Option", "OptionType", ["vectorize", "vectorize_width", "interleave", "interleave_count", - "unroll", "unroll_count"], + "unroll", "unroll_count", "distribute"], ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount", - "Unroll", "UnrollCount"]>, + "Unroll", "UnrollCount", "Distribute"]>, EnumArgument<"State", "LoopHintState", ["enable", "disable", "numeric", "assume_safety", "full"], ["Enable", "Disable", "Numeric", "AssumeSafety", "Full"]>, @@ -2096,6 +2235,7 @@ def LoopHint : Attr { case InterleaveCount: return "interleave_count"; case Unroll: return "unroll"; case UnrollCount: return "unroll_count"; + case Distribute: return "distribute"; } llvm_unreachable("Unhandled LoopHint option."); } @@ -2165,6 +2305,98 @@ def OMPThreadPrivateDecl : InheritableAttr { let Documentation = [Undocumented]; } +def OMPCaptureNoInit : InheritableAttr { + // This attribute has no spellings as it is only ever created implicitly. + let Spellings = []; + let SemaHandler = 0; + let Documentation = [Undocumented]; +} + +def OMPDeclareSimdDecl : Attr { + let Spellings = [Pragma<"omp", "declare simd">]; + let Subjects = SubjectList<[Function]>; + let SemaHandler = 0; + let HasCustomParsing = 1; + let Documentation = [OMPDeclareSimdDocs]; + let Args = [ + EnumArgument<"BranchState", "BranchStateTy", + [ "", "inbranch", "notinbranch" ], + [ "BS_Undefined", "BS_Inbranch", "BS_Notinbranch" ]>, + ExprArgument<"Simdlen">, VariadicExprArgument<"Uniforms">, + VariadicExprArgument<"Aligneds">, VariadicExprArgument<"Alignments">, + VariadicExprArgument<"Linears">, VariadicUnsignedArgument<"Modifiers">, + VariadicExprArgument<"Steps"> + ]; + let AdditionalMembers = [{ + void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy) + const { + if (getBranchState() != BS_Undefined) + OS << ConvertBranchStateTyToStr(getBranchState()) << " "; + if (auto *E = getSimdlen()) { + OS << "simdlen("; + E->printPretty(OS, nullptr, Policy); + OS << ") "; + } + if (uniforms_size() > 0) { + OS << "uniform"; + StringRef Sep = "("; + for (auto *E : uniforms()) { + OS << Sep; + E->printPretty(OS, nullptr, Policy); + Sep = ", "; + } + OS << ") "; + } + alignments_iterator NI = alignments_begin(); + for (auto *E : aligneds()) { + OS << "aligned("; + E->printPretty(OS, nullptr, Policy); + if (*NI) { + OS << ": "; + (*NI)->printPretty(OS, nullptr, Policy); + } + OS << ") "; + ++NI; + } + steps_iterator I = steps_begin(); + modifiers_iterator MI = modifiers_begin(); + for (auto *E : linears()) { + OS << "linear("; + if (*MI != OMPC_LINEAR_unknown) + OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "("; + E->printPretty(OS, nullptr, Policy); + if (*MI != OMPC_LINEAR_unknown) + OS << ")"; + if (*I) { + OS << ": "; + (*I)->printPretty(OS, nullptr, Policy); + } + OS << ") "; + ++I; + ++MI; + } + } + }]; +} + +def OMPDeclareTargetDecl : Attr { + let Spellings = [Pragma<"omp", "declare target">]; + let SemaHandler = 0; + let Documentation = [OMPDeclareTargetDocs]; + let Args = [ + EnumArgument<"MapType", "MapTypeTy", + [ "to", "link" ], + [ "MT_To", "MT_Link" ]> + ]; + let AdditionalMembers = [{ + void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const { + // Use fake syntax because it is for testing and debugging purpose only. + if (getMapType() != MT_To) + OS << ConvertMapTypeTyToStr(getMapType()) << " "; + } + }]; +} + def InternalLinkage : InheritableAttr { let Spellings = [GNU<"internal_linkage">, CXX11<"clang", "internal_linkage">]; let Subjects = SubjectList<[Var, Function, CXXRecord]>; diff --git a/include/clang/Basic/AttrDocs.td b/include/clang/Basic/AttrDocs.td index 2567d55eb7e0..d0342bc6038a 100644 --- a/include/clang/Basic/AttrDocs.td +++ b/include/clang/Basic/AttrDocs.td @@ -67,6 +67,34 @@ TLS models are mutually exclusive. }]; } +def DLLExportDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``__declspec(dllexport)`` attribute declares a variable, function, or +Objective-C interface to be exported from the module. It is available under the +``-fdeclspec`` flag for compatibility with various compilers. The primary use +is for COFF object files which explicitly specify what interfaces are available +for external use. See the dllexport_ documentation on MSDN for more +information. + +.. _dllexport: https://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx + }]; +} + +def DLLImportDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``__declspec(dllimport)`` attribute declares a variable, function, or +Objective-C interface to be imported from an external module. It is available +under the ``-fdeclspec`` flag for compatibility with various compilers. The +primary use is for COFF object files which explicitly specify what interfaces +are imported from external modules. See the dllimport_ documentation on MSDN +for more information. + +.. _dllimport: https://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx + }]; +} + def ThreadDocs : Documentation { let Category = DocCatVariable; let Content = [{ @@ -260,6 +288,55 @@ only a single candidate. In a call to g(1, 1), the call is ambiguous even though not ODR-equivalent. Query for this feature with ``__has_attribute(enable_if)``. + +Note that functions with one or more ``enable_if`` attributes may not have +their address taken, unless all of the conditions specified by said +``enable_if`` are constants that evaluate to ``true``. For example: + +.. code-block:: c + + const int TrueConstant = 1; + const int FalseConstant = 0; + int f(int a) __attribute__((enable_if(a > 0, ""))); + int g(int a) __attribute__((enable_if(a == 0 || a != 0, ""))); + int h(int a) __attribute__((enable_if(1, ""))); + int i(int a) __attribute__((enable_if(TrueConstant, ""))); + int j(int a) __attribute__((enable_if(FalseConstant, ""))); + + void fn() { + int (*ptr)(int); + ptr = &f; // error: 'a > 0' is not always true + ptr = &g; // error: 'a == 0 || a != 0' is not a truthy constant + ptr = &h; // OK: 1 is a truthy constant + ptr = &i; // OK: 'TrueConstant' is a truthy constant + ptr = &j; // error: 'FalseConstant' is a constant, but not truthy + } + +Because ``enable_if`` evaluation happens during overload resolution, +``enable_if`` may give unintuitive results when used with templates, depending +on when overloads are resolved. In the example below, clang will emit a +diagnostic about no viable overloads for ``foo`` in ``bar``, but not in ``baz``: + +.. code-block:: c++ + + double foo(int i) __attribute__((enable_if(i > 0, ""))); + void *foo(int i) __attribute__((enable_if(i <= 0, ""))); + template <int I> + auto bar() { return foo(I); } + + template <typename T> + auto baz() { return foo(T::number); } + + struct WithNumber { constexpr static int number = 1; }; + void callThem() { + bar<sizeof(WithNumber)>(); + baz<WithNumber>(); + } + +This is because, in ``bar``, ``foo`` is resolved prior to template +instantiation, so the value for ``I`` isn't known (thus, both ``enable_if`` +conditions for ``foo`` fail). However, in ``baz``, ``foo`` is resolved during +template instantiation, so the value for ``T::number`` is known. }]; } @@ -471,6 +548,15 @@ Query for this feature with ``__has_attribute(objc_method_family)``. }]; } +def NoDebugDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``nodebug`` attribute allows you to suppress debugging information for a +function or method, or for a variable that is not a parameter or a non-static +data member. + }]; +} + def NoDuplicateDocs : Documentation { let Category = DocCatFunction; let Content = [{ @@ -589,6 +675,13 @@ can only be placed before an @protocol or @interface declaration: }]; } +def ObjCRuntimeVisibleDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +This attribute specifies that the Objective-C class to which it applies is visible to the Objective-C runtime but not to the linker. Classes annotated with this attribute cannot be subclassed and cannot have categories defined for them. + }]; +} + def ObjCBoxableDocs : Documentation { let Category = DocCatFunction; let Content = [{ @@ -626,7 +719,7 @@ the function declaration for a hypothetical function ``f``: .. code-block:: c++ - void f(void) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6,obsoleted=10.7))); + void f(void) __attribute__((availability(macos,introduced=10.4,deprecated=10.6,obsoleted=10.7))); The availability attribute states that ``f`` was introduced in Mac OS X 10.4, deprecated in Mac OS X 10.6, and obsoleted in Mac OS X 10.7. This information @@ -661,6 +754,11 @@ message=\ *string-literal* error about use of a deprecated or obsoleted declaration. Useful to direct users to replacement APIs. +replacement=\ *string-literal* + Additional message text that Clang will use to provide Fix-It when emitting + a warning about use of a deprecated declaration. The Fix-It will replace + the deprecated declaration with the new declaration specified. + Multiple availability attributes can be placed on a declaration, which may correspond to different platforms. Only the availability attribute with the platform corresponding to the target platform will be used; any others will be @@ -673,9 +771,11 @@ are: the ``-mios-version-min=*version*`` or ``-miphoneos-version-min=*version*`` command-line arguments. -``macosx`` +``macos`` Apple's Mac OS X operating system. The minimum deployment target is specified by the ``-mmacosx-version-min=*version*`` command-line argument. + ``macosx`` is supported for backward-compatibility reasons, but it is + deprecated. ``tvos`` Apple's tvOS operating system. The minimum deployment target is specified by @@ -685,15 +785,21 @@ are: Apple's watchOS operating system. The minimum deployment target is specified by the ``-mwatchos-version-min=*version*`` command-line argument. -A declaration can be used even when deploying back to a platform version prior -to when the declaration was introduced. When this happens, the declaration is -`weakly linked +A declaration can typically be used even when deploying back to a platform +version prior to when the declaration was introduced. When this happens, the +declaration is `weakly linked <https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_, as if the ``weak_import`` attribute were added to the declaration. A weakly-linked declaration may or may not be present a run-time, and a program can determine whether the declaration is present by checking whether the address of that declaration is non-NULL. +The flag ``strict`` disallows using API when deploying back to a +platform version prior to when the declaration was introduced. An +attempt to use such API before its introduction causes a hard error. +Weakly-linking is almost always a better API choice, since it allows +users to query availability at runtime. + If there are multiple declarations of the same entity, the availability attributes must either match on a per-platform basis or later declarations must not have availability attributes for that @@ -701,33 +807,85 @@ platform. For example: .. code-block:: c - void g(void) __attribute__((availability(macosx,introduced=10.4))); - void g(void) __attribute__((availability(macosx,introduced=10.4))); // okay, matches + void g(void) __attribute__((availability(macos,introduced=10.4))); + void g(void) __attribute__((availability(macos,introduced=10.4))); // okay, matches void g(void) __attribute__((availability(ios,introduced=4.0))); // okay, adds a new platform - void g(void); // okay, inherits both macosx and ios availability from above. - void g(void) __attribute__((availability(macosx,introduced=10.5))); // error: mismatch + void g(void); // okay, inherits both macos and ios availability from above. + void g(void) __attribute__((availability(macos,introduced=10.5))); // error: mismatch When one method overrides another, the overriding method can be more widely available than the overridden method, e.g.,: .. code-block:: objc @interface A - - (id)method __attribute__((availability(macosx,introduced=10.4))); - - (id)method2 __attribute__((availability(macosx,introduced=10.4))); + - (id)method __attribute__((availability(macos,introduced=10.4))); + - (id)method2 __attribute__((availability(macos,introduced=10.4))); @end @interface B : A - - (id)method __attribute__((availability(macosx,introduced=10.3))); // okay: method moved into base class later - - (id)method __attribute__((availability(macosx,introduced=10.5))); // error: this method was available via the base class in 10.4 + - (id)method __attribute__((availability(macos,introduced=10.3))); // okay: method moved into base class later + - (id)method __attribute__((availability(macos,introduced=10.5))); // error: this method was available via the base class in 10.4 @end }]; } +def WarnMaybeUnusedDocs : Documentation { + let Category = DocCatVariable; + let Heading = "maybe_unused, unused, gnu::unused"; + let Content = [{ +When passing the ``-Wunused`` flag to Clang, entities that are unused by the +program may be diagnosed. The ``[[maybe_unused]]`` (or +``__attribute__((unused))``) attribute can be used to silence such diagnostics +when the entity cannot be removed. For instance, a local variable may exist +solely for use in an ``assert()`` statement, which makes the local variable +unused when ``NDEBUG`` is defined. + +The attribute may be applied to the declaration of a class, a typedef, a +variable, a function or method, a function parameter, an enumeration, an +enumerator, a non-static data member, or a label. + +.. code-block: c++ + #include <cassert>
+
+ [[maybe_unused]] void f([[maybe_unused]] bool thing1,
+ [[maybe_unused]] bool thing2) {
+ [[maybe_unused]] bool b = thing1 && thing2;
+ assert(b);
+ } + }]; +} + +def WarnUnusedResultsDocs : Documentation { + let Category = DocCatFunction; + let Heading = "nodiscard, warn_unused_result, clang::warn_unused_result, gnu::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 +generated when a function or its return type is marked with ``[[nodiscard]]`` +(or ``__attribute__((warn_unused_result))``) and the function call appears as a +potentially-evaluated discarded-value expression that is not explicitly cast to +`void`. + +.. code-block: c++ + struct [[nodiscard]] error_info { /*...*/ };
+ error_info enable_missile_safety_mode();
+
+ void launch_missiles();
+ void test_missiles() {
+ enable_missile_safety_mode(); // diagnoses
+ launch_missiles();
+ }
+ error_info &foo();
+ void f() { foo(); } // Does not diagnose, error_info is a reference. + }]; +} + def FallthroughDocs : Documentation { let Category = DocCatStmt; + let Heading = "fallthrough, clang::fallthrough"; let Content = [{ -The ``clang::fallthrough`` attribute is used along with the -``-Wimplicit-fallthrough`` argument to annotate intentional fall-through +The ``fallthrough`` (or ``clang::fallthrough``) attribute is used +to annotate intentional fall-through between switch labels. It can only be applied to a null statement placed at a point of execution between any statement and the next switch label. It is common to mark these places with a specific comment, but this attribute is @@ -738,6 +896,10 @@ control-flow statements like ``break;``, so it can be placed in most places where ``break;`` can, but only if there are no statements on the execution path between it and the next switch label. +By default, Clang does not warn on unannotated fallthrough from one ``switch`` +case to another. Diagnostics on fallthrough without a corresponding annotation +can be enabled with the ``-Wimplicit-fallthrough`` argument. + Here is an example: .. code-block:: c++ @@ -1421,6 +1583,26 @@ manipulating bits of the enumerator when issuing warnings. }]; } +def EmptyBasesDocs : Documentation { + let Category = DocCatType; + let Content = [{ +The empty_bases attribute permits the compiler to utilize the +empty-base-optimization more frequently. +This attribute only applies to struct, class, and union types. +It is only supported when using the Microsoft C++ ABI. + }]; +} + +def LayoutVersionDocs : Documentation { + let Category = DocCatType; + let Content = [{ +The layout_version attribute requests that the compiler utilize the class +layout rules of a particular compiler version. +This attribute only applies to struct, class, and union types. +It is only supported when using the Microsoft C++ ABI. + }]; +} + def MSInheritanceDocs : Documentation { let Category = DocCatType; let Heading = "__single_inhertiance, __multiple_inheritance, __virtual_inheritance"; @@ -1562,6 +1744,46 @@ for further details including limitations of the unroll hints. }]; } +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 +used to specify full unrolling or partial unrolling by a specified amount. +This is a compiler hint and the compiler may ignore this directive. See +`OpenCL v2.0 <https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf>`_ +s6.11.5 for details. + }]; +} + +def OpenCLAccessDocs : Documentation { + let Category = DocCatStmt; + let Heading = "__read_only, __write_only, __read_write (read_only, write_only, read_write)"; + let Content = [{ +The access qualifiers must be used with image object arguments or pipe arguments +to declare if they are being read or written by a kernel or function. + +The read_only/__read_only, write_only/__write_only and read_write/__read_write +names are reserved for use as access qualifiers and shall not be used otherwise. + +.. code-block:: c + + kernel void + foo (read_only image2d_t imageA, + write_only image2d_t imageB) { + ... + } + +In the above example imageA is a read-only 2D image object, and imageB is a +write-only 2D image object. + +The read_write (or __read_write) qualifier can not be used with pipe. + +More details can be found in the OpenCL C language Spec v2.0, Section 6.6. + }]; +} + def DocOpenCLAddressSpaces : DocumentationCategory<"OpenCL Address Spaces"> { let Content = [{ The address space qualifier may be used to specify the region of memory that is @@ -1643,6 +1865,17 @@ cannot point to the private address space. }]; } +def OpenCLNoSVMDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +OpenCL 2.0 supports the optional ``__attribute__((nosvm))`` qualifier for +pointer variable. It informs the compiler that the pointer does not refer +to a shared virtual memory region. See OpenCL v2.0 s6.7.2 for details. + +Since it is not widely used and has been removed from OpenCL 2.1, it is ignored +by Clang. + }]; +} def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> { let Content = [{ Whether a particular pointer may be "null" is an important concern when working with pointers in the C family of languages. The various nullability attributes indicate whether a particular pointer can be null or not, which makes APIs more expressive and can help static analysis tools identify bugs involving null pointers. Clang supports several kinds of nullability attributes: the ``nonnull`` and ``returns_nonnull`` attributes indicate which function or method parameters and result types can never be null, while nullability type qualifiers indicate which pointer types can be null (``_Nullable``) or cannot be null (``_Nonnull``). @@ -1758,6 +1991,58 @@ arguments, with arbitrary offsets. }]; } +def OMPDeclareSimdDocs : Documentation { + let Category = DocCatFunction; + let Heading = "#pragma omp declare simd"; + let Content = [{ +The `declare simd` construct can be applied to a function to enable the creation +of one or more versions that can process multiple arguments using SIMD +instructions from a single invocation in a SIMD loop. The `declare simd` +directive is a declarative directive. There may be multiple `declare simd` +directives for a function. The use of a `declare simd` construct on a function +enables the creation of SIMD versions of the associated function that can be +used to process multiple arguments from a single invocation from a SIMD loop +concurrently. +The syntax of the `declare simd` construct is as follows: + + .. code-block:: c + + #pragma omp declare simd [clause[[,] clause] ...] new-line + [#pragma omp declare simd [clause[[,] clause] ...] new-line] + [...] + function definition or declaration + +where clause is one of the following: + + .. code-block:: c + + simdlen(length) + linear(argument-list[:constant-linear-step]) + aligned(argument-list[:alignment]) + uniform(argument-list) + inbranch + notinbranch + + }]; +} + +def OMPDeclareTargetDocs : Documentation { + let Category = DocCatFunction; + let Heading = "#pragma omp declare target"; + let Content = [{ +The `declare target` directive specifies that variables and functions are mapped +to a device for OpenMP offload mechanism. + +The syntax of the declare target directive is as follows: + + .. code-block:: c + + #pragma omp declare target new-line + declarations-definition-seq + #pragma omp end declare target new-line + }]; +} + def NotTailCalledDocs : Documentation { let Category = DocCatFunction; let Content = [{ @@ -1765,7 +2050,7 @@ The ``not_tail_called`` attribute prevents tail-call optimization on statically For example, it prevents tail-call optimization in the following case: - .. code-block: c + .. code-block:: c int __attribute__((not_tail_called)) foo1(int); @@ -1775,7 +2060,7 @@ For example, it prevents tail-call optimization in the following case: However, it doesn't prevent tail-call optimization in this case: - .. code-block: c + .. code-block:: c int __attribute__((not_tail_called)) foo1(int); @@ -1789,7 +2074,7 @@ However, it doesn't prevent tail-call optimization in this case: Marking virtual functions as ``not_tail_called`` is an error: - .. code-block: c++ + .. code-block:: c++ class Base { public: @@ -1839,7 +2124,7 @@ For example: Marking virtual functions as ``disable_tail_calls`` is legal. - .. code-block: c++ + .. code-block:: c++ int callee(int); @@ -1859,3 +2144,349 @@ Marking virtual functions as ``disable_tail_calls`` is legal. }]; } + +def AnyX86InterruptDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +Clang supports the GNU style ``__attribute__((interrupt))`` attribute on +x86/x86-64 targets.The compiler generates function entry and exit sequences +suitable for use in an interrupt handler when this attribute is present. +The 'IRET' instruction, instead of the 'RET' instruction, is used to return +from interrupt or exception handlers. All registers, except for the EFLAGS +register which is restored by the 'IRET' instruction, are preserved by the +compiler. + +Any interruptible-without-stack-switch code must be compiled with +-mno-red-zone since interrupt handlers can and will, because of the +hardware design, touch the red zone. + +1. interrupt handler must be declared with a mandatory pointer argument: + + .. code-block:: c + + struct interrupt_frame + { + uword_t ip; + uword_t cs; + uword_t flags; + uword_t sp; + uword_t ss; + }; + + __attribute__ ((interrupt)) + void f (struct interrupt_frame *frame) { + ... + } + +2. exception handler: + + The exception handler is very similar to the interrupt handler with + a different mandatory function signature: + + .. code-block:: c + + __attribute__ ((interrupt)) + void f (struct interrupt_frame *frame, uword_t error_code) { + ... + } + + and compiler pops 'ERROR_CODE' off stack before the 'IRET' instruction. + + The exception handler should only be used for exceptions which push an + error code and all other exceptions must use the interrupt handler. + The system will crash if the wrong handler is used. + }]; +} + +def SwiftCallDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``swiftcall`` attribute indicates that a function should be called +using the Swift calling convention for a function or function pointer. + +The lowering for the Swift calling convention, as described by the Swift +ABI documentation, occurs in multiple phases. The first, "high-level" +phase breaks down the formal parameters and results into innately direct +and indirect components, adds implicit paraameters for the generic +signature, and assigns the context and error ABI treatments to parameters +where applicable. The second phase breaks down the direct parameters +and results from the first phase and assigns them to registers or the +stack. The ``swiftcall`` convention only handles this second phase of +lowering; the C function type must accurately reflect the results +of the first phase, as follows: + +- Results classified as indirect by high-level lowering should be + represented as parameters with the ``swift_indirect_result`` attribute. + +- Results classified as direct by high-level lowering should be represented + as follows: + + - First, remove any empty direct results. + + - If there are no direct results, the C result type should be ``void``. + + - If there is one direct result, the C result type should be a type with + the exact layout of that result type. + + - If there are a multiple direct results, the C result type should be + a struct type with the exact layout of a tuple of those results. + +- Parameters classified as indirect by high-level lowering should be + represented as parameters of pointer type. + +- Parameters classified as direct by high-level lowering should be + omitted if they are empty types; otherwise, they should be represented + as a parameter type with a layout exactly matching the layout of the + Swift parameter type. + +- The context parameter, if present, should be represented as a trailing + parameter with the ``swift_context`` attribute. + +- The error result parameter, if present, should be represented as a + trailing parameter (always following a context parameter) with the + ``swift_error_result`` attribute. + +``swiftcall`` does not support variadic arguments or unprototyped functions. + +The parameter ABI treatment attributes are aspects of the function type. +A function type which which applies an ABI treatment attribute to a +parameter is a different type from an otherwise-identical function type +that does not. A single parameter may not have multiple ABI treatment +attributes. + +Support for this feature is target-dependent, although it should be +supported on every target that Swift supports. Query for this support +with ``__has_attribute(swiftcall)``. This implies support for the +``swift_context``, ``swift_error_result``, and ``swift_indirect_result`` +attributes. + }]; +} + +def SwiftContextDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``swift_context`` attribute marks a parameter of a ``swiftcall`` +function as having the special context-parameter ABI treatment. + +This treatment generally passes the context value in a special register +which is normally callee-preserved. + +A ``swift_context`` parameter must either be the last parameter or must be +followed by a ``swift_error_result`` parameter (which itself must always be +the last parameter). + +A context parameter must have pointer or reference type. + }]; +} + +def SwiftErrorResultDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``swift_error_result`` attribute marks a parameter of a ``swiftcall`` +function as having the special error-result ABI treatment. + +This treatment generally passes the underlying error value in and out of +the function through a special register which is normally callee-preserved. +This is modeled in C by pretending that the register is addressable memory: + +- The caller appears to pass the address of a variable of pointer type. + The current value of this variable is copied into the register before + the call; if the call returns normally, the value is copied back into the + variable. + +- The callee appears to receive the address of a variable. This address + is actually a hidden location in its own stack, initialized with the + value of the register upon entry. When the function returns normally, + the value in that hidden location is written back to the register. + +A ``swift_error_result`` parameter must be the last parameter, and it must be +preceded by a ``swift_context`` parameter. + +A ``swift_error_result`` parameter must have type ``T**`` or ``T*&`` for some +type T. Note that no qualifiers are permitted on the intermediate level. + +It is undefined behavior if the caller does not pass a pointer or +reference to a valid object. + +The standard convention is that the error value itself (that is, the +value stored in the apparent argument) will be null upon function entry, +but this is not enforced by the ABI. + }]; +} + +def SwiftIndirectResultDocs : Documentation { + let Category = DocCatVariable; + let Content = [{ +The ``swift_indirect_result`` attribute marks a parameter of a ``swiftcall`` +function as having the special indirect-result ABI treatmenet. + +This treatment gives the parameter the target's normal indirect-result +ABI treatment, which may involve passing it differently from an ordinary +parameter. However, only the first indirect result will receive this +treatment. Furthermore, low-level lowering may decide that a direct result +must be returned indirectly; if so, this will take priority over the +``swift_indirect_result`` parameters. + +A ``swift_indirect_result`` parameter must either be the first parameter or +follow another ``swift_indirect_result`` parameter. + +A ``swift_indirect_result`` parameter must have type ``T*`` or ``T&`` for +some object type ``T``. If ``T`` is a complete type at the point of +definition of a function, it is undefined behavior if the argument +value does not point to storage of adequate size and alignment for a +value of type ``T``. + +Making indirect results explicit in the signature allows C functions to +directly construct objects into them without relying on language +optimizations like C++'s named return value optimization (NRVO). + }]; +} + +def AbiTagsDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The ``abi_tag`` attribute can be applied to a function, variable, class or +inline namespace declaration to modify the mangled name of the entity. It gives +the ability to distinguish between different versions of the same entity but +with different ABI versions supported. For example, a newer version of a class +could have a different set of data members and thus have a different size. Using +the ``abi_tag`` attribute, it is possible to have different mangled names for +a global variable of the class type. Therefor, the old code could keep using +the old manged name and the new code will use the new mangled name with tags. + }]; +} + +def PreserveMostDocs : Documentation { + let Category = DocCatCallingConvs; + let Content = [{ +On X86-64 and AArch64 targets, this attribute changes the calling convention of +a function. The ``preserve_most`` calling convention attempts to make the code +in the caller as unintrusive as possible. This convention behaves identically +to the ``C`` calling convention on how arguments and return values are passed, +but it uses a different set of caller/callee-saved registers. This alleviates +the burden of saving and recovering a large register set before and after the +call in the caller. If the arguments are passed in callee-saved registers, +then they will be preserved by the callee across the call. This doesn't +apply for values returned in callee-saved registers. + +- On X86-64 the callee preserves all general purpose registers, except for + R11. R11 can be used as a scratch register. Floating-point registers + (XMMs/YMMs) are not preserved and need to be saved by the caller. + +The idea behind this convention is to support calls to runtime functions +that have a hot path and a cold path. The hot path is usually a small piece +of code that doesn't use many registers. The cold path might need to call out to +another function and therefore only needs to preserve the caller-saved +registers, which haven't already been saved by the caller. The +`preserve_most` calling convention is very similar to the ``cold`` calling +convention in terms of caller/callee-saved registers, but they are used for +different types of function calls. ``coldcc`` is for function calls that are +rarely executed, whereas `preserve_most` function calls are intended to be +on the hot path and definitely executed a lot. Furthermore ``preserve_most`` +doesn't prevent the inliner from inlining the function call. + +This calling convention will be used by a future version of the Objective-C +runtime and should therefore still be considered experimental at this time. +Although this convention was created to optimize certain runtime calls to +the Objective-C runtime, it is not limited to this runtime and might be used +by other runtimes in the future too. The current implementation only +supports X86-64 and AArch64, but the intention is to support more architectures +in the future. + }]; +} + +def PreserveAllDocs : Documentation { + let Category = DocCatCallingConvs; + let Content = [{ +On X86-64 and AArch64 targets, this attribute changes the calling convention of +a function. The ``preserve_all`` calling convention attempts to make the code +in the caller even less intrusive than the ``preserve_most`` calling convention. +This calling convention also behaves identical to the ``C`` calling convention +on how arguments and return values are passed, but it uses a different set of +caller/callee-saved registers. This removes the burden of saving and +recovering a large register set before and after the call in the caller. If +the arguments are passed in callee-saved registers, then they will be +preserved by the callee across the call. This doesn't apply for values +returned in callee-saved registers. + +- On X86-64 the callee preserves all general purpose registers, except for + R11. R11 can be used as a scratch register. Furthermore it also preserves + all floating-point registers (XMMs/YMMs). + +The idea behind this convention is to support calls to runtime functions +that don't need to call out to any other functions. + +This calling convention, like the ``preserve_most`` calling convention, will be +used by a future version of the Objective-C runtime and should be considered +experimental at this time. + }]; +} + +def DeprecatedDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +The ``deprecated`` attribute can be applied to a function, a variable, or a +type. This is useful when identifying functions, variables, or types that are +expected to be removed in a future version of a program. + +Consider the function declaration for a hypothetical function ``f``: + +.. code-block:: c++ + + void f(void) __attribute__((deprecated("message", "replacement"))); + +When spelled as `__attribute__((deprecated))`, the deprecated attribute can have +two optional string arguments. The first one is the message to display when +emitting the warning; the second one enables the compiler to provide a Fix-It +to replace the deprecated name with a new name. Otherwise, when spelled as +`[[gnu::deprecated]] or [[deprecated]]`, the attribute can have one optional +string argument which is the message to display when emitting the warning. + }]; +} + +def IFuncDocs : Documentation { + let Category = DocCatFunction; + 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 ``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. + }]; +} + +def LTOVisibilityDocs : Documentation { + let Category = DocCatType; + let Content = [{ +See :doc:`LTOVisibility`. + }]; +} + +def RenderScriptKernelAttributeDocs : Documentation { + let Category = DocCatFunction; + let Content = [{ +``__attribute__((kernel))`` is used to mark a ``kernel`` function in +RenderScript. + +In RenderScript, ``kernel`` functions are used to express data-parallel +computations. The RenderScript runtime efficiently parallelizes ``kernel`` +functions to run on computational resources such as multi-core CPUs and GPUs. +See the RenderScript_ documentation for more information. + +.. _RenderScript: https://developer.android.com/guide/topics/renderscript/compute.html + }]; +} + +def XRayDocs : Documentation { + let Category = DocCatFunction; + let Heading = "xray_always_instrument (clang::xray_always_instrument), xray_never_instrument (clang::xray_never_instrument)"; + 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. + +Conversely, ``__attribute__((xray_never_instrument))`` or ``[[clang::xray_never_instrument]]`` will inhibit the insertion of these instrumentation points. + +If a function has neither of these attributes, they become subject to the XRay heuristics used to determine whether a function should be instrumented or otherwise. + }]; +} diff --git a/include/clang/Basic/AttrKinds.h b/include/clang/Basic/AttrKinds.h index f0b0a6445d40..8f7394f59d4d 100644 --- a/include/clang/Basic/AttrKinds.h +++ b/include/clang/Basic/AttrKinds.h @@ -22,10 +22,10 @@ namespace attr { // \brief A list of all the recognized kinds of attributes. enum Kind { #define ATTR(X) X, -#define LAST_INHERITABLE_ATTR(X) X, LAST_INHERITABLE = X, -#define LAST_INHERITABLE_PARAM_ATTR(X) X, LAST_INHERITABLE_PARAM = X, +#define ATTR_RANGE(CLASS, FIRST_NAME, LAST_NAME) \ + First##CLASS = FIRST_NAME, \ + Last##CLASS = LAST_NAME, #include "clang/Basic/AttrList.inc" - NUM_ATTRS }; } // end namespace attr diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index 4f474ebe42ba..96bb359e51cb 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -67,6 +67,7 @@ // Builtin::Context class. Currently we have: // n -> nothrow // r -> noreturn +// U -> pure // c -> const // t -> signature is meaningless, use custom typechecking // F -> this is a libc/libm function with a '__builtin_' prefix added. @@ -377,6 +378,11 @@ BUILTIN(__builtin_signbit, "i.", "Fnc") BUILTIN(__builtin_signbitf, "if", "Fnc") BUILTIN(__builtin_signbitl, "iLd", "Fnc") +// Special FP builtins. +BUILTIN(__builtin_canonicalize, "dd", "nc") +BUILTIN(__builtin_canonicalizef, "ff", "nc") +BUILTIN(__builtin_canonicalizel, "LdLd", "nc") + // Builtins for arithmetic. BUILTIN(__builtin_clzs , "iUs" , "nc") BUILTIN(__builtin_clz , "iUi" , "nc") @@ -404,6 +410,11 @@ BUILTIN(__builtin_bswap16, "UsUs", "nc") BUILTIN(__builtin_bswap32, "UiUi", "nc") BUILTIN(__builtin_bswap64, "ULLiULLi", "nc") +BUILTIN(__builtin_bitreverse8, "UcUc", "nc") +BUILTIN(__builtin_bitreverse16, "UsUs", "nc") +BUILTIN(__builtin_bitreverse32, "UiUi", "nc") +BUILTIN(__builtin_bitreverse64, "ULLiULLi", "nc") + // Random GCC builtins BUILTIN(__builtin_constant_p, "i.", "nctu") BUILTIN(__builtin_classify_type, "i.", "nctu") @@ -456,6 +467,7 @@ BUILTIN(__builtin_eh_return_data_regno, "iIi", "nc") 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") // GCC exception builtins BUILTIN(__builtin_eh_return, "vzv*", "r") // FIXME: Takes intptr_t, not size_t! @@ -763,6 +775,22 @@ LIBBUILTIN(sscanf, "icC*RcC*R.", "fs:1:", "stdio.h", ALL_LANGUAGES) LIBBUILTIN(vscanf, "icC*Ra", "fS:0:", "stdio.h", ALL_LANGUAGES) LIBBUILTIN(vfscanf, "iP*RcC*Ra", "fS:1:", "stdio.h", ALL_LANGUAGES) LIBBUILTIN(vsscanf, "icC*RcC*Ra", "fS:1:", "stdio.h", ALL_LANGUAGES) +// C99 ctype.h +LIBBUILTIN(isalnum, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isalpha, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isblank, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(iscntrl, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isdigit, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isgraph, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(islower, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isprint, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(ispunct, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isspace, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isupper, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(isxdigit, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(tolower, "ii", "fnU", "ctype.h", ALL_LANGUAGES) +LIBBUILTIN(toupper, "ii", "fnU", "ctype.h", ALL_LANGUAGES) + // C99 // In some systems setjmp is a macro that expands to _setjmp. We undefine // it here to avoid having two identical LIBBUILTIN entries. @@ -1252,6 +1280,43 @@ BUILTIN(__builtin___get_unsafe_stack_ptr, "v*", "Fn") BUILTIN(__builtin_nontemporal_store, "v.", "t") BUILTIN(__builtin_nontemporal_load, "v.", "t") +// OpenCL v2.0 s6.13.16, s9.17.3.5 - Pipe functions. +// We need the generic prototype, since the packet type could be anything. +LANGBUILTIN(read_pipe, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(write_pipe, "i.", "tn", OCLC20_LANG) + +LANGBUILTIN(reserve_read_pipe, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(reserve_write_pipe, "i.", "tn", OCLC20_LANG) + +LANGBUILTIN(commit_write_pipe, "v.", "tn", OCLC20_LANG) +LANGBUILTIN(commit_read_pipe, "v.", "tn", OCLC20_LANG) + +LANGBUILTIN(sub_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(sub_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG) + +LANGBUILTIN(sub_group_commit_read_pipe, "v.", "tn", OCLC20_LANG) +LANGBUILTIN(sub_group_commit_write_pipe, "v.", "tn", OCLC20_LANG) + +LANGBUILTIN(work_group_reserve_read_pipe, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(work_group_reserve_write_pipe, "i.", "tn", OCLC20_LANG) + +LANGBUILTIN(work_group_commit_read_pipe, "v.", "tn", OCLC20_LANG) +LANGBUILTIN(work_group_commit_write_pipe, "v.", "tn", OCLC20_LANG) + +LANGBUILTIN(get_pipe_num_packets, "Ui.", "tn", OCLC20_LANG) +LANGBUILTIN(get_pipe_max_packets, "Ui.", "tn", OCLC20_LANG) + +// OpenCL v2.0 s6.13.17 - Enqueue kernel functions. +// Custom builtin check allows to perform special check of passed block arguments. +LANGBUILTIN(enqueue_kernel, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(get_kernel_work_group_size, "i.", "tn", OCLC20_LANG) +LANGBUILTIN(get_kernel_preferred_work_group_size_multiple, "i.", "tn", OCLC20_LANG) + +// OpenCL v2.0 s6.13.9 - Address space qualifier functions. +LANGBUILTIN(to_global, "v*v*", "tn", OCLC20_LANG) +LANGBUILTIN(to_local, "v*v*", "tn", OCLC20_LANG) +LANGBUILTIN(to_private, "v*v*", "tn", OCLC20_LANG) + #undef BUILTIN #undef LIBBUILTIN #undef LANGBUILTIN diff --git a/include/clang/Basic/Builtins.h b/include/clang/Basic/Builtins.h index c0a6af9e2625..15e9a413fb42 100644 --- a/include/clang/Basic/Builtins.h +++ b/include/clang/Basic/Builtins.h @@ -31,11 +31,12 @@ class QualType; class LangOptions; enum LanguageID { - GNU_LANG = 0x1, // builtin requires GNU mode. - C_LANG = 0x2, // builtin for c only. - CXX_LANG = 0x4, // builtin for cplusplus only. - OBJC_LANG = 0x8, // builtin for objective-c and objective-c++ - MS_LANG = 0x10, // builtin requires MS mode. + GNU_LANG = 0x1, // builtin requires GNU mode. + C_LANG = 0x2, // builtin for c only. + CXX_LANG = 0x4, // builtin for cplusplus only. + OBJC_LANG = 0x8, // builtin for objective-c and objective-c++ + MS_LANG = 0x10, // builtin requires MS mode. + OCLC20_LANG = 0x20, // builtin for OpenCL C only. ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages. ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG, // builtin requires GNU mode. ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG // builtin requires MS mode. @@ -88,11 +89,16 @@ public: return getRecord(ID).Type; } - /// \brief Return true if this function is a target-specific builtin + /// \brief Return true if this function is a target-specific builtin. bool isTSBuiltin(unsigned ID) const { return ID >= Builtin::FirstTSBuiltin; } + /// \brief Return true if this function has no side effects. + bool isPure(unsigned ID) const { + return strchr(getRecord(ID).Attributes, 'U') != nullptr; + } + /// \brief Return true if this function has no side effects and doesn't /// read memory. bool isConst(unsigned ID) const { @@ -154,7 +160,7 @@ public: /// \brief Completely forget that the given ID was ever considered a builtin, /// e.g., because the user provided a conflicting signature. void forgetBuiltin(unsigned ID, IdentifierTable &Table); - + /// \brief If this is a library function that comes from a specific /// header, retrieve that header name. const char *getHeaderName(unsigned ID) const { @@ -213,7 +219,10 @@ private: /// \brief Kinds of BuiltinTemplateDecl. enum BuiltinTemplateKind : int { /// \brief This names the __make_integer_seq BuiltinTemplateDecl. - BTK__make_integer_seq + BTK__make_integer_seq, + + /// \brief This names the __type_pack_element BuiltinTemplateDecl. + BTK__type_pack_element }; } // end namespace clang diff --git a/include/clang/Basic/BuiltinsAArch64.def b/include/clang/Basic/BuiltinsAArch64.def index b4404434e7a8..1db4c1471029 100644 --- a/include/clang/Basic/BuiltinsAArch64.def +++ b/include/clang/Basic/BuiltinsAArch64.def @@ -60,6 +60,5 @@ BUILTIN(__builtin_arm_rsrp, "v*cC*", "nc") BUILTIN(__builtin_arm_wsr, "vcC*Ui", "nc") BUILTIN(__builtin_arm_wsr64, "vcC*LUi", "nc") BUILTIN(__builtin_arm_wsrp, "vcC*vC*", "nc") -BUILTIN(__builtin_thread_pointer, "v*", "nc") #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsAMDGPU.def b/include/clang/Basic/BuiltinsAMDGPU.def index bb9931f7a206..ea63ea10f84c 100644 --- a/include/clang/Basic/BuiltinsAMDGPU.def +++ b/include/clang/Basic/BuiltinsAMDGPU.def @@ -7,30 +7,97 @@ // //===----------------------------------------------------------------------===// // -// This file defines the R600-specific builtin function database. Users of this -// file must define the BUILTIN macro to make use of this information. +// This file defines the AMDGPU-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. -BUILTIN(__builtin_amdgpu_div_scale, "dddbb*", "n") -BUILTIN(__builtin_amdgpu_div_scalef, "fffbb*", "n") -BUILTIN(__builtin_amdgpu_div_fmas, "ddddb", "nc") -BUILTIN(__builtin_amdgpu_div_fmasf, "ffffb", "nc") -BUILTIN(__builtin_amdgpu_div_fixup, "dddd", "nc") -BUILTIN(__builtin_amdgpu_div_fixupf, "ffff", "nc") -BUILTIN(__builtin_amdgpu_trig_preop, "ddi", "nc") -BUILTIN(__builtin_amdgpu_trig_preopf, "ffi", "nc") -BUILTIN(__builtin_amdgpu_rcp, "dd", "nc") -BUILTIN(__builtin_amdgpu_rcpf, "ff", "nc") -BUILTIN(__builtin_amdgpu_rsq, "dd", "nc") -BUILTIN(__builtin_amdgpu_rsqf, "ff", "nc") -BUILTIN(__builtin_amdgpu_rsq_clamped, "dd", "nc") -BUILTIN(__builtin_amdgpu_rsq_clampedf, "ff", "nc") -BUILTIN(__builtin_amdgpu_ldexp, "ddi", "nc") -BUILTIN(__builtin_amdgpu_ldexpf, "ffi", "nc") -BUILTIN(__builtin_amdgpu_class, "bdi", "nc") -BUILTIN(__builtin_amdgpu_classf, "bfi", "nc") +#if defined(BUILTIN) && !defined(TARGET_BUILTIN) +# define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS) +#endif +//===----------------------------------------------------------------------===// +// SI+ only builtins. +//===----------------------------------------------------------------------===// + +BUILTIN(__builtin_amdgcn_kernarg_segment_ptr, "Uc*2", "nc") +BUILTIN(__builtin_amdgcn_implicitarg_ptr, "Uc*2", "nc") + +BUILTIN(__builtin_amdgcn_workgroup_id_x, "Ui", "nc") +BUILTIN(__builtin_amdgcn_workgroup_id_y, "Ui", "nc") +BUILTIN(__builtin_amdgcn_workgroup_id_z, "Ui", "nc") + +BUILTIN(__builtin_amdgcn_workitem_id_x, "Ui", "nc") +BUILTIN(__builtin_amdgcn_workitem_id_y, "Ui", "nc") +BUILTIN(__builtin_amdgcn_workitem_id_z, "Ui", "nc") + +//===----------------------------------------------------------------------===// +// Instruction builtins. +//===----------------------------------------------------------------------===// +BUILTIN(__builtin_amdgcn_s_barrier, "v", "n") +BUILTIN(__builtin_amdgcn_div_scale, "dddbb*", "n") +BUILTIN(__builtin_amdgcn_div_scalef, "fffbb*", "n") +BUILTIN(__builtin_amdgcn_div_fmas, "ddddb", "nc") +BUILTIN(__builtin_amdgcn_div_fmasf, "ffffb", "nc") +BUILTIN(__builtin_amdgcn_div_fixup, "dddd", "nc") +BUILTIN(__builtin_amdgcn_div_fixupf, "ffff", "nc") +BUILTIN(__builtin_amdgcn_trig_preop, "ddi", "nc") +BUILTIN(__builtin_amdgcn_trig_preopf, "ffi", "nc") +BUILTIN(__builtin_amdgcn_rcp, "dd", "nc") +BUILTIN(__builtin_amdgcn_rcpf, "ff", "nc") +BUILTIN(__builtin_amdgcn_rsq, "dd", "nc") +BUILTIN(__builtin_amdgcn_rsqf, "ff", "nc") +BUILTIN(__builtin_amdgcn_rsq_clamp, "dd", "nc") +BUILTIN(__builtin_amdgcn_rsq_clampf, "ff", "nc") +BUILTIN(__builtin_amdgcn_sinf, "ff", "nc") +BUILTIN(__builtin_amdgcn_cosf, "ff", "nc") +BUILTIN(__builtin_amdgcn_log_clampf, "ff", "nc") +BUILTIN(__builtin_amdgcn_ldexp, "ddi", "nc") +BUILTIN(__builtin_amdgcn_ldexpf, "ffi", "nc") +BUILTIN(__builtin_amdgcn_frexp_mant, "dd", "nc") +BUILTIN(__builtin_amdgcn_frexp_mantf, "ff", "nc") +BUILTIN(__builtin_amdgcn_frexp_exp, "id", "nc") +BUILTIN(__builtin_amdgcn_frexp_expf, "if", "nc") +BUILTIN(__builtin_amdgcn_fract, "dd", "nc") +BUILTIN(__builtin_amdgcn_fractf, "ff", "nc") +BUILTIN(__builtin_amdgcn_lerp, "UiUiUiUi", "nc") +BUILTIN(__builtin_amdgcn_class, "bdi", "nc") +BUILTIN(__builtin_amdgcn_classf, "bfi", "nc") +BUILTIN(__builtin_amdgcn_cubeid, "ffff", "nc") +BUILTIN(__builtin_amdgcn_cubesc, "ffff", "nc") +BUILTIN(__builtin_amdgcn_cubetc, "ffff", "nc") +BUILTIN(__builtin_amdgcn_cubema, "ffff", "nc") +BUILTIN(__builtin_amdgcn_s_memtime, "LUi", "n") +BUILTIN(__builtin_amdgcn_s_sleep, "vIi", "n") + +//===----------------------------------------------------------------------===// +// VI+ only builtins. +//===----------------------------------------------------------------------===// + +TARGET_BUILTIN(__builtin_amdgcn_s_memrealtime, "LUi", "n", "s-memrealtime") + +//===----------------------------------------------------------------------===// +// Special builtins. +//===----------------------------------------------------------------------===// +BUILTIN(__builtin_amdgcn_read_exec, "LUi", "nc") + +//===----------------------------------------------------------------------===// +// R600-NI only builtins. +//===----------------------------------------------------------------------===// + +BUILTIN(__builtin_r600_implicitarg_ptr, "Uc*7", "nc") + +BUILTIN(__builtin_r600_read_tgid_x, "Ui", "nc") +BUILTIN(__builtin_r600_read_tgid_y, "Ui", "nc") +BUILTIN(__builtin_r600_read_tgid_z, "Ui", "nc") + +BUILTIN(__builtin_r600_read_tidig_x, "Ui", "nc") +BUILTIN(__builtin_r600_read_tidig_y, "Ui", "nc") +BUILTIN(__builtin_r600_read_tidig_z, "Ui", "nc") + +BUILTIN(__builtin_r600_recipsqrt_ieee, "dd", "nc") +BUILTIN(__builtin_r600_recipsqrt_ieeef, "ff", "nc") #undef BUILTIN +#undef TARGET_BUILTIN diff --git a/include/clang/Basic/BuiltinsARM.def b/include/clang/Basic/BuiltinsARM.def index 3e8e2bf912ad..93b6458c5ef2 100644 --- a/include/clang/Basic/BuiltinsARM.def +++ b/include/clang/Basic/BuiltinsARM.def @@ -20,7 +20,6 @@ // In libgcc BUILTIN(__clear_cache, "vv*v*", "i") -BUILTIN(__builtin_thread_pointer, "v*", "") // Saturating arithmetic BUILTIN(__builtin_arm_qadd, "iii", "nc") @@ -48,14 +47,26 @@ BUILTIN(__builtin_arm_vcvtr_f, "ffi", "nc") BUILTIN(__builtin_arm_vcvtr_d, "fdi", "nc") // Coprocessor +BUILTIN(__builtin_arm_ldc, "vUIiUIivC*", "") +BUILTIN(__builtin_arm_ldcl, "vUIiUIivC*", "") +BUILTIN(__builtin_arm_ldc2, "vUIiUIivC*", "") +BUILTIN(__builtin_arm_ldc2l, "vUIiUIivC*", "") + +BUILTIN(__builtin_arm_stc, "vUIiUIiv*", "") +BUILTIN(__builtin_arm_stcl, "vUIiUIiv*", "") +BUILTIN(__builtin_arm_stc2, "vUIiUIiv*", "") +BUILTIN(__builtin_arm_stc2l, "vUIiUIiv*", "") + +BUILTIN(__builtin_arm_cdp, "vUIiUIiUIiUIiUIiUIi", "") +BUILTIN(__builtin_arm_cdp2, "vUIiUIiUIiUIiUIiUIi", "") BUILTIN(__builtin_arm_mcr, "vUIiUIiUiUIiUIiUIi", "") BUILTIN(__builtin_arm_mcr2, "vUIiUIiUiUIiUIiUIi", "") BUILTIN(__builtin_arm_mrc, "UiUIiUIiUIiUIiUIi", "") BUILTIN(__builtin_arm_mrc2, "UiUIiUIiUIiUIiUIi", "") -BUILTIN(__builtin_arm_cdp, "vUiUiUiUiUiUi", "") -BUILTIN(__builtin_arm_cdp2, "vUiUiUiUiUiUi", "") -BUILTIN(__builtin_arm_mcrr, "vUIiUIiUiUiUIi", "") -BUILTIN(__builtin_arm_mcrr2, "vUIiUIiUiUiUIi", "") +BUILTIN(__builtin_arm_mcrr, "vUIiUIiLLUiUIi", "") +BUILTIN(__builtin_arm_mcrr2, "vUIiUIiLLUiUIi", "") +BUILTIN(__builtin_arm_mrrc, "LLUiUIiUIiUIi", "") +BUILTIN(__builtin_arm_mrrc2, "LLUiUIiUIiUIi", "") // CRC32 BUILTIN(__builtin_arm_crc32b, "UiUiUc", "nc") diff --git a/include/clang/Basic/BuiltinsHexagon.def b/include/clang/Basic/BuiltinsHexagon.def index c071a464b0ac..85936cbfc08e 100644 --- a/include/clang/Basic/BuiltinsHexagon.def +++ b/include/clang/Basic/BuiltinsHexagon.def @@ -18,57 +18,78 @@ // Make sure you do not overwrite these. BUILTIN(__builtin_SI_to_SXTHI_asrh, "ii", "") -BUILTIN(__builtin_circ_ldd, "LLi*LLi*LLi*ii", "") +BUILTIN(__builtin_brev_ldd, "LLi*LLi*LLi*i", "") +BUILTIN(__builtin_brev_ldw, "i*i*i*i", "") +BUILTIN(__builtin_brev_ldh, "s*s*s*i", "") +BUILTIN(__builtin_brev_lduh, "Us*Us*Us*i", "") +BUILTIN(__builtin_brev_ldb, "c*c*c*i", "") +BUILTIN(__builtin_brev_ldub, "Uc*Uc*Uc*i", "") +BUILTIN(__builtin_circ_ldd, "LLi*LLi*LLi*iIi", "") +BUILTIN(__builtin_circ_ldw, "i*i*i*iIi", "") +BUILTIN(__builtin_circ_ldh, "s*s*s*iIi", "") +BUILTIN(__builtin_circ_lduh, "Us*Us*Us*iIi", "") +BUILTIN(__builtin_circ_ldb, "c*c*c*iIi", "") +BUILTIN(__builtin_circ_ldub, "Uc*Uc*Uc*iIi", "") +BUILTIN(__builtin_brev_std, "LLi*LLi*LLii", "") +BUILTIN(__builtin_brev_stw, "i*i*ii", "") +BUILTIN(__builtin_brev_sth, "s*s*ii", "") +BUILTIN(__builtin_brev_sthhi, "s*s*ii", "") +BUILTIN(__builtin_brev_stb, "c*c*ii", "") +BUILTIN(__builtin_circ_std, "LLi*LLi*LLiiIi", "") +BUILTIN(__builtin_circ_stw, "i*i*iiIi", "") +BUILTIN(__builtin_circ_sth, "s*s*iiIi", "") +BUILTIN(__builtin_circ_sthhi, "s*s*iiIi", "") +BUILTIN(__builtin_circ_stb, "c*c*iiIi", "") // The builtins above are not autogenerated from iset.py. // Make sure you do not overwrite these. -BUILTIN(__builtin_HEXAGON_C2_cmpeq,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgt,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtu,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpeqp,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtp,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtup,"bLLiLLi","") +BUILTIN(__builtin_HEXAGON_C2_cmpeq,"iii","") +BUILTIN(__builtin_HEXAGON_C2_cmpgt,"iii","") +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,"bii","") -BUILTIN(__builtin_HEXAGON_C2_bitsclr,"bii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsset,"bii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsclr,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpeqi,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgti,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgtui,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgei,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpgeui,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmplt,"bii","") -BUILTIN(__builtin_HEXAGON_C2_cmpltu,"bii","") -BUILTIN(__builtin_HEXAGON_C2_bitsclri,"bii","") -BUILTIN(__builtin_HEXAGON_C4_nbitsclri,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmpneqi,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmpltei,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmplteui,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmpneq,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmplte,"bii","") -BUILTIN(__builtin_HEXAGON_C4_cmplteu,"bii","") -BUILTIN(__builtin_HEXAGON_C2_and,"bii","") -BUILTIN(__builtin_HEXAGON_C2_or,"bii","") -BUILTIN(__builtin_HEXAGON_C2_xor,"bii","") -BUILTIN(__builtin_HEXAGON_C2_andn,"bii","") -BUILTIN(__builtin_HEXAGON_C2_not,"bi","") -BUILTIN(__builtin_HEXAGON_C2_orn,"bii","") -BUILTIN(__builtin_HEXAGON_C4_and_and,"biii","") -BUILTIN(__builtin_HEXAGON_C4_and_or,"biii","") -BUILTIN(__builtin_HEXAGON_C4_or_and,"biii","") -BUILTIN(__builtin_HEXAGON_C4_or_or,"biii","") -BUILTIN(__builtin_HEXAGON_C4_and_andn,"biii","") -BUILTIN(__builtin_HEXAGON_C4_and_orn,"biii","") -BUILTIN(__builtin_HEXAGON_C4_or_andn,"biii","") -BUILTIN(__builtin_HEXAGON_C4_or_orn,"biii","") -BUILTIN(__builtin_HEXAGON_C2_pxfer_map,"bi","") -BUILTIN(__builtin_HEXAGON_C2_any8,"bi","") -BUILTIN(__builtin_HEXAGON_C2_all8,"bi","") +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_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","") @@ -76,43 +97,43 @@ 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,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbeqi,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbeq_any,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpbgtu,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgtui,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgt,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpbgti,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbeq,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbeqi,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgtu,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgtui,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgt,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpbgti,"bii","") -BUILTIN(__builtin_HEXAGON_A2_vcmpheq,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmphgt,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmphgtu,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpheqi,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmphgti,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmphgtui,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_cmpheq,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgt,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgtu,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmpheqi,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgti,"bii","") -BUILTIN(__builtin_HEXAGON_A4_cmphgtui,"bii","") -BUILTIN(__builtin_HEXAGON_A2_vcmpweq,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpwgt,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A2_vcmpwgtu,"bLLiLLi","") -BUILTIN(__builtin_HEXAGON_A4_vcmpweqi,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpwgti,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_vcmpwgtui,"bLLii","") -BUILTIN(__builtin_HEXAGON_A4_boundscheck,"biLLi","") -BUILTIN(__builtin_HEXAGON_A4_tlbmatch,"bLLii","") +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_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_A4_boundscheck,"iiLLi","") +BUILTIN(__builtin_HEXAGON_A4_tlbmatch,"iLLii","") BUILTIN(__builtin_HEXAGON_C2_tfrpr,"ii","") -BUILTIN(__builtin_HEXAGON_C2_tfrrp,"bi","") -BUILTIN(__builtin_HEXAGON_C4_fastcorner9,"bii","") -BUILTIN(__builtin_HEXAGON_C4_fastcorner9_not,"bii","") +BUILTIN(__builtin_HEXAGON_C2_tfrrp,"ii","") +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","") @@ -620,38 +641,25 @@ 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,"bff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpgt,"bff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpge,"bff","") -BUILTIN(__builtin_HEXAGON_F2_sfcmpuo,"bff","") +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,"bfi","") +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_dfadd,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dfsub,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dfmpy,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dffma,"dddd","") -BUILTIN(__builtin_HEXAGON_F2_dffms,"dddd","") -BUILTIN(__builtin_HEXAGON_F2_dffma_lib,"dddd","") -BUILTIN(__builtin_HEXAGON_F2_dffms_lib,"dddd","") -BUILTIN(__builtin_HEXAGON_F2_dffma_sc,"ddddi","") -BUILTIN(__builtin_HEXAGON_F2_dfmax,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dfmin,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpeq,"bdd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpgt,"bdd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpge,"bdd","") -BUILTIN(__builtin_HEXAGON_F2_dfcmpuo,"bdd","") -BUILTIN(__builtin_HEXAGON_F2_dfclass,"bdi","") +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_dffixupn,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dffixupd,"ddd","") -BUILTIN(__builtin_HEXAGON_F2_dffixupr,"dd","") BUILTIN(__builtin_HEXAGON_F2_conv_sf2df,"df","") BUILTIN(__builtin_HEXAGON_F2_conv_df2sf,"fd","") BUILTIN(__builtin_HEXAGON_F2_conv_uw2sf,"fi","") @@ -797,13 +805,13 @@ 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,"bii","") -BUILTIN(__builtin_HEXAGON_S4_ntstbit_i,"bii","") +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,"bii","") -BUILTIN(__builtin_HEXAGON_S4_ntstbit_r,"bii","") +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","") @@ -875,4 +883,623 @@ BUILTIN(__builtin_HEXAGON_S2_ct1p,"iLLi","") BUILTIN(__builtin_HEXAGON_S2_interleave,"LLiLLi","") BUILTIN(__builtin_HEXAGON_S2_deinterleave,"LLiLLi","") +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_vlutb,"V16iV16iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_128B,"V32iV32iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_acc,"V16iV16iV16iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_acc_128B,"V32iV32iV32iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_dv,"V32iV32iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_dv_128B,"V64iV64iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_dv_acc,"V32iV32iV32iLLii","v:60:") +BUILTIN(__builtin_HEXAGON_V6_vlutb_dv_acc_128B,"V64iV64iV64iLLii","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:") + +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:") + #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsNVPTX.def b/include/clang/Basic/BuiltinsNVPTX.def index 3ab6413bb0ec..456d0001a12d 100644 --- a/include/clang/Basic/BuiltinsNVPTX.def +++ b/include/clang/Basic/BuiltinsNVPTX.def @@ -14,53 +14,50 @@ // The format of this database matches clang/Basic/Builtins.def. -// Builtins retained from previous PTX back-end -BUILTIN(__builtin_ptx_read_tid_x, "i", "nc") -BUILTIN(__builtin_ptx_read_tid_y, "i", "nc") -BUILTIN(__builtin_ptx_read_tid_z, "i", "nc") -BUILTIN(__builtin_ptx_read_tid_w, "i", "nc") +// Special Registers -BUILTIN(__builtin_ptx_read_ntid_x, "i", "nc") -BUILTIN(__builtin_ptx_read_ntid_y, "i", "nc") -BUILTIN(__builtin_ptx_read_ntid_z, "i", "nc") -BUILTIN(__builtin_ptx_read_ntid_w, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_tid_x, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_tid_y, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_tid_z, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_tid_w, "i", "nc") -BUILTIN(__builtin_ptx_read_ctaid_x, "i", "nc") -BUILTIN(__builtin_ptx_read_ctaid_y, "i", "nc") -BUILTIN(__builtin_ptx_read_ctaid_z, "i", "nc") -BUILTIN(__builtin_ptx_read_ctaid_w, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ntid_x, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ntid_y, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ntid_z, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ntid_w, "i", "nc") -BUILTIN(__builtin_ptx_read_nctaid_x, "i", "nc") -BUILTIN(__builtin_ptx_read_nctaid_y, "i", "nc") -BUILTIN(__builtin_ptx_read_nctaid_z, "i", "nc") -BUILTIN(__builtin_ptx_read_nctaid_w, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ctaid_x, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ctaid_y, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ctaid_z, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_ctaid_w, "i", "nc") -BUILTIN(__builtin_ptx_read_laneid, "i", "nc") -BUILTIN(__builtin_ptx_read_warpid, "i", "nc") -BUILTIN(__builtin_ptx_read_nwarpid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nctaid_x, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nctaid_y, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nctaid_z, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nctaid_w, "i", "nc") -BUILTIN(__builtin_ptx_read_smid, "i", "nc") -BUILTIN(__builtin_ptx_read_nsmid, "i", "nc") -BUILTIN(__builtin_ptx_read_gridid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_laneid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_warpid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nwarpid, "i", "nc") -BUILTIN(__builtin_ptx_read_lanemask_eq, "i", "nc") -BUILTIN(__builtin_ptx_read_lanemask_le, "i", "nc") -BUILTIN(__builtin_ptx_read_lanemask_lt, "i", "nc") -BUILTIN(__builtin_ptx_read_lanemask_ge, "i", "nc") -BUILTIN(__builtin_ptx_read_lanemask_gt, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_smid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_nsmid, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_gridid, "i", "nc") -BUILTIN(__builtin_ptx_read_clock, "i", "n") -BUILTIN(__builtin_ptx_read_clock64, "LLi", "n") +BUILTIN(__nvvm_read_ptx_sreg_lanemask_eq, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_lanemask_le, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_lanemask_lt, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_lanemask_ge, "i", "nc") +BUILTIN(__nvvm_read_ptx_sreg_lanemask_gt, "i", "nc") -BUILTIN(__builtin_ptx_read_pm0, "i", "n") -BUILTIN(__builtin_ptx_read_pm1, "i", "n") -BUILTIN(__builtin_ptx_read_pm2, "i", "n") -BUILTIN(__builtin_ptx_read_pm3, "i", "n") +BUILTIN(__nvvm_read_ptx_sreg_clock, "i", "n") +BUILTIN(__nvvm_read_ptx_sreg_clock64, "LLi", "n") -BUILTIN(__builtin_ptx_bar_sync, "vi", "n") +BUILTIN(__nvvm_read_ptx_sreg_pm0, "i", "n") +BUILTIN(__nvvm_read_ptx_sreg_pm1, "i", "n") +BUILTIN(__nvvm_read_ptx_sreg_pm2, "i", "n") +BUILTIN(__nvvm_read_ptx_sreg_pm3, "i", "n") - -// Builtins exposed as part of NVVM // MISC BUILTIN(__nvvm_clz_i, "ii", "") @@ -397,10 +394,21 @@ BUILTIN(__nvvm_bitcast_d2ll, "LLid", "") // Sync BUILTIN(__syncthreads, "v", "") -BUILTIN(__nvvm_bar0, "v", "") BUILTIN(__nvvm_bar0_popc, "ii", "") BUILTIN(__nvvm_bar0_and, "ii", "") BUILTIN(__nvvm_bar0_or, "ii", "") +BUILTIN(__nvvm_bar_sync, "vi", "n") + +// Shuffle + +BUILTIN(__nvvm_shfl_down_i32, "iiii", "") +BUILTIN(__nvvm_shfl_down_f32, "ffii", "") +BUILTIN(__nvvm_shfl_up_i32, "iiii", "") +BUILTIN(__nvvm_shfl_up_f32, "ffii", "") +BUILTIN(__nvvm_shfl_bfly_i32, "iiii", "") +BUILTIN(__nvvm_shfl_bfly_f32, "ffii", "") +BUILTIN(__nvvm_shfl_idx_i32, "iiii", "") +BUILTIN(__nvvm_shfl_idx_f32, "ffii", "") // Membar @@ -566,4 +574,40 @@ BUILTIN(__nvvm_atom_cas_gen_ll, "LLiLLiD*LLiLLi", "n") BUILTIN(__nvvm_compiler_error, "vcC*4", "n") BUILTIN(__nvvm_compiler_warn, "vcC*4", "n") +// __ldg. This is not implemented as a builtin by nvcc. +BUILTIN(__nvvm_ldg_c, "ccC*", "") +BUILTIN(__nvvm_ldg_s, "ssC*", "") +BUILTIN(__nvvm_ldg_i, "iiC*", "") +BUILTIN(__nvvm_ldg_l, "LiLiC*", "") +BUILTIN(__nvvm_ldg_ll, "LLiLLiC*", "") + +BUILTIN(__nvvm_ldg_uc, "UcUcC*", "") +BUILTIN(__nvvm_ldg_us, "UsUsC*", "") +BUILTIN(__nvvm_ldg_ui, "UiUiC*", "") +BUILTIN(__nvvm_ldg_ul, "ULiULiC*", "") +BUILTIN(__nvvm_ldg_ull, "ULLiULLiC*", "") + +BUILTIN(__nvvm_ldg_f, "ffC*", "") +BUILTIN(__nvvm_ldg_d, "ddC*", "") + +BUILTIN(__nvvm_ldg_c2, "E2cE2cC*", "") +BUILTIN(__nvvm_ldg_c4, "E4cE4cC*", "") +BUILTIN(__nvvm_ldg_s2, "E2sE2sC*", "") +BUILTIN(__nvvm_ldg_s4, "E4sE4sC*", "") +BUILTIN(__nvvm_ldg_i2, "E2iE2iC*", "") +BUILTIN(__nvvm_ldg_i4, "E4iE4iC*", "") +BUILTIN(__nvvm_ldg_ll2, "E2LLiE2LLiC*", "") + +BUILTIN(__nvvm_ldg_uc2, "E2UcE2UcC*", "") +BUILTIN(__nvvm_ldg_uc4, "E4UcE4UcC*", "") +BUILTIN(__nvvm_ldg_us2, "E2UsE2UsC*", "") +BUILTIN(__nvvm_ldg_us4, "E4UsE4UsC*", "") +BUILTIN(__nvvm_ldg_ui2, "E2UiE2UiC*", "") +BUILTIN(__nvvm_ldg_ui4, "E4UiE4UiC*", "") +BUILTIN(__nvvm_ldg_ull2, "E2ULLiE2ULLiC*", "") + +BUILTIN(__nvvm_ldg_f2, "E2fE2fC*", "") +BUILTIN(__nvvm_ldg_f4, "E4fE4fC*", "") +BUILTIN(__nvvm_ldg_d2, "E2dE2dC*", "") + #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsPPC.def b/include/clang/Basic/BuiltinsPPC.def index 5681c1f2ae1a..365dcc02a46d 100644 --- a/include/clang/Basic/BuiltinsPPC.def +++ b/include/clang/Basic/BuiltinsPPC.def @@ -336,6 +336,9 @@ BUILTIN(__builtin_vsx_xxleqv, "V4UiV4UiV4Ui", "") BUILTIN(__builtin_vsx_xvcpsgndp, "V2dV2dV2d", "") BUILTIN(__builtin_vsx_xvcpsgnsp, "V4fV4fV4f", "") +BUILTIN(__builtin_vsx_xvabssp, "V4fV4f", "") +BUILTIN(__builtin_vsx_xvabsdp, "V2dV2d", "") + // HTM builtins BUILTIN(__builtin_tbegin, "UiUIi", "") BUILTIN(__builtin_tend, "UiUIi", "") diff --git a/include/clang/Basic/BuiltinsSystemZ.def b/include/clang/Basic/BuiltinsSystemZ.def index 68d5a1c94407..fa96e10b3990 100644 --- a/include/clang/Basic/BuiltinsSystemZ.def +++ b/include/clang/Basic/BuiltinsSystemZ.def @@ -14,239 +14,244 @@ // 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 + // Transactional-memory intrinsics -BUILTIN(__builtin_tbegin, "iv*", "j") -BUILTIN(__builtin_tbegin_nofloat, "iv*", "j") -BUILTIN(__builtin_tbeginc, "v", "nj") -BUILTIN(__builtin_tabort, "vi", "r") -BUILTIN(__builtin_tend, "i", "n") -BUILTIN(__builtin_tx_nesting_depth, "i", "nc") -BUILTIN(__builtin_tx_assist, "vi", "n") -BUILTIN(__builtin_non_tx_store, "vULi*ULi", "") +TARGET_BUILTIN(__builtin_tbegin, "iv*", "j", "transactional-execution") +TARGET_BUILTIN(__builtin_tbegin_nofloat, "iv*", "j", "transactional-execution") +TARGET_BUILTIN(__builtin_tbeginc, "v", "nj", "transactional-execution") +TARGET_BUILTIN(__builtin_tabort, "vi", "r", "transactional-execution") +TARGET_BUILTIN(__builtin_tend, "i", "n", "transactional-execution") +TARGET_BUILTIN(__builtin_tx_nesting_depth, "i", "nc", "transactional-execution") +TARGET_BUILTIN(__builtin_tx_assist, "vi", "n", "transactional-execution") +TARGET_BUILTIN(__builtin_non_tx_store, "vULi*ULi", "", "transactional-execution") // Vector intrinsics. // These all map directly to z instructions, except that some variants ending // in "s" have a final "int *" that receives the post-instruction CC value. // Vector support instructions (chapter 21 of the PoP) -BUILTIN(__builtin_s390_lcbb, "UivC*Ii", "nc") -BUILTIN(__builtin_s390_vlbb, "V16ScvC*Ii", "") -BUILTIN(__builtin_s390_vll, "V16ScUivC*", "") -BUILTIN(__builtin_s390_vstl, "vV16ScUiv*", "") -BUILTIN(__builtin_s390_vperm, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vpdi, "V2ULLiV2ULLiV2ULLiIi", "nc") -BUILTIN(__builtin_s390_vpksh, "V16ScV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vpkshs, "V16ScV8SsV8Ssi*", "nc") -BUILTIN(__builtin_s390_vpksf, "V8SsV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vpksfs, "V8SsV4SiV4Sii*", "nc") -BUILTIN(__builtin_s390_vpksg, "V4SiV2SLLiV2SLLi", "nc") -BUILTIN(__builtin_s390_vpksgs, "V4SiV2SLLiV2SLLii*", "nc") -BUILTIN(__builtin_s390_vpklsh, "V16UcV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vpklshs, "V16UcV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vpklsf, "V8UsV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vpklsfs, "V8UsV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vpklsg, "V4UiV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vpklsgs, "V4UiV2ULLiV2ULLii*", "nc") -BUILTIN(__builtin_s390_vuphb, "V8SsV16Sc", "nc") -BUILTIN(__builtin_s390_vuphh, "V4SiV8Ss", "nc") -BUILTIN(__builtin_s390_vuphf, "V2SLLiV4Si", "nc") -BUILTIN(__builtin_s390_vuplb, "V8SsV16Sc", "nc") -BUILTIN(__builtin_s390_vuplhw, "V4SiV8Ss", "nc") -BUILTIN(__builtin_s390_vuplf, "V2SLLiV4Si", "nc") -BUILTIN(__builtin_s390_vuplhb, "V8UsV16Uc", "nc") -BUILTIN(__builtin_s390_vuplhh, "V4UiV8Us", "nc") -BUILTIN(__builtin_s390_vuplhf, "V2ULLiV4Ui", "nc") -BUILTIN(__builtin_s390_vupllb, "V8UsV16Uc", "nc") -BUILTIN(__builtin_s390_vupllh, "V4UiV8Us", "nc") -BUILTIN(__builtin_s390_vupllf, "V2ULLiV4Ui", "nc") +TARGET_BUILTIN(__builtin_s390_lcbb, "UivC*Ii", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vlbb, "V16ScvC*Ii", "", "vector") +TARGET_BUILTIN(__builtin_s390_vll, "V16ScUivC*", "", "vector") +TARGET_BUILTIN(__builtin_s390_vstl, "vV16ScUiv*", "", "vector") +TARGET_BUILTIN(__builtin_s390_vperm, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpdi, "V2ULLiV2ULLiV2ULLiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpksh, "V16ScV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpkshs, "V16ScV8SsV8Ssi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpksf, "V8SsV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpksfs, "V8SsV4SiV4Sii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpksg, "V4SiV2SLLiV2SLLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpksgs, "V4SiV2SLLiV2SLLii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklsh, "V16UcV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklshs, "V16UcV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklsf, "V8UsV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklsfs, "V8UsV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklsg, "V4UiV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpklsgs, "V4UiV2ULLiV2ULLii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuphb, "V8SsV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuphh, "V4SiV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuphf, "V2SLLiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplb, "V8SsV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplhw, "V4SiV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplf, "V2SLLiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplhb, "V8UsV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplhh, "V4UiV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vuplhf, "V2ULLiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vupllb, "V8UsV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vupllh, "V4UiV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vupllf, "V2ULLiV4Ui", "nc", "vector") // Vector integer instructions (chapter 22 of the PoP) -BUILTIN(__builtin_s390_vaq, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vacq, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vaccb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vacch, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vaccf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vaccg, "V2ULLiV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vaccq, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vacccq, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vavgb, "V16ScV16ScV16Sc", "nc") -BUILTIN(__builtin_s390_vavgh, "V8SsV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vavgf, "V4SiV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vavgg, "V2SLLiV2SLLiV2SLLi", "nc") -BUILTIN(__builtin_s390_vavglb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vavglh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vavglf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vavglg, "V2ULLiV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vceqbs, "V16ScV16ScV16Sci*", "nc") -BUILTIN(__builtin_s390_vceqhs, "V8SsV8SsV8Ssi*", "nc") -BUILTIN(__builtin_s390_vceqfs, "V4SiV4SiV4Sii*", "nc") -BUILTIN(__builtin_s390_vceqgs, "V2SLLiV2SLLiV2SLLii*", "nc") -BUILTIN(__builtin_s390_vchbs, "V16ScV16ScV16Sci*", "nc") -BUILTIN(__builtin_s390_vchhs, "V8SsV8SsV8Ssi*", "nc") -BUILTIN(__builtin_s390_vchfs, "V4SiV4SiV4Sii*", "nc") -BUILTIN(__builtin_s390_vchgs, "V2SLLiV2SLLiV2SLLii*", "nc") -BUILTIN(__builtin_s390_vchlbs, "V16ScV16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vchlhs, "V8SsV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vchlfs, "V4SiV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vchlgs, "V2SLLiV2ULLiV2ULLii*", "nc") -BUILTIN(__builtin_s390_vcksm, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vclzb, "V16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vclzh, "V8UsV8Us", "nc") -BUILTIN(__builtin_s390_vclzf, "V4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vclzg, "V2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vctzb, "V16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vctzh, "V8UsV8Us", "nc") -BUILTIN(__builtin_s390_vctzf, "V4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vctzg, "V2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_verimb, "V16UcV16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_verimh, "V8UsV8UsV8UsV8UsIi", "nc") -BUILTIN(__builtin_s390_verimf, "V4UiV4UiV4UiV4UiIi", "nc") -BUILTIN(__builtin_s390_verimg, "V2ULLiV2ULLiV2ULLiV2ULLiIi", "nc") -BUILTIN(__builtin_s390_verllb, "V16UcV16UcUi", "nc") -BUILTIN(__builtin_s390_verllh, "V8UsV8UsUi", "nc") -BUILTIN(__builtin_s390_verllf, "V4UiV4UiUi", "nc") -BUILTIN(__builtin_s390_verllg, "V2ULLiV2ULLiUi", "nc") -BUILTIN(__builtin_s390_verllvb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_verllvh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_verllvf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_verllvg, "V2ULLiV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vgfmb, "V8UsV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vgfmh, "V4UiV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vgfmf, "V2ULLiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vgfmg, "V16UcV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vgfmab, "V8UsV16UcV16UcV8Us", "nc") -BUILTIN(__builtin_s390_vgfmah, "V4UiV8UsV8UsV4Ui", "nc") -BUILTIN(__builtin_s390_vgfmaf, "V2ULLiV4UiV4UiV2ULLi", "nc") -BUILTIN(__builtin_s390_vgfmag, "V16UcV2ULLiV2ULLiV16Uc", "nc") -BUILTIN(__builtin_s390_vmahb, "V16ScV16ScV16ScV16Sc", "nc") -BUILTIN(__builtin_s390_vmahh, "V8SsV8SsV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vmahf, "V4SiV4SiV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vmalhb, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vmalhh, "V8UsV8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vmalhf, "V4UiV4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vmaeb, "V8SsV16ScV16ScV8Ss", "nc") -BUILTIN(__builtin_s390_vmaeh, "V4SiV8SsV8SsV4Si", "nc") -BUILTIN(__builtin_s390_vmaef, "V2SLLiV4SiV4SiV2SLLi", "nc") -BUILTIN(__builtin_s390_vmaleb, "V8UsV16UcV16UcV8Us", "nc") -BUILTIN(__builtin_s390_vmaleh, "V4UiV8UsV8UsV4Ui", "nc") -BUILTIN(__builtin_s390_vmalef, "V2ULLiV4UiV4UiV2ULLi", "nc") -BUILTIN(__builtin_s390_vmaob, "V8SsV16ScV16ScV8Ss", "nc") -BUILTIN(__builtin_s390_vmaoh, "V4SiV8SsV8SsV4Si", "nc") -BUILTIN(__builtin_s390_vmaof, "V2SLLiV4SiV4SiV2SLLi", "nc") -BUILTIN(__builtin_s390_vmalob, "V8UsV16UcV16UcV8Us", "nc") -BUILTIN(__builtin_s390_vmaloh, "V4UiV8UsV8UsV4Ui", "nc") -BUILTIN(__builtin_s390_vmalof, "V2ULLiV4UiV4UiV2ULLi", "nc") -BUILTIN(__builtin_s390_vmhb, "V16ScV16ScV16Sc", "nc") -BUILTIN(__builtin_s390_vmhh, "V8SsV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vmhf, "V4SiV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vmlhb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vmlhh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vmlhf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vmeb, "V8SsV16ScV16Sc", "nc") -BUILTIN(__builtin_s390_vmeh, "V4SiV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vmef, "V2SLLiV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vmleb, "V8UsV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vmleh, "V4UiV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vmlef, "V2ULLiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vmob, "V8SsV16ScV16Sc", "nc") -BUILTIN(__builtin_s390_vmoh, "V4SiV8SsV8Ss", "nc") -BUILTIN(__builtin_s390_vmof, "V2SLLiV4SiV4Si", "nc") -BUILTIN(__builtin_s390_vmlob, "V8UsV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vmloh, "V4UiV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vmlof, "V2ULLiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vpopctb, "V16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vpopcth, "V8UsV8Us", "nc") -BUILTIN(__builtin_s390_vpopctf, "V4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vpopctg, "V2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vsq, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsbcbiq, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsbiq, "V16UcV16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vscbib, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vscbih, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vscbif, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vscbig, "V2ULLiV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vscbiq, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsl, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vslb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsldb, "V16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_vsra, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsrab, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsrl, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsrlb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsumb, "V4UiV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vsumh, "V4UiV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vsumgh, "V2ULLiV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vsumgf, "V2ULLiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vsumqf, "V16UcV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vsumqg, "V16UcV2ULLiV2ULLi", "nc") -BUILTIN(__builtin_s390_vtm, "iV16UcV16Uc", "nc") +TARGET_BUILTIN(__builtin_s390_vaq, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vacq, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vaccb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vacch, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vaccf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vaccg, "V2ULLiV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vaccq, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vacccq, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavgb, "V16ScV16ScV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavgh, "V8SsV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavgf, "V4SiV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavgg, "V2SLLiV2SLLiV2SLLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavglb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavglh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavglf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vavglg, "V2ULLiV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vceqbs, "V16ScV16ScV16Sci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vceqhs, "V8SsV8SsV8Ssi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vceqfs, "V4SiV4SiV4Sii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vceqgs, "V2SLLiV2SLLiV2SLLii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchbs, "V16ScV16ScV16Sci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchhs, "V8SsV8SsV8Ssi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchfs, "V4SiV4SiV4Sii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchgs, "V2SLLiV2SLLiV2SLLii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchlbs, "V16ScV16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchlhs, "V8SsV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchlfs, "V4SiV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vchlgs, "V2SLLiV2ULLiV2ULLii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vcksm, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vclzb, "V16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vclzh, "V8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vclzf, "V4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vclzg, "V2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vctzb, "V16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vctzh, "V8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vctzf, "V4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vctzg, "V2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verimb, "V16UcV16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verimh, "V8UsV8UsV8UsV8UsIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verimf, "V4UiV4UiV4UiV4UiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verimg, "V2ULLiV2ULLiV2ULLiV2ULLiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllb, "V16UcV16UcUi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllh, "V8UsV8UsUi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllf, "V4UiV4UiUi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllg, "V2ULLiV2ULLiUi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllvb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllvh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllvf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_verllvg, "V2ULLiV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmb, "V8UsV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmh, "V4UiV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmf, "V2ULLiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmg, "V16UcV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmab, "V8UsV16UcV16UcV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmah, "V4UiV8UsV8UsV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmaf, "V2ULLiV4UiV4UiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vgfmag, "V16UcV2ULLiV2ULLiV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmahb, "V16ScV16ScV16ScV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmahh, "V8SsV8SsV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmahf, "V4SiV4SiV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalhb, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalhh, "V8UsV8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalhf, "V4UiV4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaeb, "V8SsV16ScV16ScV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaeh, "V4SiV8SsV8SsV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaef, "V2SLLiV4SiV4SiV2SLLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaleb, "V8UsV16UcV16UcV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaleh, "V4UiV8UsV8UsV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalef, "V2ULLiV4UiV4UiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaob, "V8SsV16ScV16ScV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaoh, "V4SiV8SsV8SsV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaof, "V2SLLiV4SiV4SiV2SLLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalob, "V8UsV16UcV16UcV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmaloh, "V4UiV8UsV8UsV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmalof, "V2ULLiV4UiV4UiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmhb, "V16ScV16ScV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmhh, "V8SsV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmhf, "V4SiV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlhb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlhh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlhf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmeb, "V8SsV16ScV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmeh, "V4SiV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmef, "V2SLLiV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmleb, "V8UsV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmleh, "V4UiV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlef, "V2ULLiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmob, "V8SsV16ScV16Sc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmoh, "V4SiV8SsV8Ss", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmof, "V2SLLiV4SiV4Si", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlob, "V8UsV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmloh, "V4UiV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vmlof, "V2ULLiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpopctb, "V16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpopcth, "V8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpopctf, "V4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vpopctg, "V2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsq, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsbcbiq, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsbiq, "V16UcV16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vscbib, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vscbih, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vscbif, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vscbig, "V2ULLiV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vscbiq, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsl, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vslb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsldb, "V16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsra, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsrab, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsrl, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsrlb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumb, "V4UiV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumh, "V4UiV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumgh, "V2ULLiV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumgf, "V2ULLiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumqf, "V16UcV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vsumqg, "V16UcV2ULLiV2ULLi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vtm, "iV16UcV16Uc", "nc", "vector") // Vector string instructions (chapter 23 of the PoP) -BUILTIN(__builtin_s390_vfaeb, "V16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_vfaebs, "V16UcV16UcV16UcIii*", "nc") -BUILTIN(__builtin_s390_vfaeh, "V8UsV8UsV8UsIi", "nc") -BUILTIN(__builtin_s390_vfaehs, "V8UsV8UsV8UsIii*", "nc") -BUILTIN(__builtin_s390_vfaef, "V4UiV4UiV4UiIi", "nc") -BUILTIN(__builtin_s390_vfaefs, "V4UiV4UiV4UiIii*", "nc") -BUILTIN(__builtin_s390_vfaezb, "V16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_vfaezbs, "V16UcV16UcV16UcIii*", "nc") -BUILTIN(__builtin_s390_vfaezh, "V8UsV8UsV8UsIi", "nc") -BUILTIN(__builtin_s390_vfaezhs, "V8UsV8UsV8UsIii*", "nc") -BUILTIN(__builtin_s390_vfaezf, "V4UiV4UiV4UiIi", "nc") -BUILTIN(__builtin_s390_vfaezfs, "V4UiV4UiV4UiIii*", "nc") -BUILTIN(__builtin_s390_vfeeb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vfeebs, "V16UcV16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vfeeh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vfeehs, "V8UsV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vfeef, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vfeefs, "V4UiV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vfeezb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vfeezbs, "V16UcV16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vfeezh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vfeezhs, "V8UsV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vfeezf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vfeezfs, "V4UiV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vfeneb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vfenebs, "V16UcV16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vfeneh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vfenehs, "V8UsV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vfenef, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vfenefs, "V4UiV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vfenezb, "V16UcV16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vfenezbs, "V16UcV16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vfenezh, "V8UsV8UsV8Us", "nc") -BUILTIN(__builtin_s390_vfenezhs, "V8UsV8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vfenezf, "V4UiV4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vfenezfs, "V4UiV4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vistrb, "V16UcV16Uc", "nc") -BUILTIN(__builtin_s390_vistrbs, "V16UcV16Uci*", "nc") -BUILTIN(__builtin_s390_vistrh, "V8UsV8Us", "nc") -BUILTIN(__builtin_s390_vistrhs, "V8UsV8Usi*", "nc") -BUILTIN(__builtin_s390_vistrf, "V4UiV4Ui", "nc") -BUILTIN(__builtin_s390_vistrfs, "V4UiV4Uii*", "nc") -BUILTIN(__builtin_s390_vstrcb, "V16UcV16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_vstrcbs, "V16UcV16UcV16UcV16UcIii*", "nc") -BUILTIN(__builtin_s390_vstrch, "V8UsV8UsV8UsV8UsIi", "nc") -BUILTIN(__builtin_s390_vstrchs, "V8UsV8UsV8UsV8UsIii*", "nc") -BUILTIN(__builtin_s390_vstrcf, "V4UiV4UiV4UiV4UiIi", "nc") -BUILTIN(__builtin_s390_vstrcfs, "V4UiV4UiV4UiV4UiIii*", "nc") -BUILTIN(__builtin_s390_vstrczb, "V16UcV16UcV16UcV16UcIi", "nc") -BUILTIN(__builtin_s390_vstrczbs, "V16UcV16UcV16UcV16UcIii*", "nc") -BUILTIN(__builtin_s390_vstrczh, "V8UsV8UsV8UsV8UsIi", "nc") -BUILTIN(__builtin_s390_vstrczhs, "V8UsV8UsV8UsV8UsIii*", "nc") -BUILTIN(__builtin_s390_vstrczf, "V4UiV4UiV4UiV4UiIi", "nc") -BUILTIN(__builtin_s390_vstrczfs, "V4UiV4UiV4UiV4UiIii*", "nc") +TARGET_BUILTIN(__builtin_s390_vfaeb, "V16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaebs, "V16UcV16UcV16UcIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaeh, "V8UsV8UsV8UsIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaehs, "V8UsV8UsV8UsIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaef, "V4UiV4UiV4UiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaefs, "V4UiV4UiV4UiIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezb, "V16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezbs, "V16UcV16UcV16UcIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezh, "V8UsV8UsV8UsIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezhs, "V8UsV8UsV8UsIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezf, "V4UiV4UiV4UiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfaezfs, "V4UiV4UiV4UiIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeeb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeebs, "V16UcV16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeeh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeehs, "V8UsV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeef, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeefs, "V4UiV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezbs, "V16UcV16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezhs, "V8UsV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeezfs, "V4UiV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeneb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenebs, "V16UcV16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfeneh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenehs, "V8UsV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenef, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenefs, "V4UiV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezb, "V16UcV16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezbs, "V16UcV16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezh, "V8UsV8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezhs, "V8UsV8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezf, "V4UiV4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfenezfs, "V4UiV4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrb, "V16UcV16Uc", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrbs, "V16UcV16Uci*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrh, "V8UsV8Us", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrhs, "V8UsV8Usi*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrf, "V4UiV4Ui", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vistrfs, "V4UiV4Uii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrcb, "V16UcV16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrcbs, "V16UcV16UcV16UcV16UcIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrch, "V8UsV8UsV8UsV8UsIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrchs, "V8UsV8UsV8UsV8UsIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrcf, "V4UiV4UiV4UiV4UiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrcfs, "V4UiV4UiV4UiV4UiIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczb, "V16UcV16UcV16UcV16UcIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczbs, "V16UcV16UcV16UcV16UcIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczh, "V8UsV8UsV8UsV8UsIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczhs, "V8UsV8UsV8UsV8UsIii*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczf, "V4UiV4UiV4UiV4UiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vstrczfs, "V4UiV4UiV4UiV4UiIii*", "nc", "vector") // Vector floating-point instructions (chapter 24 of the PoP) -BUILTIN(__builtin_s390_vfcedbs, "V2SLLiV2dV2di*", "nc") -BUILTIN(__builtin_s390_vfchdbs, "V2SLLiV2dV2di*", "nc") -BUILTIN(__builtin_s390_vfchedbs, "V2SLLiV2dV2di*", "nc") -BUILTIN(__builtin_s390_vfidb, "V2dV2dIiIi", "nc") -BUILTIN(__builtin_s390_vflndb, "V2dV2d", "nc") -BUILTIN(__builtin_s390_vflpdb, "V2dV2d", "nc") -BUILTIN(__builtin_s390_vfmadb, "V2dV2dV2dV2d", "nc") -BUILTIN(__builtin_s390_vfmsdb, "V2dV2dV2dV2d", "nc") -BUILTIN(__builtin_s390_vfsqdb, "V2dV2d", "nc") -BUILTIN(__builtin_s390_vftcidb, "V2SLLiV2dIii*", "nc") +TARGET_BUILTIN(__builtin_s390_vfcedbs, "V2SLLiV2dV2di*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfchdbs, "V2SLLiV2dV2di*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfchedbs, "V2SLLiV2dV2di*", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfidb, "V2dV2dIiIi", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vflndb, "V2dV2d", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vflpdb, "V2dV2d", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfmadb, "V2dV2dV2dV2d", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfmsdb, "V2dV2dV2dV2d", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vfsqdb, "V2dV2d", "nc", "vector") +TARGET_BUILTIN(__builtin_s390_vftcidb, "V2SLLiV2dIii*", "nc", "vector") #undef BUILTIN +#undef TARGET_BUILTIN diff --git a/include/clang/Basic/BuiltinsWebAssembly.def b/include/clang/Basic/BuiltinsWebAssembly.def index 975433523ada..97b59a1fd86c 100644 --- a/include/clang/Basic/BuiltinsWebAssembly.def +++ b/include/clang/Basic/BuiltinsWebAssembly.def @@ -16,9 +16,9 @@ // The format of this database matches clang/Basic/Builtins.def. -// Note that memory_size is not "c" (readnone) because it must be sequenced with +// Note that current_memory is not "c" (readnone) because it must be sequenced with // respect to grow_memory calls. -BUILTIN(__builtin_wasm_memory_size, "z", "n") +BUILTIN(__builtin_wasm_current_memory, "z", "n") BUILTIN(__builtin_wasm_grow_memory, "vz", "n") #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index f738cc12a431..ff97693c313e 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -161,6 +161,8 @@ TARGET_BUILTIN(__builtin_ia32_pmovmskb, "iV8c", "", "sse") TARGET_BUILTIN(__builtin_ia32_pmulhuw, "V4sV4sV4s", "", "sse") TARGET_BUILTIN(__builtin_ia32_psadbw, "V4sV8cV8c", "", "sse") TARGET_BUILTIN(__builtin_ia32_pshufw, "V4sV4sIc", "", "sse") +TARGET_BUILTIN(__builtin_ia32_vec_ext_v4hi, "iV4sIi", "", "sse") +TARGET_BUILTIN(__builtin_ia32_vec_set_v4hi, "V4sV4siIi", "", "sse") // MMX+SSE2 TARGET_BUILTIN(__builtin_ia32_cvtpd2pi, "V2iV2d", "", "sse2") @@ -215,7 +217,6 @@ TARGET_BUILTIN(__builtin_ia32_ucomisdgt, "iV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_ucomisdge, "iV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_ucomisdneq, "iV2dV2d", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_cmpps, "V4fV4fV4fIc", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpeqps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpltps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpleps, "V4fV4fV4f", "", "sse") @@ -224,7 +225,6 @@ TARGET_BUILTIN(__builtin_ia32_cmpneqps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpnltps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpnleps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpordps, "V4fV4fV4f", "", "sse") -TARGET_BUILTIN(__builtin_ia32_cmpss, "V4fV4fV4fIc", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpeqss, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpltss, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cmpless, "V4fV4fV4f", "", "sse") @@ -238,7 +238,6 @@ TARGET_BUILTIN(__builtin_ia32_maxps, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_minss, "V4fV4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_maxss, "V4fV4fV4f", "", "sse") -TARGET_BUILTIN(__builtin_ia32_cmppd, "V2dV2dV2dIc", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpeqpd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpltpd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmplepd, "V2dV2dV2d", "", "sse2") @@ -247,7 +246,6 @@ TARGET_BUILTIN(__builtin_ia32_cmpneqpd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpnltpd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpnlepd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpordpd, "V2dV2dV2d", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_cmpsd, "V2dV2dV2dIc", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpeqsd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmpltsd, "V2dV2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cmplesd, "V2dV2dV2d", "", "sse2") @@ -306,11 +304,9 @@ TARGET_BUILTIN(__builtin_ia32_ldmxcsr, "vUi", "", "sse") TARGET_BUILTIN(__builtin_ia32_stmxcsr, "Ui", "", "sse") TARGET_BUILTIN(__builtin_ia32_cvtss2si, "iV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_cvtss2si64, "LLiV4f", "", "sse") -TARGET_BUILTIN(__builtin_ia32_storeups, "vf*V4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_storehps, "vV2i*V4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_storelps, "vV2i*V4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_movmskps, "iV4f", "", "sse") -TARGET_BUILTIN(__builtin_ia32_movntps, "vf*V4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_sfence, "v", "", "sse") TARGET_BUILTIN(__builtin_ia32_rcpps, "V4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_rcpss, "V4fV4f", "", "sse") @@ -320,17 +316,13 @@ TARGET_BUILTIN(__builtin_ia32_sqrtps, "V4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_sqrtss, "V4fV4f", "", "sse") TARGET_BUILTIN(__builtin_ia32_maskmovdqu, "vV16cV16cc*", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_storeupd, "vd*V2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_movmskpd, "iV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_pmovmskb128, "iV16c", "", "sse2") TARGET_BUILTIN(__builtin_ia32_movnti, "vi*i", "", "sse2") TARGET_BUILTIN(__builtin_ia32_movnti64, "vLLi*LLi", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_movntpd, "vd*V2d", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_movntdq, "vV2LLi*V2LLi", "", "sse2") TARGET_BUILTIN(__builtin_ia32_psadbw128, "V2LLiV16cV16c", "", "sse2") TARGET_BUILTIN(__builtin_ia32_sqrtpd, "V2dV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_sqrtsd, "V2dV2d", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_cvtdq2pd, "V2dV4i", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtdq2ps, "V4fV4i", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtpd2dq, "V2LLiV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtpd2ps, "V4fV2d", "", "sse2") @@ -338,13 +330,10 @@ TARGET_BUILTIN(__builtin_ia32_cvttpd2dq, "V4iV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtsd2si, "iV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtsd2si64, "LLiV2d", "", "sse2") TARGET_BUILTIN(__builtin_ia32_cvtps2dq, "V4iV4f", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_cvtps2pd, "V2dV4f", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_cvttps2dq, "V4iV4f", "", "sse2") TARGET_BUILTIN(__builtin_ia32_clflush, "vvC*", "", "sse2") TARGET_BUILTIN(__builtin_ia32_lfence, "v", "", "sse2") TARGET_BUILTIN(__builtin_ia32_mfence, "v", "", "sse2") TARGET_BUILTIN(__builtin_ia32_pause, "v", "", "sse2") -TARGET_BUILTIN(__builtin_ia32_storedqu, "vc*V16c", "", "sse2") TARGET_BUILTIN(__builtin_ia32_pmuludq128, "V2LLiV4iV4i", "", "sse2") TARGET_BUILTIN(__builtin_ia32_psraw128, "V8sV8sV8s", "", "sse2") TARGET_BUILTIN(__builtin_ia32_psrad128, "V4iV4iV4i", "", "sse2") @@ -368,7 +357,7 @@ TARGET_BUILTIN(__builtin_ia32_monitor, "vv*UiUi", "", "sse3") TARGET_BUILTIN(__builtin_ia32_mwait, "vUiUi", "", "sse3") TARGET_BUILTIN(__builtin_ia32_lddqu, "V16ccC*", "", "sse3") -TARGET_BUILTIN(__builtin_ia32_palignr128, "V16cV16cV16cIc", "", "ssse3") +TARGET_BUILTIN(__builtin_ia32_palignr128, "V16cV16cV16cIi", "", "ssse3") TARGET_BUILTIN(__builtin_ia32_insertps128, "V4fV4fV4fIc", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_pblendvb128, "V16cV16cV16cV16c", "", "sse4.1") @@ -384,14 +373,7 @@ TARGET_BUILTIN(__builtin_ia32_pminsb128, "V16cV16cV16c", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_pminsd128, "V4iV4iV4i", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_pminud128, "V4iV4iV4i", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_pminuw128, "V8sV8sV8s", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxbd128, "V4iV16c", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxbq128, "V2LLiV16c", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxbw128, "V8sV16c", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxdq128, "V2LLiV4i", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxwd128, "V4iV8s", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmovzxwq128, "V2LLiV8s", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_pmuldq128, "V2LLiV4iV4i", "", "sse4.1") -TARGET_BUILTIN(__builtin_ia32_pmulld128, "V4iV4iV4i", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_roundps, "V4fV4fIi", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_roundss, "V4fV4fV4fIi", "", "sse4.1") TARGET_BUILTIN(__builtin_ia32_roundsd, "V2dV2dV2dIi", "", "sse4.1") @@ -464,16 +446,16 @@ TARGET_BUILTIN(__builtin_ia32_vpermilvarps256, "V8fV8fV8i", "", "avx") TARGET_BUILTIN(__builtin_ia32_blendvpd256, "V4dV4dV4dV4d", "", "avx") TARGET_BUILTIN(__builtin_ia32_blendvps256, "V8fV8fV8fV8f", "", "avx") TARGET_BUILTIN(__builtin_ia32_dpps256, "V8fV8fV8fIc", "", "avx") +TARGET_BUILTIN(__builtin_ia32_cmppd, "V2dV2dV2dIc", "", "avx") TARGET_BUILTIN(__builtin_ia32_cmppd256, "V4dV4dV4dIc", "", "avx") +TARGET_BUILTIN(__builtin_ia32_cmpps, "V4fV4fV4fIc", "", "avx") TARGET_BUILTIN(__builtin_ia32_cmpps256, "V8fV8fV8fIc", "", "avx") -TARGET_BUILTIN(__builtin_ia32_cvtdq2pd256, "V4dV4i", "", "avx") +TARGET_BUILTIN(__builtin_ia32_cmpsd, "V2dV2dV2dIc", "", "avx") +TARGET_BUILTIN(__builtin_ia32_cmpss, "V4fV4fV4fIc", "", "avx") TARGET_BUILTIN(__builtin_ia32_cvtdq2ps256, "V8fV8i", "", "avx") TARGET_BUILTIN(__builtin_ia32_cvtpd2ps256, "V4fV4d", "", "avx") TARGET_BUILTIN(__builtin_ia32_cvtps2dq256, "V8iV8f", "", "avx") -TARGET_BUILTIN(__builtin_ia32_cvtps2pd256, "V4dV4f", "", "avx") -TARGET_BUILTIN(__builtin_ia32_cvttpd2dq256, "V4iV4d", "", "avx") TARGET_BUILTIN(__builtin_ia32_cvtpd2dq256, "V4iV4d", "", "avx") -TARGET_BUILTIN(__builtin_ia32_cvttps2dq256, "V8iV8f", "", "avx") TARGET_BUILTIN(__builtin_ia32_vperm2f128_pd256, "V4dV4dV4dIc", "", "avx") TARGET_BUILTIN(__builtin_ia32_vperm2f128_ps256, "V8fV8fV8fIc", "", "avx") TARGET_BUILTIN(__builtin_ia32_vperm2f128_si256, "V8iV8iV8iIc", "", "avx") @@ -504,13 +486,7 @@ TARGET_BUILTIN(__builtin_ia32_vzeroall, "v", "", "avx") TARGET_BUILTIN(__builtin_ia32_vzeroupper, "v", "", "avx") TARGET_BUILTIN(__builtin_ia32_vbroadcastf128_pd256, "V4dV2dC*", "", "avx") TARGET_BUILTIN(__builtin_ia32_vbroadcastf128_ps256, "V8fV4fC*", "", "avx") -TARGET_BUILTIN(__builtin_ia32_storeupd256, "vd*V4d", "", "avx") -TARGET_BUILTIN(__builtin_ia32_storeups256, "vf*V8f", "", "avx") -TARGET_BUILTIN(__builtin_ia32_storedqu256, "vc*V32c", "", "avx") TARGET_BUILTIN(__builtin_ia32_lddqu256, "V32ccC*", "", "avx") -TARGET_BUILTIN(__builtin_ia32_movntdq256, "vV4LLi*V4LLi", "", "avx") -TARGET_BUILTIN(__builtin_ia32_movntpd256, "vd*V4d", "", "avx") -TARGET_BUILTIN(__builtin_ia32_movntps256, "vf*V8f", "", "avx") TARGET_BUILTIN(__builtin_ia32_maskloadpd, "V2dV2dC*V2LLi", "", "avx") TARGET_BUILTIN(__builtin_ia32_maskloadps, "V4fV4fC*V4i", "", "avx") TARGET_BUILTIN(__builtin_ia32_maskloadpd256, "V4dV4dC*V4LLi", "", "avx") @@ -537,7 +513,7 @@ TARGET_BUILTIN(__builtin_ia32_paddusb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_paddusw256, "V16sV16sV16s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psubusb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psubusw256, "V16sV16sV16s", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_palignr256, "V32cV32cV32cIc", "", "avx2") +TARGET_BUILTIN(__builtin_ia32_palignr256, "V32cV32cV32cIi", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pavgb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pavgw256, "V16sV16sV16s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pblendvb256, "V32cV32cV32cV32c", "", "avx2") @@ -562,18 +538,6 @@ TARGET_BUILTIN(__builtin_ia32_pminsb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pminsw256, "V16sV16sV16s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pminsd256, "V8iV8iV8i", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pmovmskb256, "iV32c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxbw256, "V16sV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxbd256, "V8iV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxbq256, "V4LLiV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxwd256, "V8iV8s", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxwq256, "V4LLiV8s", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovsxdq256, "V4LLiV4i", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxbw256, "V16sV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxbd256, "V8iV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxbq256, "V4LLiV16c", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxwd256, "V8iV8s", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxwq256, "V4LLiV8s", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pmovzxdq256, "V4LLiV4i", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pmuldq256, "V4LLiV8iV8i", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pmulhrsw256, "V16sV16sV16s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pmulhuw256, "V16sV16sV16s", "", "avx2") @@ -584,7 +548,6 @@ TARGET_BUILTIN(__builtin_ia32_pshufb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psignb256, "V32cV32cV32c", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psignw256, "V16sV16sV16s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psignd256, "V8iV8iV8i", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_pslldqi256, "V4LLiV4LLiIi", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psllwi256, "V16sV16si", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psllw256, "V16sV16sV8s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_pslldi256, "V8iV8ii", "", "avx2") @@ -595,7 +558,6 @@ TARGET_BUILTIN(__builtin_ia32_psrawi256, "V16sV16si", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psraw256, "V16sV16sV8s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psradi256, "V8iV8ii", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psrad256, "V8iV8iV4i", "", "avx2") -TARGET_BUILTIN(__builtin_ia32_psrldqi256, "V4LLiV4LLiIi", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psrlwi256, "V16sV16si", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psrlw256, "V16sV16sV8s", "", "avx2") TARGET_BUILTIN(__builtin_ia32_psrldi256, "V8iV8ii", "", "avx2") @@ -647,10 +609,8 @@ TARGET_BUILTIN(__builtin_ia32_gatherq_d256, "V4iV4iiC*V4LLiV4iIc", "", "avx2") // F16C TARGET_BUILTIN(__builtin_ia32_vcvtps2ph, "V8sV4fIi", "", "f16c") TARGET_BUILTIN(__builtin_ia32_vcvtps2ph256, "V8sV8fIi", "", "f16c") -TARGET_BUILTIN(__builtin_ia32_vcvtps2ph512, "V16sV16fIi", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vcvtph2ps, "V4fV8s", "", "f16c") TARGET_BUILTIN(__builtin_ia32_vcvtph2ps256, "V8fV8s", "", "f16c") -TARGET_BUILTIN(__builtin_ia32_vcvtph2ps512, "V16fV16s", "", "avx512f") // RDRAND TARGET_BUILTIN(__builtin_ia32_rdrand16_step, "UiUs*", "", "rdrnd") @@ -687,13 +647,16 @@ TARGET_BUILTIN(__builtin_ia32_xsavec64, "vv*ULLi", "", "xsavec") TARGET_BUILTIN(__builtin_ia32_xsaves, "vv*ULLi", "", "xsaves") TARGET_BUILTIN(__builtin_ia32_xsaves64, "vv*ULLi", "", "xsaves") +//CLFLUSHOPT +TARGET_BUILTIN(__builtin_ia32_clflushopt, "vc*", "", "clflushopt") + // ADX TARGET_BUILTIN(__builtin_ia32_addcarryx_u32, "UcUcUiUiUi*", "", "adx") TARGET_BUILTIN(__builtin_ia32_addcarryx_u64, "UcUcULLiULLiULLi*", "", "adx") -TARGET_BUILTIN(__builtin_ia32_addcarry_u32, "UcUcUiUiUi*", "", "adx") -TARGET_BUILTIN(__builtin_ia32_addcarry_u64, "UcUcULLiULLiULLi*", "", "adx") -TARGET_BUILTIN(__builtin_ia32_subborrow_u32, "UcUcUiUiUi*", "", "adx") -TARGET_BUILTIN(__builtin_ia32_subborrow_u64, "UcUcULLiULLiULLi*", "", "adx") +TARGET_BUILTIN(__builtin_ia32_addcarry_u32, "UcUcUiUiUi*", "", "") +TARGET_BUILTIN(__builtin_ia32_addcarry_u64, "UcUcULLiULLiULLi*", "", "") +TARGET_BUILTIN(__builtin_ia32_subborrow_u32, "UcUcUiUiUi*", "", "") +TARGET_BUILTIN(__builtin_ia32_subborrow_u64, "UcUcULLiULLiULLi*", "", "") // RDSEED TARGET_BUILTIN(__builtin_ia32_rdseed16_step, "UiUs*", "", "rdseed") @@ -931,23 +894,23 @@ TARGET_BUILTIN(__builtin_ia32_wrpkru, "vUi", "", "pku") // AVX-512 TARGET_BUILTIN(__builtin_ia32_sqrtpd512_mask, "V8dV8dV8dUcIi", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_sqrtps512_mask, "V16fV16fV16fUsIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_rsqrt14sd, "V2dV2dV2dV2dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_rsqrt14ss, "V4fV4fV4fV4fUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_rsqrt14sd_mask, "V2dV2dV2dV2dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_rsqrt14ss_mask, "V4fV4fV4fV4fUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_rsqrt14pd512_mask, "V8dV8dV8dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_rsqrt14ps512_mask, "V16fV16fV16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_rsqrt28sd_round, "V2dV2dV2dV2dUcIi", "", "avx512er") -TARGET_BUILTIN(__builtin_ia32_rsqrt28ss_round, "V4fV4fV4fV4fUcIi", "", "avx512er") +TARGET_BUILTIN(__builtin_ia32_rsqrt28sd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512er") +TARGET_BUILTIN(__builtin_ia32_rsqrt28ss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512er") TARGET_BUILTIN(__builtin_ia32_rsqrt28pd_mask, "V8dV8dV8dUcIi", "", "avx512er") TARGET_BUILTIN(__builtin_ia32_rsqrt28ps_mask, "V16fV16fV16fUsIi", "", "avx512er") -TARGET_BUILTIN(__builtin_ia32_rcp14sd, "V2dV2dV2dV2dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_rcp14ss, "V4fV4fV4fV4fUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_rcp14sd_mask, "V2dV2dV2dV2dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_rcp14ss_mask, "V4fV4fV4fV4fUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_rcp14pd512_mask, "V8dV8dV8dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_rcp14ps512_mask, "V16fV16fV16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_rcp28sd_round, "V2dV2dV2dV2dUcIi", "", "avx512er") -TARGET_BUILTIN(__builtin_ia32_rcp28ss_round, "V4fV4fV4fV4fUcIi", "", "avx512er") +TARGET_BUILTIN(__builtin_ia32_rcp28sd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512er") +TARGET_BUILTIN(__builtin_ia32_rcp28ss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512er") TARGET_BUILTIN(__builtin_ia32_rcp28pd_mask, "V8dV8dV8dUcIi", "", "avx512er") TARGET_BUILTIN(__builtin_ia32_rcp28ps_mask, "V16fV16fV16fUsIi", "", "avx512er") TARGET_BUILTIN(__builtin_ia32_exp2pd_mask, "V8dV8dV8dUcIi", "", "avx512er") @@ -968,12 +931,12 @@ TARGET_BUILTIN(__builtin_ia32_pcmpeqq512_mask, "cV8LLiV8LLic", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pcmpeqw512_mask, "iV32sV32si", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pcmpeqb256_mask, "iV32cV32ci", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpeqd256_mask, "cV8iV8ic", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpeqq256_mask, "cV4LLiV4LLic", "", "avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pcmpeqd256_mask, "cV8iV8ic", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_pcmpeqq256_mask, "cV4LLiV4LLic", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pcmpeqw256_mask, "sV16sV16ss", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pcmpeqb128_mask, "sV16cV16cs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpeqd128_mask, "cV4iV4ic", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpeqq128_mask, "cV2LLiV2LLic", "", "avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pcmpeqd128_mask, "cV4iV4ic", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_pcmpeqq128_mask, "cV2LLiV2LLic", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pcmpeqw128_mask, "cV8sV8sc", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pcmpgtb512_mask, "LLiV64cV64cLLi", "", "avx512bw") @@ -982,12 +945,12 @@ TARGET_BUILTIN(__builtin_ia32_pcmpgtq512_mask, "cV8LLiV8LLic", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pcmpgtw512_mask, "iV32sV32si", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pcmpgtb256_mask, "iV32cV32ci", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpgtd256_mask, "cV8iV8ic", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpgtq256_mask, "cV4LLiV4LLic", "", "avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pcmpgtd256_mask, "cV8iV8ic", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_pcmpgtq256_mask, "cV4LLiV4LLic", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pcmpgtw256_mask, "sV16sV16ss", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pcmpgtb128_mask, "sV16cV16cs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpgtd128_mask, "cV4iV4ic", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pcmpgtq128_mask, "cV2LLiV2LLic", "", "avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pcmpgtd128_mask, "cV4iV4ic", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_pcmpgtq128_mask, "cV2LLiV2LLic", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pcmpgtw128_mask, "cV8sV8sc", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_cmppd512_mask, "UcV8dV8dIiUcIi", "", "avx512f") @@ -1011,12 +974,6 @@ TARGET_BUILTIN(__builtin_ia32_cvtudq2pd512_mask, "V8dV8iV8dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_cvtpd2ps512_mask, "V8fV8dV8fUcIi", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vcvtps2ph512_mask, "V16sV16fIiV16sUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vcvtph2ps512_mask, "V16fV16sV16fUsIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pandd512_mask, "V16iV16iV16iV16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pandq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pord512_mask, "V16iV16iV16iV16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_porq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pxord512_mask, "V16iV16iV16iV16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pxorq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pabsd512_mask, "V16iV16iV16iUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pabsq512_mask, "V8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pmaxsd512_mask, "V16iV16iV16iV16iUs", "", "avx512f") @@ -1029,61 +986,77 @@ TARGET_BUILTIN(__builtin_ia32_pminud512_mask, "V16iV16iV16iV16iUs", "", "avx512f TARGET_BUILTIN(__builtin_ia32_pminuq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pmuldq512_mask, "V8LLiV16iV16iV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pmuludq512_mask, "V8LLiV16iV16iV8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_blendmd_512_mask, "V16iV16iV16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_blendmq_512_mask, "V8LLiV8LLiV8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_blendmps_512_mask, "V16fV16fV16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_blendmpd_512_mask, "V8dV8dV8dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_ptestmd512, "UsV16iV16iUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_ptestmq512, "UcV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pbroadcastd512_gpr_mask, "V16iiV16iUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pbroadcastq512_gpr_mask, "V8LLiLLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_pbroadcastq512_mem_mask, "V8LLiLLiV8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loaddqusi512_mask, "V16ivC*V16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loaddqudi512_mask, "V8LLivC*V8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loadups512_mask, "V16fvC*V16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loadaps512_mask, "V16fvC*V16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loadupd512_mask, "V8dvC*V8dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_loadapd512_mask, "V8dvC*V8dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storedqudi512_mask, "vv*V8LLiUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storedqusi512_mask, "vv*V16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storeupd512_mask, "vv*V8dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storeapd512_mask, "vv*V8dUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storeups512_mask, "vv*V16fUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_storeaps512_mask, "vv*V16fUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loaddqusi512_mask, "V16iiC*V16iUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loaddqudi512_mask, "V8LLiLLiC*V8LLiUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loadups512_mask, "V16ffC*V16fUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loadaps512_mask, "V16fV16fC*V16fUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loadupd512_mask, "V8ddC*V8dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_loadapd512_mask, "V8dV8dC*V8dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storedqudi512_mask, "vLLi*V8LLiUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storedqusi512_mask, "vi*V16iUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storeupd512_mask, "vd*V8dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storeapd512_mask, "vV8d*V8dUc", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storeups512_mask, "vf*V16fUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_storeaps512_mask, "vV16f*V16fUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vpermt2vard512_mask, "V16iV16iV16iV16iUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vpermt2varq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vpermt2varps512_mask, "V16fV16iV16fV16fUs", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_vpermt2varpd512_mask, "V8dV8LLiV8dV8dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_alignq512_mask, "V8LLiV8LLiV8LLiIiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_alignd512_mask, "V16iV16iV16iIiV16iUs", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_alignd128_mask, "V4iV4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_alignd256_mask, "V8iV8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_alignq128_mask, "V2LLiV2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_alignq256_mask, "V4LLiV4LLiV4LLiIiV4LLiUc","","avx512vl") TARGET_BUILTIN(__builtin_ia32_extractf64x4_mask, "V4dV8dIiV4dUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_extractf32x4_mask, "V4fV16fIiV4fUc", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv8df, "V8dV8dvC*V8iUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv16sf, "V16fV16fvC*UsIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv8df, "V8dV8dvC*V8LLiUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv16sf, "V8fV8fvC*V8LLiUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv8di, "V8LLiV8LLivC*V8iUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gathersiv16si, "V16iV16ivC*UsIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv8di, "V8LLiV8LLivC*V8LLiUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherdiv16si, "V8iV8ivC*V8LLiUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv8df, "vv*UcV8iV8dIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv16sf, "vv*UsV16iV16fIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8df, "vv*UcV8LLiV8dIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv16sf, "vv*UcV8LLiV8fIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv8di, "vv*UcV8iV8LLiIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scattersiv16si, "vv*UsV16iV16iIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8di, "vv*UcV8LLiV8LLiIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_scatterdiv16si, "vv*UcV8LLiV8iIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gather3div2df, "V2dV2ddC*V2LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div2di, "V4iV2LLiLLiC*V2LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4df, "V4dV4ddC*V4LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4di, "V8iV4LLiLLiC*V4LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4sf, "V4fV4ffC*V2LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div4si, "V4iV4iiC*V2LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div8sf, "V4fV4ffC*V4LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3div8si, "V4iV4iiC*V4LLiUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv2df, "V2dV2ddC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv2di, "V4iV2LLiLLiC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4df, "V4dV4ddC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4di, "V8iV4LLiLLiC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4sf, "V4fV4ffC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv4si, "V4iV4iiC*V4iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv8sf, "V8fV8ffC*V8iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gather3siv8si, "V8iV8iiC*V8iUci","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_gathersiv8df, "V8dV8ddC*V8iUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv16sf, "V16fV16ffC*V16fUsIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv8df, "V8dV8ddC*V8LLiUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv16sf, "V8fV8ffC*V8LLiUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv8di, "V8LLiV8LLiLLiC*V8iUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gathersiv16si, "V16iV16iiC*V16iUsIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv8di, "V8LLiV8LLiLLiC*V8LLiUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_gatherdiv16si, "V8iV8iiC*V8LLiUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv8df, "vd*UcV8iV8dIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv16sf, "vf*UsV16iV16fIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8df, "vd*UcV8LLiV8dIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv16sf, "vf*UcV8LLiV8fIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv8di, "vLLi*UcV8iV8LLiIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scattersiv16si, "vi*UsV16iV16iIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8di, "vLLi*UcV8LLiV8LLiIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_scatterdiv16si, "vi*UcV8LLiV8iIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_gatherpfdpd, "vUcV8ivC*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfdps, "vUsV16ivC*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfqpd, "vUcV8LLivC*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_gatherpfqps, "vUcV8LLivC*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfdpd, "vUcV8iv*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfdps, "vUsV16iv*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfqpd, "vUcV8LLiv*IiIi", "", "avx512pf") -TARGET_BUILTIN(__builtin_ia32_scatterpfqps, "vUcV8LLiv*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfdpd, "vUcV8iLLiC*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfdps, "vUsV16iiC*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfqpd, "vUcV8LLiLLiC*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_gatherpfqps, "vUcV8LLiiC*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfdpd, "vUcV8iLLi*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfdps, "vUsV16ii*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfqpd, "vUcV8LLiLLi*IiIi", "", "avx512pf") +TARGET_BUILTIN(__builtin_ia32_scatterpfqps, "vUcV8LLii*IiIi", "", "avx512pf") TARGET_BUILTIN(__builtin_ia32_knothi, "UsUs", "", "avx512f") @@ -1126,22 +1099,6 @@ TARGET_BUILTIN(__builtin_ia32_pmuludq256_mask, "V4LLiV8iV8iV4LLiUc", "", "avx512 TARGET_BUILTIN(__builtin_ia32_pmuludq128_mask, "V2LLiV4iV4iV2LLiUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pmulld256_mask, "V8iV8iV8iV8iUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_pmulld128_mask, "V4iV4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandd256_mask, "V8iV8iV8iV8iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandd128_mask, "V4iV4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandnd256_mask, "V8iV8iV8iV8iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandnd128_mask, "V4iV4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pord256_mask, "V8iV8iV8iV8iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pord128_mask, "V4iV4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pxord256_mask, "V8iV8iV8iV8iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pxord128_mask, "V4iV4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandnq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pandnq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_porq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_porq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pxorq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_pxorq128_mask, "V2LLiV2LLiV2LLiV2LLiUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_paddb512_mask, "V64cV64cV64cV64cULLi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_psubb512_mask, "V64cV64cV64cV64cULLi", "", "avx512bw") @@ -1159,8 +1116,6 @@ TARGET_BUILTIN(__builtin_ia32_psubw128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,avx TARGET_BUILTIN(__builtin_ia32_pmullw256_mask, "V16sV16sV16sV16sUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pmullw128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_pandnd512_mask, "V16iV16iV16iV16iUs", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_pandnq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_paddq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_psubq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_paddd512_mask, "V16iV16iV16iV16iUs", "", "avx512f") @@ -1195,8 +1150,6 @@ TARGET_BUILTIN(__builtin_ia32_orpd128_mask, "V2dV2dV2dV2dUc", "", "avx512vl,avx5 TARGET_BUILTIN(__builtin_ia32_orps256_mask, "V8fV8fV8fV8fUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_orps128_mask, "V4fV4fV4fV4fUc", "", "avx512vl,avx512dq") -TARGET_BUILTIN(__builtin_ia32_blendmb_512_mask, "V64cV64cV64cULLi", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_blendmw_512_mask, "V32sV32sV32sUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pabsb512_mask, "V64cV64cV64cULLi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pabsw512_mask, "V32sV32sV32sUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_packssdw512_mask, "V32sV16iV16iV32sUi", "", "avx512bw") @@ -1227,15 +1180,15 @@ TARGET_BUILTIN(__builtin_ia32_vpermi2varhi512_mask, "V32sV32sV32sV32sUi", "", "a TARGET_BUILTIN(__builtin_ia32_vpermt2varhi512_mask, "V32sV32sV32sV32sUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_vpermt2varhi512_maskz, "V32sV32sV32sV32sUi", "", "avx512bw") +TARGET_BUILTIN(__builtin_ia32_vpconflictdi_128_mask, "V2LLiV2LLiV2LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpconflictdi_256_mask, "V4LLiV4LLiV4LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpconflictsi_128_mask, "V4iV4iV4iUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpconflictsi_256_mask, "V8iV8iV8iUc","","avx512cd,avx512vl") TARGET_BUILTIN(__builtin_ia32_vpconflictdi_512_mask, "V8LLiV8LLiV8LLiUc", "", "avx512cd") TARGET_BUILTIN(__builtin_ia32_vpconflictsi_512_mask, "V16iV16iV16iUs", "", "avx512cd") TARGET_BUILTIN(__builtin_ia32_vplzcntd_512_mask, "V16iV16iV16iUs", "", "avx512cd") TARGET_BUILTIN(__builtin_ia32_vplzcntq_512_mask, "V8LLiV8LLiV8LLiUc", "", "avx512cd") -TARGET_BUILTIN(__builtin_ia32_blendmb_128_mask, "V16cV16cV16cUs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_blendmb_256_mask, "V32cV32cV32cUi", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_blendmw_128_mask, "V8sV8sV8sUc", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_blendmw_256_mask, "V16sV16sV16sUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pabsb128_mask, "V16cV16cV16cUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pabsb256_mask, "V32cV32cV32cUi", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pabsw128_mask, "V8sV8sV8sUc", "", "avx512vl,avx512bw") @@ -1310,31 +1263,23 @@ TARGET_BUILTIN(__builtin_ia32_subps512_mask, "V16fV16fV16fV16fUsIi", "", "avx512 TARGET_BUILTIN(__builtin_ia32_pmaddubsw512_mask, "V32sV64cV64cV32sUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaddwd512_mask, "V16iV32sV32sV16iUs", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_addss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_divss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_mulss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_subss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_maxss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_minss_round, "V4fV4fV4fV4fUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_addsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_divsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_mulsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_subsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_maxsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") -TARGET_BUILTIN(__builtin_ia32_minsd_round, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_addss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_divss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_mulss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_subss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_maxss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_minss_round_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_addsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_divsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_mulsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_subsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_maxsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_minsd_round_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") TARGET_BUILTIN(__builtin_ia32_addpd128_mask, "V2dV2dV2dV2dUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_addpd256_mask, "V4dV4dV4dV4dUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_addps128_mask, "V4fV4fV4fV4fUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_addps256_mask, "V8fV8fV8fV8fUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmd_128_mask, "V4iV4iV4iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmd_256_mask, "V8iV8iV8iUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmpd_128_mask, "V2dV2dV2dUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmpd_256_mask, "V4dV4dV4dUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmps_128_mask, "V4fV4fV4fUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmps_256_mask, "V8fV8fV8fUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmq_128_mask, "V2LLiV2LLiV2LLiUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_blendmq_256_mask, "V4LLiV4LLiV4LLiUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_compressdf128_mask, "V2dV2dV2dUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_compressdf256_mask, "V4dV4dV4dUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_compressdi128_mask, "V2LLiV2LLiV2LLiUc", "", "avx512vl") @@ -1444,22 +1389,22 @@ TARGET_BUILTIN(__builtin_ia32_scalefpd256_mask, "V4dV4dV4dV4dUc", "", "avx512vl" TARGET_BUILTIN(__builtin_ia32_scalefps128_mask, "V4fV4fV4fV4fUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_scalefps256_mask, "V8fV8fV8fV8fUc", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv2df, "vv*UcV2LLiV2dIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv2di, "vv*UcV2LLiV2LLiIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4df, "vv*UcV4LLiV4dIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4di, "vv*UcV4LLiV4LLiIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4sf, "vv*UcV2LLiV4fIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv4si, "vv*UcV2LLiV4iIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8sf, "vv*UcV4LLiV4fIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scatterdiv8si, "vv*UcV4LLiV4iIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv2df, "vv*UcV4iV2dIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv2di, "vv*UcV4iV2LLiIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4df, "vv*UcV4iV4dIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4di, "vv*UcV4iV4LLiIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4sf, "vv*UcV4iV4fIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv4si, "vv*UcV4iV4iIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv8sf, "vv*UcV8iV8fIi", "", "avx512vl") -TARGET_BUILTIN(__builtin_ia32_scattersiv8si, "vv*UcV8iV8iIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv2df, "vd*UcV2LLiV2dIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv2di, "vLLi*UcV2LLiV2LLiIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4df, "vd*UcV4LLiV4dIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4di, "vLLi*UcV4LLiV4LLiIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4sf, "vf*UcV2LLiV4fIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv4si, "vi*UcV2LLiV4iIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8sf, "vf*UcV4LLiV4fIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scatterdiv8si, "vi*UcV4LLiV4iIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv2df, "vd*UcV4iV2dIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv2di, "vLLi*UcV4iV2LLiIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4df, "vd*UcV4iV4dIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4di, "vLLi*UcV4iV4LLiIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4sf, "vf*UcV4iV4fIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv4si, "vi*UcV4iV4iIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv8sf, "vf*UcV8iV8fIi", "", "avx512vl") +TARGET_BUILTIN(__builtin_ia32_scattersiv8si, "vi*UcV8iV8iIi", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_sqrtpd128_mask, "V2dV2dV2dUc", "", "avx512vl") TARGET_BUILTIN(__builtin_ia32_sqrtpd256_mask, "V4dV4dV4dUc", "", "avx512vl") @@ -1496,10 +1441,6 @@ TARGET_BUILTIN(__builtin_ia32_vpermt2varq256_maskz, "V4LLiV4LLiV4LLiV4LLiUc", "" TARGET_BUILTIN(__builtin_ia32_pmovswb512_mask, "V32cV32sV32cUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmovuswb512_mask, "V32cV32sV32cUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_pmovwb512_mask, "V32cV32sV32cUi", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhbw512_mask, "V64cV64cV64cV64cULLi", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhwd512_mask, "V32sV32sV32sV32sUi", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklbw512_mask, "V64cV64cV64cV64cULLi", "", "avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklwd512_mask, "V32sV32sV32sV32sUi", "", "avx512bw") TARGET_BUILTIN(__builtin_ia32_cvtpd2qq128_mask, "V2LLiV2dV2LLiUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_cvtpd2qq256_mask, "V4LLiV4dV4LLiUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_cvtpd2uqq128_mask, "V2LLiV2dV2LLiUc", "", "avx512vl,avx512dq") @@ -1528,10 +1469,14 @@ TARGET_BUILTIN(__builtin_ia32_rangepd128_mask, "V2dV2dV2dIiV2dUc", "", "avx512vl TARGET_BUILTIN(__builtin_ia32_rangepd256_mask, "V4dV4dV4dIiV4dUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_rangeps128_mask, "V4fV4fV4fIiV4fUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_rangeps256_mask, "V8fV8fV8fIiV8fUc", "", "avx512vl,avx512dq") +TARGET_BUILTIN(__builtin_ia32_rangesd128_round_mask, "V2dV2dV2dV2dUcIiIi", "", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_rangess128_round_mask, "V4fV4fV4fV4fUcIiIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_reducepd128_mask, "V2dV2dIiV2dUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_reducepd256_mask, "V4dV4dIiV4dUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_reduceps128_mask, "V4fV4fIiV4fUc", "", "avx512vl,avx512dq") TARGET_BUILTIN(__builtin_ia32_reduceps256_mask, "V8fV8fIiV8fUc", "", "avx512vl,avx512dq") +TARGET_BUILTIN(__builtin_ia32_reducesd_mask, "V2dV2dV2dV2dUcIiIi", "", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_reducess_mask, "V4fV4fV4fV4fUcIiIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_pmaddubsw128_mask, "V8sV16cV16cV8sUc", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaddubsw256_mask, "V16sV32cV32cV16sUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pmaddwd128_mask, "V4iV8sV8sV4iUc", "", "avx512vl,avx512bw") @@ -1548,14 +1493,6 @@ TARGET_BUILTIN(__builtin_ia32_pmulhuw128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,a TARGET_BUILTIN(__builtin_ia32_pmulhuw256_mask, "V16sV16sV16sV16sUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pmulhw128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_pmulhw256_mask, "V16sV16sV16sV16sUs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhbw128_mask, "V16cV16cV16cV16cUs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhbw256_mask, "V32cV32cV32cV32cUi", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhwd128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpckhwd256_mask, "V16sV16sV16sV16sUs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklbw128_mask, "V16cV16cV16cV16cUs", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklbw256_mask, "V32cV32cV32cV32cUi", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklwd128_mask, "V8sV8sV8sV8sUc", "", "avx512vl,avx512bw") -TARGET_BUILTIN(__builtin_ia32_punpcklwd256_mask, "V16sV16sV16sV16sUs", "", "avx512vl,avx512bw") TARGET_BUILTIN(__builtin_ia32_cvtpd2qq512_mask, "V8LLiV8dV8LLiUcIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_cvtpd2uqq512_mask, "V8LLiV8dV8LLiUcIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_cvtps2qq512_mask, "V8LLiV8fV8LLiUcIi", "", "avx512dq") @@ -1572,6 +1509,621 @@ TARGET_BUILTIN(__builtin_ia32_rangepd512_mask, "V8dV8dV8dIiV8dUcIi", "", "avx512 TARGET_BUILTIN(__builtin_ia32_rangeps512_mask, "V16fV16fV16fIiV16fUsIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_reducepd512_mask, "V8dV8dIiV8dUcIi", "", "avx512dq") TARGET_BUILTIN(__builtin_ia32_reduceps512_mask, "V16fV16fIiV16fUsIi", "", "avx512dq") +TARGET_BUILTIN(__builtin_ia32_pmovsxbw512_mask, "V32sV32cV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsxbd512_mask, "V16iV16cV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsxbq512_mask, "V8LLiV16cV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsxdq512_mask, "V8LLiV8iV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsxwd512_mask, "V16iV16sV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsxwq512_mask, "V8LLiV8sV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsxbw128_mask, "V8sV16cV8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsxbw256_mask, "V16sV16cV16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsxbd128_mask, "V4iV16cV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxbd256_mask, "V8iV16cV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxbq128_mask, "V2LLiV16cV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxbq256_mask, "V4LLiV16cV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxdq128_mask, "V2LLiV4iV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxdq256_mask, "V4LLiV4iV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxwd128_mask, "V4iV8sV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxwd256_mask, "V8iV8sV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxwq128_mask, "V2LLiV8sV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsxwq256_mask, "V4LLiV8sV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxbw512_mask, "V32sV32cV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovzxbd512_mask, "V16iV16cV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovzxbq512_mask, "V8LLiV16cV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovzxdq512_mask, "V8LLiV8iV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovzxwd512_mask, "V16iV16sV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovzxwq512_mask, "V8LLiV8sV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovzxbw128_mask, "V8sV16cV8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovzxbw256_mask, "V16sV16cV16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovzxbd128_mask, "V4iV16cV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxbd256_mask, "V8iV16cV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxbq128_mask, "V2LLiV16cV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxbq256_mask, "V4LLiV16cV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxdq128_mask, "V2LLiV4iV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxdq256_mask, "V4LLiV4iV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxwd128_mask, "V4iV8sV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxwd256_mask, "V8iV8sV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxwq128_mask, "V2LLiV8sV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovzxwq256_mask, "V4LLiV8sV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prold512_mask, "V16iV16iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prolq512_mask, "V8LLiV8LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prold128_mask, "V4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prold256_mask, "V8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolq128_mask, "V2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolq256_mask, "V4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolvd512_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prolvq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prord512_mask, "V16iV16iiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prorq512_mask, "V8LLiV8LLiiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prolvd128_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolvd256_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolvq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prolvq256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prord128_mask, "V4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prord256_mask, "V8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorq128_mask, "V2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorq256_mask, "V4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorvd512_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prorvq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_prorvd128_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorvd256_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorvq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_prorvq256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv32hi_mask, "V32sV32sV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psllw512_mask, "V32sV32sV8sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psllwi512_mask, "V32sV32sIiV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psllv16hi_mask, "V16sV16sV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv8hi_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllw128_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllw256_mask, "V16sV16sV8sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllwi128_mask, "V8sV8sIiV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllwi256_mask, "V16sV16sIiV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv2di_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv4di_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv4si_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllv8si_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pslldi512_mask, "V16iV16iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psllqi512_mask, "V8LLiV8LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pslld128_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pslld256_mask, "V8iV8iV4iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pslldi128_mask, "V4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pslldi256_mask, "V8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllq256_mask, "V4LLiV4LLiV2LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllqi128_mask, "V2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psllqi256_mask, "V4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv32hi_mask, "V32sV32sV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psrlv16hi_mask, "V16sV16sV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv8hi_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv2di_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv4di_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv4si_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlv8si_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrldi512_mask, "V16iV16iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrlqi512_mask, "V8LLiV8LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrld128_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrld256_mask, "V8iV8iV4iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrldi128_mask, "V4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrldi256_mask, "V8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlq256_mask, "V4LLiV4LLiV2LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlqi128_mask, "V2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlqi256_mask, "V4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrav32hi_mask, "V32sV32sV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psrav16hi_mask, "V16sV16sV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrav8hi_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrav4si_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrav8si_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psravq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psravq256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraw512_mask, "V32sV32sV8sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psrawi512_mask, "V32sV32sIiV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psraw128_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraw256_mask, "V16sV16sV8sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrawi128_mask, "V8sV8sIiV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrawi256_mask, "V16sV16sIiV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlw512_mask, "V32sV32sV8sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psrlwi512_mask, "V32sV32sIiV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psrlw128_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlw256_mask, "V16sV16sV8sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlwi128_mask, "V8sV8sIiV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrlwi256_mask, "V16sV16sIiV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_movdqa32load128_mask, "V4iV4i*V4iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa32load256_mask, "V8iV8i*V8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa32load512_mask, "V16iV16iC*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa32store512_mask, "vV16i*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa64load512_mask, "V8LLiV8LLiC*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa64store512_mask, "vV8LLi*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa32store128_mask, "vV4i*V4iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa32store256_mask, "vV8i*V8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa64load128_mask, "V2LLiV2LLiC*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_movdqa64load256_mask, "V4LLiV4LLiC*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_movdqa64store128_mask, "vV2LLi*V2LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movdqa64store256_mask, "vV4LLi*V4LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pbroadcastb512_gpr_mask, "V64ccV64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pbroadcastb128_gpr_mask, "V16ccV16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastb256_gpr_mask, "V32ccV32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastd128_gpr_mask, "V4iiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastd256_gpr_mask, "V8iiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastq128_gpr_mask, "V2LLiULLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastq256_gpr_mask, "V4LLiULLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512ifma") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc","","avx512ifma") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512ifma") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc","","avx512ifma") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq128_maskz, "V2LLiV2LLiV2LLiV2LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52huq256_maskz, "V4LLiV4LLiV4LLiV4LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq128_maskz, "V2LLiV2LLiV2LLiV2LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmadd52luq256_maskz, "V4LLiV4LLiV4LLiV4LLiUc","","avx512ifma,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermi2varqi512_mask, "V64cV64cV64cV64cULLi","","avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi512_mask, "V64cV64cV64cV64cULLi","","avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi512_maskz, "V64cV64cV64cV64cULLi","","avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_vpermi2varqi128_mask, "V16cV16cV16cV16cUs","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermi2varqi256_mask, "V32cV32cV32cV32cUi","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi128_mask, "V16cV16cV16cV16cUs","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi128_maskz, "V16cV16cV16cV16cUs","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi256_mask, "V32cV32cV32cV32cUi","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermt2varqi256_maskz, "V32cV32cV32cV32cUi","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vcomisd, "iV2dV2dIiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcomiss, "iV4fV4fIiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kunpckdi, "ULLiULLiULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_kunpcksi, "UiUiUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_loaddquhi512_mask, "V32sV32s*V32sUi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_loaddquqi512_mask, "V64cV64c*V64cULLi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd512_mask, "V8dV8dV8dV8LLiIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd512_maskz, "V8dV8dV8dV8LLiIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmps512_mask, "V16fV16fV16fV16iIiUsIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmps512_maskz, "V16fV16fV16fV16iIiUsIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmsd_mask, "V2dV2dV2dV2LLiIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmsd_maskz, "V2dV2dV2dV2LLiIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmss_mask, "V4fV4fV4fV4iIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_fixupimmss_maskz, "V4fV4fV4fV4iIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getexpsd128_round_mask, "V2dV2dV2dV2dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getexpss128_round_mask, "V4fV4fV4fV4fUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getmantsd_round_mask, "V2dV2dV2dIiV2dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getmantss_round_mask, "V4fV4fV4fIiV4fUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_loaddquhi128_mask, "V8sV8s*V8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddquhi256_mask, "V16sV16s*V16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddquqi128_mask, "V16cV16c*V16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddquqi256_mask, "V32cV32c*V32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd128_mask, "V2dV2dV2dV2LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd128_maskz, "V2dV2dV2dV2LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd256_mask, "V4dV4dV4dV4LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmpd256_maskz, "V4dV4dV4dV4LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmps128_mask, "V4fV4fV4fV4iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmps128_maskz, "V4fV4fV4fV4iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmps256_mask, "V8fV8fV8fV8iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fixupimmps256_maskz, "V8fV8fV8fV8iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadapd128_mask, "V2dV2d*V2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadapd256_mask, "V4dV4d*V4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadaps128_mask, "V4fV4f*V4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadaps256_mask, "V8fV8f*V8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddqudi128_mask, "V2LLiV2LLi*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddqudi256_mask, "V4LLiV4LLi*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loaddqusi128_mask, "V4iV4i*V4iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_loaddqusi256_mask, "V8iV8i*V8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_loadupd128_mask, "V2dV2d*V2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadupd256_mask, "V4dV4d*V4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadups128_mask, "V4fV4f*V4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_loadups256_mask, "V8fV8f*V8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storedquhi512_mask, "vV32s*V32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_storedquqi512_mask, "vV64c*V64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_storedquhi128_mask, "vV8s*V8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_storedquhi256_mask, "vV16s*V16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_storedquqi128_mask, "vV16c*V16cUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_storedquqi256_mask, "vV32c*V32cUi","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_storeapd128_mask, "vV2d*V2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeapd256_mask, "vV4d*V4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeaps128_mask, "vV4f*V4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeaps256_mask, "vV8f*V8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storedqudi128_mask, "vV2LLi*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storedqudi256_mask, "vV4LLi*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storedqusi128_mask, "vV4i*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storedqusi256_mask, "vV8i*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeupd128_mask, "vV2d*V2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeupd256_mask, "vV4d*V4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeups128_mask, "vV4f*V4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_storeups256_mask, "vV8f*V8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rcp14pd128_mask, "V2dV2dV2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rcp14pd256_mask, "V4dV4dV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rcp14ps128_mask, "V4fV4fV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rcp14ps256_mask, "V8fV8fV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vplzcntd_128_mask, "V4iV4iV4iUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vplzcntd_256_mask, "V8iV8iV8iUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vplzcntq_128_mask, "V2LLiV2LLiV2LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vplzcntq_256_mask, "V4LLiV4LLiV4LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vcvtsd2si64, "LLiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtsd2si32, "iV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtsd2usi32, "UiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtsd2usi64, "ULLiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtss2si32, "iV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtss2si64, "LLiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtss2usi32, "UiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtss2usi64, "ULLiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttsd2si32, "iV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttsd2si64, "LLiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttsd2usi32, "UiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttsd2usi64, "ULLiV2dIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttss2si32, "iV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttss2si64, "LLiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttss2usi32, "UiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvttss2usi64, "ULLiV4fIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermi2vard512_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermi2varpd512_mask, "V8dV8dV8LLiV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermi2varps512_mask, "V16fV16fV16iV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermi2varq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermilvarpd512_mask, "V8dV8dV8LLiV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermilvarps512_mask, "V16fV16fV16iV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermt2vard512_maskz, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermt2varpd512_maskz, "V8dV8LLiV8dV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermt2varps512_maskz, "V16fV16iV16fV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermt2varq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpermilvarpd_mask, "V2dV2dV2LLiV2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermilvarpd256_mask, "V4dV4dV4LLiV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermilvarps_mask, "V4fV4fV4iV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpermilvarps256_mask, "V8fV8fV8iV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmb512, "ULLiV64cV64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_ptestmw512, "UiV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_ptestnmb512, "ULLiV64cV64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_ptestnmw512, "UiV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_ptestmb128, "UsV16cV16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmb256, "UiV32cV32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmw128, "UcV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmw256, "UsV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmb128, "UsV16cV16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmb256, "UiV32cV32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmw128, "UcV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmw256, "UsV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmd128, "UcV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmd256, "UcV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmq128, "UcV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestmq256, "UcV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmd128, "UcV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmd256, "UcV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmq128, "UcV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmq256, "UcV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_ptestnmd512, "UsV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_ptestnmq512, "UcV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_rndscalesd_round_mask, "V2dV2dV2dV2dUcIiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_rndscaless_round_mask, "V4fV4fV4fV4fUcIiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_scalefpd512_mask, "V8dV8dV8dV8dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_scalefps512_mask, "V16fV16fV16fV16fUsIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_scalefsd_round_mask, "V2dV2dV2dV2dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_scalefss_round_mask, "V4fV4fV4fV4fUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psradi512_mask, "V16iV16iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psraqi512_mask, "V8LLiV8LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrad128_mask, "V4iV4iV4iV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psrad256_mask, "V8iV8iV4iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psradi128_mask, "V4iV4iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psradi256_mask, "V8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraq128_mask, "V2LLiV2LLiV2LLiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraq256_mask, "V4LLiV4LLiV2LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraqi128_mask, "V2LLiV2LLiIiV2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_psraqi256_mask, "V4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pslld512_mask, "V16iV16iV4iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psllq512_mask, "V8LLiV8LLiV2LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psllv16si_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psllv8di_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrad512_mask, "V16iV16iV4iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psraq512_mask, "V8LLiV8LLiV2LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrav16si_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrav8di_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrld512_mask, "V16iV16iV4iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrlq512_mask, "V8LLiV8LLiV2LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrlv16si_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_psrlv8di_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pternlogd512_mask, "V16iV16iV16iV16iIiUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pternlogd512_maskz, "V16iV16iV16iV16iIiUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pternlogq512_mask, "V8LLiV8LLiV8LLiV8LLiIiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pternlogq512_maskz, "V8LLiV8LLiV8LLiV8LLiIiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pternlogd128_mask, "V4iV4iV4iV4iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogd128_maskz, "V4iV4iV4iV4iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogd256_mask, "V8iV8iV8iV8iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogd256_maskz, "V8iV8iV8iV8iIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogq128_mask, "V2LLiV2LLiV2LLiV2LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogq128_maskz, "V2LLiV2LLiV2LLiV2LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogq256_mask, "V4LLiV4LLiV4LLiV4LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pternlogq256_maskz, "V4LLiV4LLiV4LLiV4LLiIiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_shuf_f32x4_mask, "V16fV16fV16fIiV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_shuf_f64x2_mask, "V8dV8dV8dIiV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_shuf_i32x4_mask, "V16iV16iV16iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_shuf_i64x2_mask, "V8LLiV8LLiV8LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_shuf_f32x4_256_mask, "V8fV8fV8fIiV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_shuf_f64x2_256_mask, "V4dV4dV4dIiV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_shuf_i32x4_256_mask, "V8iV8iV8iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_shuf_i64x2_256_mask, "V4LLiV4LLiV4LLiIiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_sqrtsd_round_mask, "V2dV2dV2dV2dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_sqrtss_round_mask, "V4fV4fV4fV4fUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_rsqrt14pd128_mask, "V2dV2dV2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rsqrt14pd256_mask, "V4dV4dV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rsqrt14ps128_mask, "V4fV4fV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_rsqrt14ps256_mask, "V8fV8fV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtb2mask512, "ULLiV64c","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_cvtmask2b512, "V64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_cvtmask2w512, "V32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_cvtd2mask512, "UsV16i","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_cvtmask2d512, "V16iUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_cvtmask2q512, "V8LLiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_cvtq2mask512, "UcV8LLi","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_cvtb2mask128, "UsV16c","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtb2mask256, "UiV32c","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2b128, "V16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2b256, "V32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2w128, "V8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2w256, "V16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtd2mask128, "UcV4i","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtd2mask256, "UcV8i","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2d128, "V4iUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2d256, "V8iUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2q128, "V2LLiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtmask2q256, "V4LLiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtq2mask128, "UcV2LLi","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtq2mask256, "UcV4LLi","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastmb512, "V8LLiUc","","avx512cd") +TARGET_BUILTIN(__builtin_ia32_broadcastmw512, "V16iUs","","avx512cd") +TARGET_BUILTIN(__builtin_ia32_broadcastf32x4_512, "V16fV4fV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_broadcastf64x4_512, "V8dV4dV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x4_512, "V16iV4iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_broadcasti64x4_512, "V8LLiV4LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_broadcastmb128, "V2LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastmb256, "V4LLiUc","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastmw128, "V4iUs","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastmw256, "V8iUs","","avx512cd,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastf32x2_512_mask, "V16fV4fV16fUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcastf32x8_512_mask, "V16fV8fV16fUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcastf64x2_512_mask, "V8dV2dV8dUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x2_512_mask, "V16iV4iV16iUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x8_512_mask, "V16iV8iV16iUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcasti64x2_512_mask, "V8LLiV2LLiV8LLiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_broadcastf32x2_256_mask, "V8fV4fV8fUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastf64x2_256_mask, "V4dV2dV4dUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x2_128_mask, "V4iV4iV4iUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x2_256_mask, "V8iV4iV8iUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcasti64x2_256_mask, "V4LLiV2LLiV4LLiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcastf32x4_256_mask, "V8fV4fV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_broadcasti32x4_256_mask, "V8iV4iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastw512_gpr_mask, "V32shV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pbroadcastw256_gpr_mask, "V16shV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_pbroadcastw128_gpr_mask, "V8ssV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdb512_mask, "V16cV16iV16cUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsdb512mem_mask, "vV16c*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovswb512mem_mask, "vV32c*V32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsdw512_mask, "V16sV16iV16sUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsdw512mem_mask, "vV16s*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqb512_mask, "V16cV8LLiV16cUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqb512mem_mask, "vV16c*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqd512_mask, "V8iV8LLiV8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqd512mem_mask, "vV8i*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqw512_mask, "V8sV8LLiV8sUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsqw512mem_mask, "vV8s*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovsdb128_mask, "V16cV4iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdb128mem_mask, "vV16c*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovswb128mem_mask, "vV16c*V8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsdb256_mask, "V16cV8iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdb256mem_mask, "vV16c*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovswb256mem_mask, "vV16c*V16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovsdw128_mask, "V8sV4iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdw128mem_mask, "vV8s*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdw256_mask, "V8sV8iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsdw256mem_mask, "vV8s*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqb128_mask, "V16cV2LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqb128mem_mask, "vV16c*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqb256_mask, "V16cV4LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqb256mem_mask, "vV16c*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqd128_mask, "V4iV2LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqd128mem_mask, "vV4i*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqd256_mask, "V4iV4LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqd256mem_mask, "vV4i*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqw128_mask, "V8sV2LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqw128mem_mask, "vV8s*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqw256_mask, "V8sV4LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovsqw256mem_mask, "vV8s*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdb512_mask, "V16cV16iV16cUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusdb512mem_mask, "vV16c*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovuswb512mem_mask, "vV32c*V32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovusdw512_mask, "V16sV16iV16sUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusdw512mem_mask, "vV16s*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqb512_mask, "V16cV8LLiV16cUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqb512mem_mask, "vV16c*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqd512_mask, "V8iV8LLiV8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqd512mem_mask, "vV8i*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqw512_mask, "V8sV8LLiV8sUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusqw512mem_mask, "vV8s*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovusdb128_mask, "V16cV4iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdb128mem_mask, "vV16c*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovuswb128mem_mask, "vV16c*V8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovusdb256_mask, "V16cV8iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdb256mem_mask, "vV16c*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovuswb256mem_mask, "vV16c*V16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovusdw128_mask, "V8sV4iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdw128mem_mask, "vV8s*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdw256_mask, "V8sV8iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusdw256mem_mask, "vV8s*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqb128_mask, "V16cV2LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqb128mem_mask, "vV16c*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqb256_mask, "V16cV4LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqb256mem_mask, "vV16c*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqd128_mask, "V4iV2LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqd128mem_mask, "vV4i*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqd256_mask, "V4iV4LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqd256mem_mask, "vV4i*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqw128_mask, "V8sV2LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqw128mem_mask, "vV8s*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqw256_mask, "V8sV4LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovusqw256mem_mask, "vV8s*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdb512_mask, "V16cV16iV16cUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovdb512mem_mask, "vV16c*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovwb512mem_mask, "vV32c*V32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovdw512_mask, "V16sV16iV16sUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovdw512mem_mask, "vV16s*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqb512_mask, "V16cV8LLiV16cUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqb512mem_mask, "vV16c*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqd512_mask, "V8iV8LLiV8iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqd512mem_mask, "vV8i*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqw512_mask, "V8sV8LLiV8sUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovqw512mem_mask, "vV8s*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_pmovdb128_mask, "V16cV4iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovwb128mem_mask, "vV16c*V8sUc","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovdb128mem_mask, "vV16c*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdb256_mask, "V16cV8iV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdb256mem_mask, "vV16c*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovwb256mem_mask, "vV16c*V16sUs","","avx512vl,avx512bw") +TARGET_BUILTIN(__builtin_ia32_pmovdw128_mask, "V8sV4iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdw128mem_mask, "vV8s*V4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdw256_mask, "V8sV8iV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovdw256mem_mask, "vV8s*V8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqb128_mask, "V16cV2LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqb128mem_mask, "vV16c*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqb256_mask, "V16cV4LLiV16cUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqb256mem_mask, "vV16c*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqd128_mask, "V4iV2LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqd128mem_mask, "vV4i*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqd256_mask, "V4iV4LLiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqd256mem_mask, "vV4i*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqw128_mask, "V8sV2LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqw128mem_mask, "vV8s*V2LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqw256_mask, "V8sV4LLiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_pmovqw256mem_mask, "vV8s*V4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_extractf32x8_mask, "V8fV16fIiV8fUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_extractf64x2_512_mask, "V2dV8dIiV2dUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_extracti32x8_mask, "V8iV16iIiV8iUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_extracti64x2_512_mask, "V2LLiV8LLiIiV2LLiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_extracti32x4_mask, "V4iV16iIiV4iUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_extracti64x4_mask, "V4LLiV8LLiIiV4LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_extractf64x2_256_mask, "V2dV4dIiV2dUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_extracti64x2_256_mask, "V2LLiV4LLiIiV2LLiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_extractf32x4_256_mask, "V4fV8fIiV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_extracti32x4_256_mask, "V4iV8iIiV4iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_insertf32x8_mask, "V16fV16fV8fIiV16fUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_insertf64x2_512_mask, "V8dV8dV2dIiV8dUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_inserti32x8_mask, "V16iV16iV8iIiV16iUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_inserti64x2_512_mask, "V8LLiV8LLiV2LLiIiV8LLiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_insertf64x4_mask, "V8dV8dV4dIiV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_inserti64x4_mask, "V8LLiV8LLiV4LLiIiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_insertf64x2_256_mask, "V4dV4dV2dIiV4dUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_inserti64x2_256_mask, "V4LLiV4LLiV2LLiIiV4LLiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_insertf32x4_256_mask, "V8fV8fV4fIiV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_inserti32x4_256_mask, "V8iV8iV4iIiV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_insertf32x4_mask, "V16fV16fV4fIiV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_inserti32x4_mask, "V16iV16iV4iIiV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getmantpd128_mask, "V2dV2diV2dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_getmantpd256_mask, "V4dV4diV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_getmantps128_mask, "V4fV4fiV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_getmantps256_mask, "V8fV8fiV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_getmantpd512_mask, "V8dV8diV8dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getmantps512_mask, "V16fV16fiV16fUsIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getexppd512_mask, "V8dV8dV8dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_getexpps512_mask, "V16fV16fV16fUsIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddss3_mask, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddss3_maskz, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddss3_mask3, "V4fV4fV4fV4fUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddsd3_mask, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddsd3_maskz, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_vfmaddsd3_mask3, "V2dV2dV2dV2dUcIi", "", "avx512f") +TARGET_BUILTIN(__builtin_ia32_permvarhi512_mask, "V32sV32sV32sV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_permvardf512_mask, "V8dV8dV8LLiV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_permvardi512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_permvarsf512_mask, "V16fV16fV16iV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_permvarsi512_mask, "V16iV16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_permvarqi512_mask, "V64cV64cV64cV64cULLi","","avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_permvarqi128_mask, "V16cV16cV16cV16cUs","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvarqi256_mask, "V32cV32cV32cV32cUi","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvarhi128_mask, "V8sV8sV8sV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvarhi256_mask, "V16sV16sV16sV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvardf256_mask, "V4dV4dV4LLiV4dUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvardi256_mask, "V4LLiV4LLiV4LLiV4LLiUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvarsf256_mask, "V8fV8fV8iV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_permvarsi256_mask, "V8iV8iV8iV8iUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_fpclasspd128_mask, "UcV2dIiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_fpclasspd256_mask, "UcV4dIiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_fpclassps128_mask, "UcV4fIiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_fpclassps256_mask, "UcV8fIiUc","","avx512dq,avx512vl") +TARGET_BUILTIN(__builtin_ia32_fpclassps512_mask, "UsV16fIiUs","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_fpclasspd512_mask, "UcV8dIiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_fpclasssd_mask, "UcV2dIiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_fpclassss_mask, "UcV4fIiUc","","avx512dq") +TARGET_BUILTIN(__builtin_ia32_kandhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kandnhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_korhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kortestchi, "iUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kortestzhi, "iUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kunpckhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kxnorhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_kxorhi, "UsUsUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_movntdqa512, "V8LLiV8LLi*","","avx512f") +TARGET_BUILTIN(__builtin_ia32_palignr512_mask, "V64cV64cV64cIiV64cULLi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_palignr128_mask, "V16cV16cV16cIiV16cUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_palignr256_mask, "V32cV32cV32cIiV32cUi","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_dbpsadbw128_mask, "V8sV16cV16cIiV8sUc","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_dbpsadbw256_mask, "V16sV32cV32cIiV16sUs","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_dbpsadbw512_mask, "V32sV64cV64cIiV32sUi","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_psadbw512, "V8LLiV64cV64c","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_compressdf512_mask, "V8dV8dV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compressdi512_mask, "V8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compresssf512_mask, "V16fV16fV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compresssi512_mask, "V16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cmpsd_mask, "UcV2dV2dIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cmpss_mask, "UcV4fV4fIiUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expanddf512_mask, "V8dV8dV8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expanddi512_mask, "V8LLiV8LLiV8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandloaddf512_mask, "V8dV8dC*V8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandloaddi512_mask, "V8LLiV8LLiC*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandloadsf512_mask, "V16fV16fC*V16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandloadsi512_mask, "V16iV16iC*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandsf512_mask, "V16fV16fV16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_expandsi512_mask, "V16iV16iV16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtps2pd512_mask, "V8dV8fV8dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compressstoredf512_mask, "vV8d*V8dUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compressstoredi512_mask, "vV8LLi*V8LLiUc","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compressstoresf512_mask, "vV16f*V16fUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_compressstoresi512_mask, "vV16i*V16iUs","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vcvtph2ps_mask, "V4fV8sV4fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vcvtph2ps256_mask, "V8fV8sV8fUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vcvtps2ph_mask, "V8sV4fIiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_vcvtps2ph256_mask, "V8sV8fIiV8sUc","","avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtw2mask512, "UiV32s","","avx512bw") +TARGET_BUILTIN(__builtin_ia32_cvtw2mask128, "UcV8s","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtw2mask256, "UsV16s","","avx512bw,avx512vl") +TARGET_BUILTIN(__builtin_ia32_cvtsd2ss_round_mask, "V4fV4fV2dV4fUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtsi2sd64, "V2dV2dLLiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtsi2ss32, "V4fV4fiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtsi2ss64, "V4fV4fLLiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtss2sd_round_mask, "V2dV2dV4fV2dUcIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtusi2sd32, "V2dV2dUi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtusi2sd64, "V2dV2dULLiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtusi2ss32, "V4fV4fUiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_cvtusi2ss64, "V4fV4fULLiIi","","avx512f") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb512_mask, "V64cV64cV64cV64cULLi","","avx512vbmi") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb128_mask, "V16cV16cV16cV16cUs","","avx512vbmi,avx512vl") +TARGET_BUILTIN(__builtin_ia32_vpmultishiftqb256_mask, "V32cV32cV32cV32cUi","","avx512vbmi,avx512vl") + +// generic select intrinsics +TARGET_BUILTIN(__builtin_ia32_selectb_128, "V16cUsV16cV16c", "", "") +TARGET_BUILTIN(__builtin_ia32_selectb_256, "V32cUiV32cV32c", "", "") +TARGET_BUILTIN(__builtin_ia32_selectb_512, "V64cULLiV64cV64c", "", "") +TARGET_BUILTIN(__builtin_ia32_selectw_128, "V8sUcV8sV8s", "", "") +TARGET_BUILTIN(__builtin_ia32_selectw_256, "V16sUsV16sV16s", "", "") +TARGET_BUILTIN(__builtin_ia32_selectw_512, "V32sUiV32sV32s", "", "") +TARGET_BUILTIN(__builtin_ia32_selectd_128, "V4iUcV4iV4i", "", "") +TARGET_BUILTIN(__builtin_ia32_selectd_256, "V8iUcV8iV8i", "", "") +TARGET_BUILTIN(__builtin_ia32_selectd_512, "V16iUsV16iV16i", "", "") +TARGET_BUILTIN(__builtin_ia32_selectq_128, "V2LLiUcV2LLiV2LLi", "", "") +TARGET_BUILTIN(__builtin_ia32_selectq_256, "V4LLiUcV4LLiV4LLi", "", "") +TARGET_BUILTIN(__builtin_ia32_selectq_512, "V8LLiUcV8LLiV8LLi", "", "") +TARGET_BUILTIN(__builtin_ia32_selectps_128, "V4fUcV4fV4f", "", "") +TARGET_BUILTIN(__builtin_ia32_selectps_256, "V8fUcV8fV8f", "", "") +TARGET_BUILTIN(__builtin_ia32_selectps_512, "V16fUsV16fV16f", "", "") +TARGET_BUILTIN(__builtin_ia32_selectpd_128, "V2dUcV2dV2d", "", "") +TARGET_BUILTIN(__builtin_ia32_selectpd_256, "V4dUcV4dV4d", "", "") +TARGET_BUILTIN(__builtin_ia32_selectpd_512, "V8dUcV8dV8d", "", "") + +// MONITORX/MWAITX +TARGET_BUILTIN(__builtin_ia32_monitorx, "vv*UiUi", "", "mwaitx") +TARGET_BUILTIN(__builtin_ia32_mwaitx, "vUiUiUi", "", "mwaitx") #undef BUILTIN #undef TARGET_BUILTIN diff --git a/include/clang/Basic/Cuda.h b/include/clang/Basic/Cuda.h new file mode 100644 index 000000000000..ad1139b8c197 --- /dev/null +++ b/include/clang/Basic/Cuda.h @@ -0,0 +1,77 @@ +//===--- Cuda.h - Utilities for compiling CUDA code ------------*- 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_CUDA_H +#define LLVM_CLANG_BASIC_CUDA_H + +namespace llvm { +class StringRef; +} // namespace llvm + +namespace clang { + +enum class CudaVersion { + UNKNOWN, + CUDA_70, + CUDA_75, + CUDA_80, +}; +const char *CudaVersionToString(CudaVersion V); + +// No string -> CudaVersion conversion function because there's no canonical +// spelling of the various CUDA versions. + +enum class CudaArch { + UNKNOWN, + SM_20, + SM_21, + SM_30, + SM_32, + SM_35, + SM_37, + SM_50, + SM_52, + SM_53, + SM_60, + SM_61, + SM_62, +}; +const char *CudaArchToString(CudaArch A); + +// The input should have the form "sm_20". +CudaArch StringToCudaArch(llvm::StringRef S); + +enum class CudaVirtualArch { + UNKNOWN, + COMPUTE_20, + COMPUTE_30, + COMPUTE_32, + COMPUTE_35, + COMPUTE_37, + COMPUTE_50, + COMPUTE_52, + COMPUTE_53, + COMPUTE_60, + COMPUTE_61, + COMPUTE_62, +}; +const char *CudaVirtualArchToString(CudaVirtualArch A); + +// The input should have the form "compute_20". +CudaVirtualArch StringToCudaVirtualArch(llvm::StringRef S); + +/// Get the compute_xx corresponding to an sm_yy. +CudaVirtualArch VirtualArchForCudaArch(CudaArch A); + +/// Get the earliest CudaVersion that supports the given CudaArch. +CudaVersion MinVersionForCudaArch(CudaArch A); + +} // namespace clang + +#endif diff --git a/include/clang/Basic/DebugInfoOptions.h b/include/clang/Basic/DebugInfoOptions.h new file mode 100644 index 000000000000..e7ff4a662b63 --- /dev/null +++ b/include/clang/Basic/DebugInfoOptions.h @@ -0,0 +1,39 @@ +//===--- DebugInfoOptions.h - Debug Info Emission Types ---------*- 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_DEBUGINFOOPTIONS_H +#define LLVM_CLANG_BASIC_DEBUGINFOOPTIONS_H + +namespace clang { +namespace codegenoptions { + +enum DebugInfoKind { + NoDebugInfo, /// Don't generate debug info. + LocTrackingOnly, /// Emit location information but do not generate + /// debug info in the output. This is useful in + /// cases where the backend wants to track source + /// locations for instructions without actually + /// emitting debug info for them (e.g., when -Rpass + /// is used). + DebugLineTablesOnly, /// Emit only debug info necessary for generating + /// line number tables (-gline-tables-only). + LimitedDebugInfo, /// Limit generated debug info to reduce size + /// (-fno-standalone-debug). This emits + /// forward decls for types that could be + /// replaced with forward decls in the source + /// code. For dynamic C++ classes type info + /// is only emitted int the module that + /// contains the classe's vtable. + FullDebugInfo /// Generate complete debug info. +}; + +} // end namespace codegenoptions +} // end namespace clang + +#endif diff --git a/include/clang/Basic/DeclNodes.td b/include/clang/Basic/DeclNodes.td index 723ea547d8aa..4f7bbc078d98 100644 --- a/include/clang/Basic/DeclNodes.td +++ b/include/clang/Basic/DeclNodes.td @@ -11,6 +11,8 @@ class DDecl<Decl base, bit abstract = 0> : Decl<abstract> { class DeclContext { } def TranslationUnit : Decl, DeclContext; +def PragmaComment : Decl; +def PragmaDetectMismatch : Decl; def ExternCContext : Decl, DeclContext; def Named : Decl<1>; def Namespace : DDecl<Named>, DeclContext; @@ -35,6 +37,7 @@ def Named : Decl<1>; def EnumConstant : DDecl<Value>; def UnresolvedUsingValue : DDecl<Value>; def IndirectField : DDecl<Value>; + def OMPDeclareReduction : DDecl<Value>, DeclContext; def Declarator : DDecl<Value, 1>; def Field : DDecl<Declarator>; def ObjCIvar : DDecl<Field>; @@ -51,6 +54,7 @@ def Named : Decl<1>; : DDecl<VarTemplateSpecialization>; def ImplicitParam : DDecl<Var>; def ParmVar : DDecl<Var>; + def OMPCapturedExpr : DDecl<Var>; def NonTypeTemplateParm : DDecl<Declarator>; def Template : DDecl<Named, 1>; def RedeclarableTemplate : DDecl<Template, 1>; @@ -62,6 +66,7 @@ def Named : Decl<1>; def BuiltinTemplate : DDecl<Template>; def Using : DDecl<Named>; def UsingShadow : DDecl<Named>; + def ConstructorUsingShadow : DDecl<UsingShadow>; def ObjCMethod : DDecl<Named>, DeclContext; def ObjCContainer : DDecl<Named, 1>, DeclContext; def ObjCCategory : DDecl<ObjCContainer>; diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h index 1d6c19bc9539..085faeae4834 100644 --- a/include/clang/Basic/Diagnostic.h +++ b/include/clang/Basic/Diagnostic.h @@ -173,6 +173,7 @@ private: bool WarningsAsErrors; // Treat warnings like errors. bool EnableAllWarnings; // Enable all warnings. bool ErrorsAsFatal; // Treat errors like fatal errors. + bool FatalsAsError; // Treat fatal errors like errors. bool SuppressSystemWarnings; // Suppress warnings in system headers. bool SuppressAllDiagnostics; // Suppress all diagnostics. bool ElideType; // Elide common types of templates. @@ -455,6 +456,12 @@ public: void setErrorsAsFatal(bool Val) { ErrorsAsFatal = Val; } bool getErrorsAsFatal() const { return ErrorsAsFatal; } + /// \brief When set to true, any fatal error reported is made an error. + /// + /// This setting takes precedence over the setErrorsAsFatal setting above. + void setFatalsAsError(bool Val) { FatalsAsError = Val; } + bool getFatalsAsError() const { return FatalsAsError; } + /// \brief When set to true mask warnings that come from system headers. void setSuppressSystemWarnings(bool Val) { SuppressSystemWarnings = Val; } bool getSuppressSystemWarnings() const { return SuppressSystemWarnings; } @@ -1065,10 +1072,10 @@ inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, // so that we only match those arguments that are (statically) DeclContexts; // other arguments that derive from DeclContext (e.g., RecordDecls) will not // match. -template<typename T> -inline -typename std::enable_if<std::is_same<T, DeclContext>::value, - const DiagnosticBuilder &>::type +template <typename T> +inline typename std::enable_if< + std::is_same<typename std::remove_const<T>::type, DeclContext>::value, + const DiagnosticBuilder &>::type operator<<(const DiagnosticBuilder &DB, T *DC) { DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), DiagnosticsEngine::ak_declcontext); diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td index 0b37030d7eec..03ed8aa74597 100644 --- a/include/clang/Basic/DiagnosticASTKinds.td +++ b/include/clang/Basic/DiagnosticASTKinds.td @@ -26,6 +26,9 @@ def note_constexpr_lshift_discards : Note<"signed left shift discards bits">; def note_constexpr_invalid_function : Note< "%select{non-constexpr|undefined}0 %select{function|constructor}1 %2 cannot " "be used in a constant expression">; +def note_constexpr_invalid_inhctor : Note< + "constructor inherited from base class %0 cannot be used in a " + "constant expression; derived class cannot be implicitly initialized">; def note_constexpr_no_return : Note< "control reached end of constexpr function">; def note_constexpr_virtual_call : Note< @@ -141,6 +144,8 @@ def note_constexpr_calls_suppressed : Note< "(skipping %0 call%s0 in backtrace; use -fconstexpr-backtrace-limit=0 to " "see all)">; def note_constexpr_call_here : Note<"in call to '%0'">; +def note_constexpr_inherited_ctor_call_here : Note< + "in implicit initialization for inherited constructor of %0">; def note_constexpr_baa_insufficient_alignment : Note< "%select{alignment of|offset of the aligned pointer from}0 the base pointee " "object (%1 %plural{1:byte|:bytes}1) is %select{less than|not a multiple of}0 the " @@ -153,6 +158,12 @@ def warn_integer_constant_overflow : Warning< "overflow in expression; result is %0 with type %1">, InGroup<DiagGroup<"integer-overflow">>; +// This is a temporary diagnostic, and shall be removed once our +// implementation is complete, and like the preceding constexpr notes belongs +// in Sema. +def note_unimplemented_constexpr_lambda_feature_ast : Note< + "unimplemented constexpr lambda feature: %0 (coming soon!)">; + // inline asm related. let CategoryName = "Inline Assembly Issue" in { def err_asm_invalid_escape : Error< diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index ccc271a69f91..1c3bbfc11840 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -89,7 +89,7 @@ def err_module_unavailable : Error< def err_module_header_missing : Error< "%select{|umbrella }0header '%1' not found">; def err_module_lock_failure : Error< - "could not acquire lock file for module '%0'">, DefaultFatal; + "could not acquire lock file for module '%0': %1">, DefaultFatal; def err_module_lock_timeout : Error< "timed out waiting to acquire lock file for module '%0'">, DefaultFatal; def err_module_cycle : Error<"cyclic dependency in module '%0': %1">, @@ -157,6 +157,8 @@ def ext_old_implicitly_unsigned_long_cxx : ExtWarn< "this literal will %select{have type 'long long'|be ill-formed}0 " "in C++11 onwards">, InGroup<CXX11Compat>; +def ext_clang_enable_if : Extension<"'enable_if' is a clang extension">, + InGroup<GccCompat>; // SEH def err_seh_expected_handler : Error< @@ -178,6 +180,9 @@ def err_target_unknown_triple : Error< "unknown target triple '%0', please use -triple or -arch">; def err_target_unknown_cpu : Error<"unknown target CPU '%0'">; 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_target_unknown_fpmath : Error<"unknown FP unit '%0'">; def err_target_unsupported_fpmath : Error< "the '%0' unit is not supported with this instruction set">; diff --git a/include/clang/Basic/DiagnosticDriverKinds.td b/include/clang/Basic/DiagnosticDriverKinds.td index b04498f3188c..6b8db6963daa 100644 --- a/include/clang/Basic/DiagnosticDriverKinds.td +++ b/include/clang/Basic/DiagnosticDriverKinds.td @@ -23,10 +23,19 @@ def err_drv_unknown_language : Error<"language not recognized: '%0'">; def err_drv_invalid_arch_name : Error< "invalid arch name '%0'">; def err_drv_cuda_bad_gpu_arch : Error<"Unsupported CUDA gpu architecture: %0">; +def err_drv_no_cuda_installation : Error< + "cannot find CUDA installation. Provide its path via --cuda-path, or pass " + "-nocudainc to build without CUDA includes.">; +def err_drv_cuda_version_too_low : Error< + "GPU arch %1 requires CUDA version at least %3, but installation at %0 is %2. " + "Use --cuda-path to specify a different CUDA install, or pass " + "--no-cuda-version-check.">; def err_drv_invalid_thread_model_for_target : Error< "invalid thread model '%0' in '%1' for this target">; def err_drv_invalid_linker_name : Error< "invalid linker name in argument '%0'">; +def err_drv_invalid_pgo_instrumentor : Error< + "invalid PGO instrumentor in argument '%0'">; def err_drv_invalid_rtlib_name : Error< "invalid runtime library name in argument '%0'">; def err_drv_unsupported_rtlib_for_platform : Error< @@ -93,6 +102,23 @@ def err_target_unsupported_arch def err_drv_I_dash_not_supported : Error< "'%0' not supported, please use -iquote instead">; def err_drv_unknown_argument : Error<"unknown argument: '%0'">; +def warn_drv_unknown_argument_clang_cl : Warning< + "unknown argument ignored in clang-cl: '%0'">, + 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>; +def warn_drv_ycyu_no_fi_arg_clang_cl : Warning< + "support for '%0' without a corresponding /FI flag not implemented yet; flag ignored">, + InGroup<ClangClPch>; +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_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< @@ -127,6 +153,10 @@ def err_drv_no_neon_modifier : Error<"[no]neon is not accepted as modifier, plea def err_drv_invalid_omp_target : Error<"OpenMP target is invalid: '%0'">; def err_drv_omp_host_ir_file_not_found : Error< "The provided host compiler IR file '%0' is required to generate code for OpenMP target regions but cannot be found.">; +def err_drv_omp_host_target_not_supported : Error< + "The target '%0' is not a supported OpenMP host target.">; +def err_drv_bitcode_unsupported_on_toolchain : Error< + "-fembed-bitcode is not supported on versions of iOS prior to 6.0">; def warn_O4_is_O3 : Warning<"-O4 is equivalent to -O3">, InGroup<Deprecated>; def warn_drv_lto_libpath : Warning<"libLTO.dylib relative to clang installed dir not found; using 'ld' default search path instead">, @@ -172,6 +202,8 @@ def warn_drv_pch_not_first_include : Warning< "precompiled header '%0' was ignored because '%1' is not first '-include'">; def warn_missing_sysroot : Warning<"no such sysroot directory: '%0'">, InGroup<DiagGroup<"missing-sysroot">>; +def warn_incompatible_sysroot : Warning<"using sysroot for '%0' but targeting '%1'">, + InGroup<DiagGroup<"incompatible-sysroot">>; def warn_debug_compression_unavailable : Warning<"cannot compress debug sections (zlib not installed)">, InGroup<DiagGroup<"debug-compression-unavailable">>; def warn_drv_enabling_rtti_with_exceptions : Warning< @@ -210,6 +242,9 @@ def warn_target_unsupported_nan2008 : Warning< def warn_target_unsupported_nanlegacy : Warning< "ignoring '-mnan=legacy' option because the '%0' architecture does not support it">, InGroup<UnsupportedNan>; +def warn_target_unsupported_compact_branches : Warning< + "ignoring '-mcompact-branches=' option because the '%0' architecture does not" + " support it">, InGroup<UnsupportedCB>; def warn_drv_unable_to_find_directory_expected : Warning< "unable to find %0 directory, expected to be in '%1'">, @@ -220,7 +255,7 @@ def warn_drv_ps4_force_pic : Warning< InGroup<OptionIgnored>; def warn_drv_ps4_sdk_dir : Warning< - "environment variable SCE_PS4_SDK_DIR is set, but points to invalid or nonexistent directory '%0'">, + "environment variable SCE_ORBIS_SDK_DIR is set, but points to invalid or nonexistent directory '%0'">, InGroup<InvalidOrNonExistentDirectory>; def err_drv_unsupported_linker : Error<"unsupported value '%0' for -linker option">; diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td index 033834bc505d..2aa8f103500d 100644 --- a/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/include/clang/Basic/DiagnosticFrontendKinds.td @@ -58,8 +58,10 @@ def remark_fe_backend_optimization_remark_analysis_aliasing : Remark<"%0; " BackendInfo, InGroup<BackendOptimizationRemarkAnalysis>; def warn_fe_backend_optimization_failure : Warning<"%0">, BackendInfo, InGroup<BackendOptimizationFailure>, DefaultWarn; -def note_fe_backend_optimization_remark_invalid_loc : Note<"could " - "not determine the original source location for %0:%1:%2">; +def note_fe_backend_invalid_loc : Note<"could " + "not determine the original source location for %0:%1:%2">, BackendInfo; + +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, @@ -208,12 +210,11 @@ def err_test_module_file_extension_version : Error< "test module file extension '%0' has different version (%1.%2) than expected " "(%3.%4)">; -def err_conflicting_module_names : Error< - "conflicting module names specified: '-fmodule-name=%0' and " - "'-fmodule-implementation-of %1'">; - def err_missing_vfs_overlay_file : Error< "virtual filesystem overlay file '%0' not found">, DefaultFatal; def err_invalid_vfs_overlay : Error< "invalid virtual filesystem overlay file '%0'">, DefaultFatal; -} + +def warn_option_invalid_ocl_version : Warning< + "OpenCL version %0 does not support the option '%1'">, InGroup<Deprecated>; +}
\ No newline at end of file diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index 2e4e57b63b8e..72dfedbbaef0 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -46,10 +46,17 @@ def BoolConversion : DiagGroup<"bool-conversion", [PointerBoolConversion, UndefinedBoolConversion]>; def IntConversion : DiagGroup<"int-conversion">; def EnumConversion : DiagGroup<"enum-conversion">; -def FloatConversion : DiagGroup<"float-conversion">; + +def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">; +def FloatZeroConversion : DiagGroup<"float-zero-conversion">; +def FloatConversion : + DiagGroup<"float-conversion", [FloatOverflowConversion, + FloatZeroConversion]>; + def DoublePromotion : DiagGroup<"double-promotion">; def EnumTooLarge : DiagGroup<"enum-too-large">; def UnsupportedNan : DiagGroup<"unsupported-nan">; +def UnsupportedCB : DiagGroup<"unsupported-cb">; def NonLiteralNullConversion : DiagGroup<"non-literal-null-conversion">; def NullConversion : DiagGroup<"null-conversion">; def ImplicitConversionFloatingPointToBool : @@ -75,6 +82,8 @@ def : DiagGroup<"ctor-dtor-privacy">; def GNUDesignator : DiagGroup<"gnu-designator">; def GNUStringLiteralOperatorTemplate : DiagGroup<"gnu-string-literal-operator-template">; +def UndefinedVarTemplate : DiagGroup<"undefined-var-template">; +def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">; def DeleteIncomplete : DiagGroup<"delete-incomplete">; def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">; @@ -87,6 +96,7 @@ def DeprecatedAttributes : DiagGroup<"deprecated-attributes">; def DeprecatedDeclarations : DiagGroup<"deprecated-declarations">; def UnavailableDeclarations : DiagGroup<"unavailable-declarations">; def PartialAvailability : DiagGroup<"partial-availability">; +def UnguardedAvailability : DiagGroup<"unguarded-availability">; def DeprecatedImplementations :DiagGroup<"deprecated-implementations">; def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">; def DeprecatedRegister : DiagGroup<"deprecated-register">; @@ -204,6 +214,7 @@ def OverloadedShiftOpParentheses: DiagGroup<"overloaded-shift-op-parentheses">; def DanglingElse: DiagGroup<"dangling-else">; def DanglingField : DiagGroup<"dangling-field">; def DistributedObjectModifiers : DiagGroup<"distributed-object-modifiers">; +def ExpansionToDefined : DiagGroup<"expansion-to-defined">; def FlagEnum : DiagGroup<"flag-enum">; def IncrementBool : DiagGroup<"increment-bool", [DeprecatedIncrementBool]>; def InfiniteRecursion : DiagGroup<"infinite-recursion">; @@ -283,8 +294,6 @@ def : DiagGroup<"overflow">; def ForwardClassReceiver : DiagGroup<"receiver-forward-class">; def MethodAccess : DiagGroup<"objc-method-access">; def ObjCReceiver : DiagGroup<"receiver-expr">; -// FIXME: Remove this when Xcode removes the warning setting. -def : DiagGroup<"receiver-is-weak">; def OperatorNewReturnsNull : DiagGroup<"new-returns-null">; def OverlengthStrings : DiagGroup<"overlength-strings">; def OverloadedVirtual : DiagGroup<"overloaded-virtual">; @@ -330,7 +339,16 @@ def SelfMove : DiagGroup<"self-move">; def SemiBeforeMethodBody : DiagGroup<"semicolon-before-method-body">; def Sentinel : DiagGroup<"sentinel">; def MissingMethodReturnType : DiagGroup<"missing-method-return-type">; -def Shadow : DiagGroup<"shadow">; + +def ShadowFieldInConstructorModified : DiagGroup<"shadow-field-in-constructor-modified">; +def ShadowFieldInConstructor : DiagGroup<"shadow-field-in-constructor", + [ShadowFieldInConstructorModified]>; + +// -Wshadow-all is a catch-all for all shadowing. -Wshadow is just the +// shadowing that we think is unsafe. +def Shadow : DiagGroup<"shadow", [ShadowFieldInConstructorModified]>; +def ShadowAll : DiagGroup<"shadow-all", [Shadow, ShadowFieldInConstructor]>; + def Shorten64To32 : DiagGroup<"shorten-64-to-32">; def : DiagGroup<"sign-promo">; def SignCompare : DiagGroup<"sign-compare">; @@ -756,6 +774,7 @@ def MicrosoftEnumValue : DiagGroup<"microsoft-enum-value">; def MicrosoftDefaultArgRedefinition : DiagGroup<"microsoft-default-arg-redefinition">; def MicrosoftTemplate : DiagGroup<"microsoft-template">; +def MicrosoftInconsistentDllImport : DiagGroup<"inconsistent-dllimport">; def MicrosoftRedeclareStatic : DiagGroup<"microsoft-redeclare-static">; def MicrosoftEnumForwardReference : DiagGroup<"microsoft-enum-forward-reference">; @@ -782,7 +801,10 @@ def Microsoft : DiagGroup<"microsoft", MicrosoftRedeclareStatic, MicrosoftEnumForwardReference, MicrosoftGoto, MicrosoftFlexibleArray, MicrosoftExtraQualification, MicrosoftCast, MicrosoftConstInit, MicrosoftVoidPseudoDtor, MicrosoftAnonTag, - MicrosoftCommentPaste, MicrosoftEndOfFile]>; + MicrosoftCommentPaste, MicrosoftEndOfFile, + MicrosoftInconsistentDllImport]>; + +def ClangClPch : DiagGroup<"clang-cl-pch">; def ObjCNonUnifiedException : DiagGroup<"objc-nonunified-exceptions">; @@ -816,6 +838,7 @@ def ASM : DiagGroup<"asm", [ def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">; def OpenMPClauses : DiagGroup<"openmp-clauses">; def OpenMPLoopForm : DiagGroup<"openmp-loop-form">; +def OpenMPTarget : DiagGroup<"openmp-target">; // Backend warnings. def BackendInlineAsm : DiagGroup<"inline-asm">; @@ -847,3 +870,5 @@ def FutureCompat : DiagGroup<"future-compat">; def InvalidOrNonExistentDirectory : DiagGroup<"invalid-or-nonexistent-directory">; def OptionIgnored : DiagGroup<"option-ignored">; + +def UnknownArgument : DiagGroup<"unknown-argument">; diff --git a/include/clang/Basic/DiagnosticIDs.h b/include/clang/Basic/DiagnosticIDs.h index 312b71f4064d..fcd04a0be187 100644 --- a/include/clang/Basic/DiagnosticIDs.h +++ b/include/clang/Basic/DiagnosticIDs.h @@ -36,7 +36,7 @@ namespace clang { DIAG_START_AST = DIAG_START_PARSE + 500, DIAG_START_COMMENT = DIAG_START_AST + 110, DIAG_START_SEMA = DIAG_START_COMMENT + 100, - DIAG_START_ANALYSIS = DIAG_START_SEMA + 3000, + DIAG_START_ANALYSIS = DIAG_START_SEMA + 3500, DIAG_UPPER_LIMIT = DIAG_START_ANALYSIS + 100 }; diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td index 2fc9664f49e5..604d51db1ffe 100644 --- a/include/clang/Basic/DiagnosticLexKinds.td +++ b/include/clang/Basic/DiagnosticLexKinds.td @@ -175,10 +175,17 @@ def err_multichar_utf_character_literal : Error< def err_exponent_has_no_digits : Error<"exponent has no digits">; def ext_imaginary_constant : Extension< "imaginary constants are a GNU extension">, InGroup<GNUImaginaryConstant>; -def err_hexconstant_requires: Error< - "hexadecimal floating constants require %select{an exponent|a significand}0">; -def ext_hexconstant_invalid : Extension< +def err_hex_constant_requires : Error< + "hexadecimal floating %select{constant|literal}0 requires " + "%select{an exponent|a significand}1">; +def ext_hex_constant_invalid : Extension< "hexadecimal floating constants are a C99 feature">, InGroup<C99>; +def ext_hex_literal_invalid : Extension< + "hexadecimal floating literals are a C++1z feature">, InGroup<CXX1z>; +def warn_cxx1z_hex_literal : Warning< + "hexidecimal floating literals are incompatible with " + "C++ standards before C++1z">, + InGroup<CXXPre1zCompatPedantic>, DefaultIgnore; def ext_binary_literal : Extension< "binary integer literals are a GNU extension">, InGroup<GNUBinaryLiteral>; def ext_binary_literal_cxx14 : Extension< @@ -267,6 +274,14 @@ def ext_missing_whitespace_after_macro_name : ExtWarn< "whitespace required after macro name">; def warn_missing_whitespace_after_macro_name : Warning< "whitespace recommended after macro name">; + +class NonportablePath : Warning< + "non-portable path to file '%0'; specified path differs in case from file" + " name on disk">; +def pp_nonportable_path : NonportablePath, + InGroup<DiagGroup<"nonportable-include-path">>; +def pp_nonportable_system_path : NonportablePath, DefaultIgnore, + InGroup<DiagGroup<"nonportable-system-include-path">>; def pp_pragma_once_in_main_file : Warning<"#pragma once in main file">, InGroup<DiagGroup<"pragma-once-outside-header">>; @@ -380,7 +395,7 @@ def err_pp_expected_comma_in_arg_list : Error< def err_pp_duplicate_name_in_arg_list : Error< "duplicate macro parameter name %0">; def err_pp_stringize_not_parameter : Error< - "'#' is not followed by a macro parameter">; + "'%select{#|#@}0' is not followed by a macro parameter">; def err_pp_malformed_ident : Error<"invalid #ident directive">; def err_pp_unterminated_conditional : Error< "unterminated conditional directive">; @@ -394,6 +409,7 @@ def err_pp_expected_rparen : Error<"expected ')' in preprocessor expression">; def err_pp_expected_eol : Error< "expected end of line in preprocessor expression">; def err_pp_expected_after : Error<"missing %1 after %0">; +def err_pp_nested_paren : Error<"nested parentheses not permitted in %0">; def err_pp_colon_without_question : Error<"':' without preceding '?'">; def err_pp_division_by_zero : Error< "division by zero in preprocessor expression">; @@ -401,6 +417,8 @@ def err_pp_remainder_by_zero : Error< "remainder by zero in preprocessor expression">; def err_pp_expr_bad_token_binop : Error< "token is not a valid binary operator in a preprocessor subexpression">; +def err_pp_expr_bad_token_lparen : Error< + "function-like macro %0 is not defined">; def err_pp_expr_bad_token_start_expr : Error< "invalid token at start of a preprocessor expression">; def err_pp_invalid_poison : Error<"can only poison identifier tokens">; @@ -409,8 +427,6 @@ def err_pp_used_poisoned_id : Error<"attempt to use a poisoned identifier">; def err_feature_check_malformed : Error< "builtin feature check macro requires a parenthesized identifier">; -def err_warning_check_malformed : Error< - "builtin warning check macro requires a parenthesized string">; def warn_has_warning_invalid_option : ExtWarn<"__has_warning expected option name (e.g. \"-Wundef\")">, InGroup<MalformedWarningCheck>; @@ -658,6 +674,13 @@ def warn_header_guard : Warning< def note_header_guard : Note< "%0 is defined here; did you mean %1?">; +def warn_defined_in_object_type_macro : Warning< + "macro expansion producing 'defined' has undefined behavior">, + InGroup<ExpansionToDefined>; +def warn_defined_in_function_type_macro : Extension< + "macro expansion producing 'defined' has undefined behavior">, + InGroup<ExpansionToDefined>; + let CategoryName = "Nullability Issue" in { def err_pp_assume_nonnull_syntax : Error<"expected 'begin' or 'end'">; diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index f8dee2f98cca..e5c64681e48f 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -27,6 +27,8 @@ def err_msasm_unable_to_create_target : Error< "MS-style inline assembly is not available: %0">; def err_gnu_inline_asm_disabled : Error< "GNU-style inline assembly is disabled">; +def err_asm_goto_not_supported_yet : Error< + "'asm goto' constructs are not supported yet">; } let CategoryName = "Parse Issue" in { @@ -510,6 +512,11 @@ def err_function_is_not_record : Error< "unexpected %0 in function call; perhaps remove the %0?">; def err_super_in_using_declaration : Error< "'__super' cannot be used with a using declaration">; +def ext_constexpr_if : ExtWarn< + "constexpr if is a C++1z extension">, InGroup<CXX1z>; +def warn_cxx14_compat_constexpr_if : Warning< + "constexpr if is incompatible with C++ standards before C++1z">, + DefaultIgnore, InGroup<CXXPre1zCompat>; // C++ derived classes def err_dup_virtual : Error<"duplicate 'virtual' in base specifier">; @@ -553,6 +560,14 @@ def err_cxx11_attribute_forbids_ellipsis : Error< "attribute '%0' cannot be used as an attribute pack">; def err_cxx11_attribute_repeated : Error< "attribute %0 cannot appear multiple times in an attribute specifier">; +def warn_cxx14_compat_using_attribute_ns : Warning< + "default scope specifier for attributes is incompatible with C++ standards " + "before C++1z">, InGroup<CXXPre1zCompat>, DefaultIgnore; +def ext_using_attribute_ns : ExtWarn< + "default scope specifier for attributes is a C++1z extension">, + InGroup<CXX1z>; +def err_using_attribute_ns_conflict : Error< + "attribute with scope specifier cannot follow default scope specifier">; def err_attributes_not_allowed : Error<"an attribute list cannot appear here">; def err_l_square_l_square_not_attribute : Error< "C++11 only allows consecutive left square brackets when " @@ -765,7 +780,19 @@ def warn_cxx98_compat_lambda : Warning< InGroup<CXX98Compat>, DefaultIgnore; def err_lambda_missing_parens : Error< "lambda requires '()' before %select{'mutable'|return type|" - "attribute specifier}0">; + "attribute specifier|'constexpr'}0">; +def err_lambda_decl_specifier_repeated : Error< + "%select{'mutable'|'constexpr'}0 cannot appear multiple times in a lambda declarator">; +// C++1z lambda expressions
+def err_expected_star_this_capture : Error< + "expected 'this' following '*' in lambda capture list">; + +// C++1z constexpr lambda expressions +def warn_cxx14_compat_constexpr_on_lambda : Warning< + "constexpr on lambda expressions is incompatible with C++ standards before C++1z">, + InGroup<CXXPre1zCompat>, DefaultIgnore; +def ext_constexpr_on_lambda_cxx1z : ExtWarn< + "'constexpr' on lambda expressions is a C++1z extension">, InGroup<CXX1z>; // Availability attribute def err_expected_version : Error< @@ -776,7 +803,7 @@ def warn_expected_consistent_version_separator : Warning< def err_zero_version : Error< "version number must have non-zero major, minor, or sub-minor version">; def err_availability_expected_platform : Error< - "expected a platform name, e.g., 'macosx'">; + "expected a platform name, e.g., 'macos'">; // objc_bridge_related attribute def err_objcbridge_related_expected_related_class : Error< @@ -796,6 +823,21 @@ def warn_availability_and_unavailable : Warning< "'unavailable' availability overrides all other availability information">, InGroup<Availability>; +// @available(...) +def err_avail_query_expected_condition : Error< + "expected an availability condition here">; +def err_avail_query_expected_platform_name : Error< + "expected a platform name here">; + +def err_avail_query_unrecognized_platform_name : Error< + "unrecognized platform name %0">; +def err_availability_query_wildcard_required: Error< + "must handle potential future platforms with '*'">; +def err_availability_query_repeated_platform: Error< + "version for '%0' already specified">; +def err_availability_query_repeated_star : Error< + "'*' query has already been specified">; + // Type safety attributes def err_type_safety_unknown_flag : Error< "invalid comparison flag %0; use 'layout_compatible' or 'must_be_null'">; @@ -902,6 +944,9 @@ def err_pragma_optimize_invalid_argument : Error< def err_pragma_optimize_extra_argument : Error< "unexpected extra argument '%0' to '#pragma clang optimize'">; +def err_opencl_unroll_hint_on_non_loop : Error< + "OpenCL only supports 'opencl_unroll_hint' attribute on for, while, and do statements">; + // OpenCL EXTENSION pragma (OpenCL 1.1 [9.1]) def warn_pragma_expected_colon : Warning< "missing ':' after %0 - ignoring">, InGroup<IgnoredPragmas>; @@ -909,10 +954,16 @@ def warn_pragma_expected_enable_disable : Warning< "expected 'enable' or 'disable' - ignoring">, InGroup<IgnoredPragmas>; def warn_pragma_unknown_extension : Warning< "unknown OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>; +def warn_pragma_unsupported_extension : Warning< + "unsupported OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>; +def warn_pragma_extension_is_core : Warning< + "OpenCL extension %0 is core feature or supported optional core feature - ignoring">, InGroup<DiagGroup<"pedantic-core-features">>, DefaultIgnore; -// OpenCL error +// OpenCL errors. def err_opencl_taking_function_address_parser : Error< "taking address of function is not allowed">; +def err_opencl_logical_exclusive_or : Error< + "^^ is a reserved operator in OpenCL">; // OpenMP support. def warn_pragma_omp_ignored : Warning< @@ -934,22 +985,32 @@ def err_omp_immediate_directive : Error< "'#pragma omp %0' %select{|with '%2' clause }1cannot be an immediate substatement">; def err_omp_expected_identifier_for_critical : Error< "expected identifier specifying the name of the 'omp critical' directive">; +def err_omp_expected_reduction_identifier : Error< + "expected identifier or one of the following operators: '+', '-', '*', '&', '|', '^', '&&', or '||'">; +def err_omp_decl_in_declare_simd : Error< + "function declaration is expected after 'declare simd' directive">; 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'">; def err_omp_map_type_missing : Error< "missing map type">; +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">; // Pragma loop support. def err_pragma_loop_missing_argument : Error< "missing argument; expected %select{an integer value|" - "'enable', %select{'assume_safety'|'full'}1 or 'disable'}0">; + "'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, or unroll_count">; + "vectorize_width, interleave, interleave_count, unroll, unroll_count, or distribute">; def err_pragma_invalid_keyword : Error< - "invalid argument; expected 'enable', %select{'assume_safety'|'full'}0 or 'disable'">; + "invalid argument; expected 'enable'%select{|, 'full'}0%select{|, 'assume_safety'}1 or 'disable'">; // Pragma unroll support. def warn_pragma_unroll_cuda_value_in_parens : Warning< diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 6ba482c78e4a..1203fe765b52 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -30,23 +30,6 @@ def warn_redundant_loop_iteration : Warning< InGroup<ForLoopAnalysis>, DefaultIgnore; def note_loop_iteration_here : Note<"%select{decremented|incremented}0 here">; -def warn_for_range_const_reference_copy : Warning< - "loop variable %0 " - "%diff{has type $ but is initialized with type $" - "| is initialized with a value of a different type}1,2 resulting in a copy">, - InGroup<RangeLoopAnalysis>, DefaultIgnore; -def note_use_type_or_non_reference : Note< - "use non-reference type %0 to keep the copy or type %1 to prevent copying">; -def warn_for_range_variable_always_copy : Warning< - "loop variable %0 is always a copy because the range of type %1 does not " - "return a reference">, - InGroup<RangeLoopAnalysis>, DefaultIgnore; -def note_use_non_reference_type : Note<"use non-reference type %0">; -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 warn_duplicate_enum_values : Warning< "element %0 has been implicitly assigned %1 which another element has " "been assigned">, InGroup<DiagGroup<"duplicate-enum">>, DefaultIgnore; @@ -74,6 +57,10 @@ def warn_infinite_recursive_function : Warning< "all paths through this function will call itself">, InGroup<InfiniteRecursion>, DefaultIgnore; +def warn_comma_operator : Warning<"possible misuse of comma operator here">, + InGroup<DiagGroup<"comma">>, DefaultIgnore; +def note_cast_to_void : Note<"cast expression to void to silence warning">; + // Constant expressions def err_expr_not_ice : Error< "expression is not an %select{integer|integral}0 constant expression">; @@ -88,10 +75,12 @@ def err_typecheck_converted_constant_expression_indirect : Error< "conversion from %0 to %1 in converted constant expression would " "bind reference to a temporary">; def err_expr_not_cce : Error< - "%select{case value|enumerator value|non-type template argument|array size}0 " + "%select{case value|enumerator value|non-type template argument|" + "array size|constexpr if condition}0 " "is not a constant expression">; def ext_cce_narrowing : ExtWarn< - "%select{case value|enumerator value|non-type template argument|array size}0 " + "%select{case value|enumerator value|non-type template argument|" + "array size|constexpr if condition}0 " "%select{cannot be narrowed from type %2 to %3|" "evaluates to %2, which cannot be narrowed to type %3}1">, InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure; @@ -124,13 +113,14 @@ def warn_float_underflow : Warning< InGroup<LiteralRange>; def warn_double_const_requires_fp64 : Warning< "double precision constant requires cl_khr_fp64, casting to single precision">; +def err_half_const_requires_fp16 : Error< + "half precision constant requires cl_khr_fp16">; // C99 variable-length arrays def ext_vla : Extension<"variable length arrays are a C99 feature">, InGroup<VLAExtension>; def warn_vla_used : Warning<"variable length array used">, InGroup<VLA>, DefaultIgnore; -def err_vla_non_pod : Error<"variable length array of non-POD element type %0">; def err_vla_in_sfinae : Error< "variable length array cannot be formed during template argument deduction">; def err_array_star_in_function_definition : Error< @@ -254,6 +244,13 @@ def err_bad_variable_name : Error< def err_bad_parameter_name : Error< "%0 cannot be the name of a parameter">; def err_parameter_name_omitted : Error<"parameter name omitted">; +def err_anyx86_interrupt_attribute : Error< + "%select{x86|x86-64}0 'interrupt' attribute only applies to functions that " + "have %select{a 'void' return type|" + "only a pointer parameter optionally followed by an integer parameter|" + "a pointer as the first parameter|a %2 type as the second parameter}1">; +def err_anyx86_interrupt_called : Error< + "interrupt service routine cannot be called directly">; def warn_mips_interrupt_attribute : Warning< "MIPS 'interrupt' attribute only applies to functions that have " "%select{no parameters|a 'void' return type}0">, @@ -342,12 +339,16 @@ def err_language_linkage_spec_not_ascii : Error< def warn_use_out_of_scope_declaration : Warning< "use of out-of-scope declaration of %0">; def err_inline_non_function : Error< - "'inline' can only appear on functions">; + "'inline' can only appear on functions%select{| and non-local variables}0">; def err_noreturn_non_function : Error< "'_Noreturn' can only appear on functions">; def warn_qual_return_type : Warning< "'%0' type qualifier%s1 on return type %plural{1:has|:have}1 no effect">, InGroup<IgnoredQualifiers>, DefaultIgnore; +def warn_deprecated_redundant_constexpr_static_def : Warning< + "out-of-line definition of constexpr static data member is redundant " + "in C++17 and is deprecated">, + InGroup<Deprecated>, DefaultIgnore; def warn_decl_shadow : Warning<"declaration shadows a %select{" @@ -356,6 +357,14 @@ def warn_decl_shadow : "static data member of %2|" "field of %2}1">, InGroup<Shadow>, DefaultIgnore; +def warn_ctor_parm_shadows_field: + Warning<"constructor parameter %0 shadows the field %1 of %2">, + InGroup<ShadowFieldInConstructor>, DefaultIgnore; +def warn_modifying_shadowing_decl : + Warning<"modifying constructor parameter %0 that shadows a " + "field of %1">, + InGroup<ShadowFieldInConstructorModified>, DefaultIgnore; + // C++ using declarations def err_using_requires_qualname : Error< @@ -372,27 +381,19 @@ def err_using_decl_nested_name_specifier_is_not_base_class : Error< "using declaration refers into '%0', which is not a base class of %1">; def err_using_decl_constructor_not_in_direct_base : Error< "%0 is not a direct base of %1, cannot inherit constructors">; -def err_using_decl_constructor_conflict : Error< - "cannot inherit constructor, already inherited constructor with " - "the same signature">; -def note_using_decl_constructor_conflict_current_ctor : Note< - "conflicting constructor">; -def note_using_decl_constructor_conflict_previous_ctor : Note< - "previous constructor">; -def note_using_decl_constructor_conflict_previous_using : Note< - "previously inherited here">; -def warn_using_decl_constructor_ellipsis : Warning< - "inheriting constructor does not inherit ellipsis">, - InGroup<DiagGroup<"inherited-variadic-ctor">>; -def note_using_decl_constructor_ellipsis : Note< - "constructor declared with ellipsis here">; def err_using_decl_can_not_refer_to_class_member : Error< "using declaration cannot refer to class member">; +def err_ambiguous_inherited_constructor : Error< + "constructor of %0 inherited from multiple base class subobjects">; +def note_ambiguous_inherited_constructor_using : Note< + "inherited from base class %0 here">; def note_using_decl_class_member_workaround : Note< - "use %select{an alias declaration|a typedef declaration|a reference}0 " - "instead">; + "use %select{an alias declaration|a typedef declaration|a reference|" + "a const variable|a constexpr variable}0 instead">; def err_using_decl_can_not_refer_to_namespace : Error< - "using declaration cannot refer to namespace">; + "using declaration cannot refer to a namespace">; +def err_using_decl_can_not_refer_to_scoped_enum : Error< + "using declaration cannot refer to a scoped enumerator">; def err_using_decl_constructor : Error< "using declaration cannot refer to a constructor">; def warn_cxx98_compat_using_decl_constructor : Warning< @@ -404,7 +405,7 @@ def err_using_decl_template_id : Error< "using declaration cannot refer to a template specialization">; def note_using_decl_target : Note<"target of using declaration">; def note_using_decl_conflict : Note<"conflicting declaration">; -def err_using_decl_redeclaration : Error<"redeclaration of using decl">; +def err_using_decl_redeclaration : Error<"redeclaration of using declaration">; def err_using_decl_conflict : Error< "target of using declaration conflicts with declaration already in scope">; def err_using_decl_conflict_reverse : Error< @@ -610,8 +611,8 @@ def err_opencl_half_declaration : Error< "declaring variable of type %0 is not allowed">; def err_opencl_half_param : Error< "declaring function parameter of type %0 is not allowed; did you forget * ?">; -def err_opencl_half_return : Error< - "declaring function return value of type %0 is not allowed; did you forget * ?">; +def err_opencl_invalid_return : Error< + "declaring function return value of type %0 is not allowed %select{; did you forget * ?|}1">; def warn_enum_value_overflow : Warning<"overflow in enumeration value">; def warn_pragma_options_align_reset_failed : Warning< "#pragma options align=reset failed: %0">, @@ -719,6 +720,12 @@ def err_objc_root_class_subclass : Error< def warn_objc_root_class_missing : Warning< "class %0 defined without specifying a base class">, InGroup<ObjCRootClass>; +def err_objc_runtime_visible_category : Error< + "cannot implement a category for class %0 that is only visible via the " + "Objective-C runtime">; +def err_objc_runtime_visible_subclass : Error< + "cannot implement subclass %0 of a superclass %1 that is only visible via the " + "Objective-C runtime">; def note_objc_needs_superclass : Note< "add a super class to fix this problem">; def warn_dup_category_def : Warning< @@ -967,6 +974,8 @@ def note_property_synthesize : Note< "property synthesized here">; def error_synthesize_category_decl : Error< "@synthesize not allowed in a category's implementation">; +def error_synthesize_on_class_property : Error< + "@synthesize not allowed on a class property %0">; def error_reference_property : Error< "property of reference type is not supported">; def error_missing_property_interface : Error< @@ -1071,6 +1080,12 @@ def warn_cxx14_compat_static_assert_no_message : Warning< "static_assert with no message is incompatible with C++ standards before C++1z">, DefaultIgnore, InGroup<CXXPre1zCompat>; +def ext_inline_variable : ExtWarn< + "inline variables are a C++1z extension">, InGroup<CXX1z>; +def warn_cxx14_compat_inline_variable : Warning< + "inline variables are incompatible with C++ standards before C++1z">, + DefaultIgnore, InGroup<CXXPre1zCompat>; + def warn_inline_namespace_reopened_noninline : Warning< "inline namespace cannot be reopened as a non-inline namespace">; def err_inline_namespace_mismatch : Error< @@ -1210,6 +1225,8 @@ def err_distant_exception_spec : Error< def err_incomplete_in_exception_spec : Error< "%select{|pointer to |reference to }0incomplete type %1 is not allowed " "in exception specification">; +def ext_incomplete_in_exception_spec : ExtWarn<err_incomplete_in_exception_spec.Text>, + InGroup<MicrosoftExceptionSpec>; def err_rref_in_exception_spec : Error< "rvalue reference type %0 is not allowed in exception specification">; def err_mismatched_exception_spec : Error< @@ -1409,11 +1426,13 @@ def note_member_synthesized_at : Note< "assignment operator|move assignment operator|destructor}0 for %1 first " "required here">; def note_inhctor_synthesized_at : Note< - "inheriting constructor for %0 first required here">; + "inherited constructor for %0 first required here">; def err_missing_default_ctor : Error< - "%select{|implicit default |inheriting }0constructor for %1 must explicitly " - "initialize the %select{base class|member}2 %3 which does not have a default " - "constructor">; + "%select{constructor for %1 must explicitly initialize the|" + "implicit default constructor for %1 must explicitly initialize the|" + "cannot use constructor inherited from base class %4;}0 " + "%select{base class|member}2 %3 %select{which|which|of %1}0 " + "does not have a default constructor">; def note_due_to_dllexported_class : Note< "due to '%0' being dllexported%select{|; try compiling in C++11 mode}1">; @@ -1663,7 +1682,7 @@ def warn_maybe_uninit_var : Warning< "variable %0 may be uninitialized when " "%select{used here|captured by block}1">, InGroup<UninitializedMaybe>, DefaultIgnore; -def note_uninit_var_def : Note<"variable %0 is declared here">; +def note_var_declared_here : Note<"variable %0 is declared here">; def note_uninit_var_use : Note< "%select{uninitialized use occurs|variable is captured by block}0 here">; def warn_uninit_byref_blockvar_captured_by_block : Warning< @@ -1905,8 +1924,12 @@ 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 err_for_range_begin_end_types_differ : Error< - "'begin' and 'end' must return the same type (got %0 and %1)">; +def ext_for_range_begin_end_types_differ : ExtWarn< + "'begin' and 'end' returning different types (%0 and %1) is a C++1z extension">, + InGroup<CXX1z>; +def warn_for_range_begin_end_types_differ : Warning< + "'begin' and 'end' returning different types (%0 and %1) is incompatible " + "with C++ standards before C++1z">, InGroup<CXXPre1zCompat>, DefaultIgnore; def note_in_for_range: Note< "when looking up '%select{begin|end}0' function for range expression " "of type %1">; @@ -1923,6 +1946,22 @@ def note_for_range_invalid_iterator : Note < "in implicit call to 'operator%select{!=|*|++}0' for iterator of type %1">; def note_for_range_begin_end : Note< "selected '%select{begin|end}0' %select{function|template }1%2 with iterator type %3">; +def warn_for_range_const_reference_copy : Warning< + "loop variable %0 " + "%diff{has type $ but is initialized with type $" + "| is initialized with a value of a different type}1,2 resulting in a copy">, + InGroup<RangeLoopAnalysis>, DefaultIgnore; +def note_use_type_or_non_reference : Note< + "use non-reference type %0 to keep the copy or type %1 to prevent copying">; +def warn_for_range_variable_always_copy : Warning< + "loop variable %0 is always a copy because the range of type %1 does not " + "return a reference">, + InGroup<RangeLoopAnalysis>, DefaultIgnore; +def note_use_non_reference_type : Note<"use non-reference type %0">; +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">; // C++11 constexpr def warn_cxx98_compat_constexpr : Warning< @@ -2067,6 +2106,16 @@ def err_concept_decl_invalid_specifiers : Error< "'%select{thread_local|inline|friend|constexpr}1'">; def err_function_concept_with_params : Error< "function concept cannot have any parameters">; +def err_function_concept_bool_ret : Error< + "declared return type of function concept must be 'bool'">; +def err_variable_concept_bool_decl : Error< + "declared type of variable concept must be 'bool'">; +def err_concept_specified_specialization : Error< + "'concept' cannot be applied on an " + "%select{explicit instantiation|explicit specialization|partial specialization}0">; +def err_concept_specialized : Error< + "%select{function|variable}0 concept cannot be " + "%select{explicitly instantiated|explicitly specialized|partially specialized}1">; // C++11 char16_t/char32_t def warn_cxx98_compat_unicode_type : Warning< @@ -2079,6 +2128,10 @@ def err_integer_sequence_negative_length : Error< def err_integer_sequence_integral_element_type : Error< "integer sequences must have integral element type">; +// __type_pack_element +def err_type_pack_element_out_of_bounds : Error< + "a parameter pack may not be accessed at an out of bounds index">; + // Objective-C++ def err_objc_decls_may_only_appear_in_global_scope : Error< "Objective-C declarations may only appear in global scope">; @@ -2101,6 +2154,10 @@ def err_attribute_too_few_arguments : Error< 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">; +def err_attribute_requires_opencl_version : Error< + "%0 attribute requires OpenCL version %1%select{| or above}2">; def warn_unsupported_target_attribute : Warning<"Ignoring unsupported '%0' in the target attribute string">, InGroup<IgnoredAttributes>; @@ -2250,6 +2307,20 @@ def warn_objc_collection_literal_element : Warning< "object of type %0 is not compatible with " "%select{array element type|dictionary key type|dictionary value type}1 %2">, InGroup<ObjCLiteralConversion>; +def err_swift_param_attr_not_swiftcall : Error< + "'%0' parameter can only be used with swiftcall calling convention">; +def err_swift_indirect_result_not_first : Error< + "'swift_indirect_result' parameters must be first parameters of function">; +def err_swift_context_not_before_swift_error_result : Error< + "'swift_context' parameter can only be followed by 'swift_error_result' " + "parameter">; +def err_swift_error_result_not_last : Error< + "'swift_error_result' parameter must be last parameter of function">; +def err_swift_error_result_not_after_swift_context : Error< + "'swift_error_result' parameter must follow 'swift_context' parameter">; +def err_swift_abi_parameter_wrong_type : Error< + "'%0' parameter must have pointer%select{| to unqualified pointer}1 type; " + "type here is %2">; def err_attribute_argument_is_zero : Error< "%0 attribute must be greater than 0">; @@ -2298,7 +2369,10 @@ def err_attribute_aligned_too_great : Error< "requested alignment must be %0 bytes or smaller">; def warn_redeclaration_without_attribute_prev_attribute_ignored : Warning< "%q0 redeclared without %1 attribute: previous %1 ignored">, - InGroup<DiagGroup<"inconsistent-dllimport">>; + InGroup<MicrosoftInconsistentDllImport>; +def warn_redeclaration_without_import_attribute : Warning< + "%q0 redeclared without 'dllimport' attribute: 'dllexport' attribute added">, + InGroup<MicrosoftInconsistentDllImport>; def warn_dllimport_dropped_from_inline_function : Warning< "%q0 redeclared inline; %1 attribute ignored">, InGroup<IgnoredAttributes>; @@ -2318,8 +2392,10 @@ def warn_cxx11_gnu_attribute_on_type : Warning< def warn_unhandled_ms_attribute_ignored : Warning< "__declspec attribute %0 is not supported">, InGroup<IgnoredAttributes>; -def err_attribute_invalid_on_stmt : Error< +def err_decl_attribute_invalid_on_stmt : Error< "%0 attribute cannot be applied to a statement">; +def err_stmt_attribute_invalid_on_decl : Error< + "%0 attribute cannot be applied to a declaration">; def warn_declspec_attribute_ignored : Warning< "attribute %0 is ignored, place it after " "\"%select{class|struct|interface|union|enum}1\" to apply attribute to " @@ -2410,31 +2486,41 @@ def err_attribute_weakref_without_alias : Error< def err_alias_not_supported_on_darwin : Error < "only weak aliases are supported on darwin">; def err_alias_to_undefined : Error< - "alias must point to a defined variable or function">; + "%select{alias|ifunc}0 must point to a defined %select{variable or |}1function">; def warn_alias_to_weak_alias : Warning< - "alias will always resolve to %0 even if weak definition of alias %1 is overridden">, + "%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< - "alias will not be in section '%0' but in the same section as the aliasee">, + "%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 as another definition">; def err_cyclic_alias : Error< - "alias definition is part of a cycle">; + "%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 : Warning< "%0 attribute only applies to %select{functions|unions|" - "variables and functions|functions and methods|parameters|" + "variables and functions|" + "functions, variables, and Objective-C interfaces|" + "functions and methods|parameters|" "functions, methods and blocks|functions, methods, and classes|" "functions, methods, and parameters|classes|enums|variables|methods|" - "variables, functions and labels|fields and global variables|structs|" - "variables and typedefs|thread-local variables|" - "variables and fields|variables, data members and tag types|" + "fields and global variables|structs|parameters and typedefs|variables and typedefs|" + "thread-local variables|variables and fields|variables, data members and tag types|" "types and namespaces|Objective-C interfaces|methods and properties|" "struct or union|struct, union or class|types|" "Objective-C instance methods|init methods of interface or class extension declarations|" - "variables, functions and classes|Objective-C protocols|" + "variables, functions and classes|" + "functions, variables, classes, and Objective-C interfaces|" + "Objective-C protocols|" "functions and global variables|structs, unions, and typedefs|structs and typedefs|" - "interface or protocol declarations|kernel functions|non-K&R-style functions}1">, + "interface or protocol declarations|kernel functions|non-K&R-style functions|" + "variables, enums, fields and typedefs|functions, methods, enums, and classes|" + "structs, classes, variables, functions, and inline namespaces|" + "variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members}1">, InGroup<IgnoredAttributes>; def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>; def warn_type_attribute_wrong_type : Warning< @@ -2444,9 +2530,6 @@ def warn_type_attribute_wrong_type : Warning< def warn_incomplete_encoded_type : Warning< "encoding of %0 type is incomplete because %1 component has unknown encoding">, InGroup<DiagGroup<"encode-type">>; -def warn_attribute_requires_functions_or_static_globals : Warning< - "%0 only applies to variables with static storage duration and functions">, - InGroup<IgnoredAttributes>; def warn_gnu_inline_attribute_requires_inline : Warning< "'gnu_inline' attribute requires function to be marked 'inline'," " attribute ignored">, @@ -2516,6 +2599,9 @@ def note_overridden_method : Note< def note_protocol_method : Note< "protocol method is here">; +def warn_available_using_star_case : Warning< + "using '*' case here, platform %0 is not accounted for">, InGroup<UnguardedAvailability>; + // Thread Safety Attributes def warn_invalid_capability_name : Warning< "invalid capability name '%0'; capability name must be 'mutex' or 'role'">, @@ -2682,9 +2768,6 @@ def warn_impcast_float_precision : Warning< def warn_impcast_double_promotion : Warning< "implicit conversion increases floating-point precision: %0 to %1">, InGroup<DoublePromotion>, DefaultIgnore; -def warn_impcast_float_integer : Warning< - "implicit conversion turns floating-point number into integer: %0 to %1">, - InGroup<FloatConversion>, DefaultIgnore; def warn_impcast_integer_sign : Warning< "implicit conversion changes signedness: %0 to %1">, InGroup<SignConversion>, DefaultIgnore; @@ -2703,9 +2786,22 @@ def warn_impcast_integer_precision_constant : Warning< def warn_impcast_bitfield_precision_constant : Warning< "implicit truncation from %2 to bitfield changes value from %0 to %1">, InGroup<BitFieldConstantConversion>; + def warn_impcast_literal_float_to_integer : Warning< "implicit conversion from %0 to %1 changes value from %2 to %3">, InGroup<LiteralConversion>; +def warn_impcast_float_integer : Warning< + "implicit conversion turns floating-point number into integer: %0 to %1">, + InGroup<FloatConversion>, DefaultIgnore; + +def warn_impcast_float_to_integer : Warning< + "implicit conversion of out of range value from %0 to %1 changes value " + "from %2 to %3">, + InGroup<FloatOverflowConversion>, DefaultIgnore; +def warn_impcast_float_to_integer_zero : Warning< + "implicit conversion from %0 to %1 changes non-zero value from %2 to %3">, + InGroup<FloatZeroConversion>, DefaultIgnore; + def warn_impcast_string_literal_to_bool : Warning< "implicit conversion turns string literal into bool: %0 to %1">, InGroup<StringConversion>, DefaultIgnore; @@ -2844,14 +2940,16 @@ def warn_vector_mode_deprecated : Warning< InGroup<DeprecatedAttributes>; def err_complex_mode_vector_type : Error< "type of machine mode does not support base vector types">; -def err_attr_wrong_decl : Error< - "%0 attribute invalid on this declaration, requires typedef or value">; +def err_enum_mode_vector_type : Error< + "mode %0 is not supported for enumeration types">; def warn_attribute_nonnull_no_pointers : Warning< "'nonnull' attribute applied to function with no pointer arguments">, InGroup<IgnoredAttributes>; def warn_attribute_nonnull_parm_no_args : Warning< "'nonnull' attribute when used on parameters takes no arguments">, InGroup<IgnoredAttributes>; +def note_declared_nonnull : Note< + "declared %select{'returns_nonnull'|'nonnull'}0 here">; def warn_attribute_sentinel_named_arguments : Warning< "'sentinel' attribute requires named arguments">, InGroup<IgnoredAttributes>; @@ -2907,6 +3005,9 @@ def warn_ns_attribute_wrong_return_type : Warning< "%0 attribute only applies to %select{functions|methods|properties}1 that " "return %select{an Objective-C object|a pointer|a non-retainable pointer}2">, InGroup<IgnoredAttributes>; +def err_ns_attribute_wrong_parameter_type : Error< + "%0 attribute only applies to " + "%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">, @@ -3013,7 +3114,9 @@ def err_uninitialized_member_for_assign : Error< "non-static %select{reference|const}1 member %2 cannot use copy " "assignment operator">; def err_uninitialized_member_in_ctor : Error< - "%select{|implicit default |inheriting }0constructor for %1 must explicitly " + "%select{constructor for %1|" + "implicit default constructor for %1|" + "cannot use constructor inherited from %1:}0 must explicitly " "initialize the %select{reference|const}2 member %3">; def err_default_arg_makes_ctor_special : Error< "addition of default argument on redeclaration makes this constructor a " @@ -3023,6 +3126,7 @@ def err_use_of_default_argument_to_function_declared_later : Error< "use of default argument to function %0 that is declared later in class %1">; def note_default_argument_declared_here : Note< "default argument declared here">; +def err_recursive_default_argument : Error<"recursive evaluation of default argument">; def ext_param_promoted_not_compatible_with_prototype : ExtWarn< "%diff{promoted type $ of K&R function parameter is not compatible with the " @@ -3061,7 +3165,8 @@ def note_ovl_candidate : Note<"candidate " "is the implicit move constructor|" "is the implicit copy assignment operator|" "is the implicit move assignment operator|" - "is an inherited constructor}0%1" + "inherited constructor|" + "inherited constructor }0%1" "%select{| has different class%diff{ (expected $ but has $)|}3,4" "| has different number of parameters (expected %3 but has %4)" "| has type mismatch at %ordinal3 parameter" @@ -3073,7 +3178,8 @@ def note_ovl_candidate : Note<"candidate " "%select{none|const|restrict|const and restrict|volatile|const and volatile" "|volatile and restrict|const, volatile, and restrict}4)}2">; -def note_ovl_candidate_inherited_constructor : Note<"inherited from here">; +def note_ovl_candidate_inherited_constructor : Note< + "constructor from base class %0 inherited here">; def note_ovl_candidate_illegal_constructor : Note< "candidate %select{constructor|template}0 ignored: " "instantiation %select{takes|would take}0 its own class type by value">; @@ -3133,7 +3239,8 @@ def note_ovl_candidate_arity : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0 %select{|template }1" + "inherited constructor|" + "inherited constructor}0 %select{|template }1" "not viable: requires%select{ at least| at most|}2 %3 argument%s3, but %4 " "%plural{1:was|:were}4 provided">; @@ -3144,7 +3251,8 @@ def note_ovl_candidate_arity_one : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0 %select{|template }1not viable: " + "inherited constructor|" + "inherited constructor}0 %select{|template }1not viable: " "%select{requires at least|allows at most single|requires single}2 " "argument %3, but %plural{0:no|:%4}4 arguments were provided">; @@ -3156,7 +3264,8 @@ def note_ovl_candidate_deleted : Note< "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 has been " + "inherited constructor|" + "inherited constructor }0%1 has been " "%select{explicitly made unavailable|explicitly deleted|" "implicitly deleted}2">; @@ -3173,9 +3282,15 @@ def note_ovl_candidate_bad_conv_incomplete : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 " + "inherited constructor|" + "inherited constructor }0%1 " "not viable: cannot convert argument of incomplete type " - "%diff{$ to $|to parameter type}2,3">; + "%diff{$ to $|to parameter type}2,3 for " + "%select{%ordinal5 argument|object argument}4" + "%select{|; dereference the argument with *|" + "; take the address of the argument with &|" + "; remove *|" + "; remove &}6">; def note_ovl_candidate_bad_list_argument : Note<"candidate " "%select{function|function|constructor|" "function |function |constructor |" @@ -3184,7 +3299,8 @@ def note_ovl_candidate_bad_list_argument : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 " + "inherited constructor|" + "inherited constructor }0%1 " "not viable: cannot convert initializer list argument to %3">; def note_ovl_candidate_bad_overload : Note<"candidate " "%select{function|function|constructor|" @@ -3194,7 +3310,8 @@ def note_ovl_candidate_bad_overload : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1" + "inherited constructor|" + "inherited constructor }0%1" " not viable: no overload of %3 matching %2 for %ordinal4 argument">; def note_ovl_candidate_bad_conv : Note<"candidate " "%select{function|function|constructor|" @@ -3204,7 +3321,8 @@ def note_ovl_candidate_bad_conv : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1" + "inherited constructor|" + "inherited constructor }0%1" " not viable: no known conversion " "%diff{from $ to $|from argument type to parameter type}2,3 for " "%select{%ordinal5 argument|object argument}4" @@ -3220,7 +3338,8 @@ def note_ovl_candidate_bad_arc_conv : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1" + "inherited constructor|" + "inherited constructor }0%1" " not viable: cannot implicitly convert argument " "%diff{of type $ to $|type to parameter type}2,3 for " "%select{%ordinal5 argument|object argument}4 under ARC">; @@ -3232,7 +3351,8 @@ def note_ovl_candidate_bad_lvalue : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1" + "inherited constructor|" + "inherited constructor }0%1" " not viable: expects an l-value for " "%select{%ordinal3 argument|object argument}2">; def note_ovl_candidate_bad_addrspace : Note<"candidate " @@ -3243,7 +3363,8 @@ def note_ovl_candidate_bad_addrspace : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 not viable: " + "inherited constructor|" + "inherited constructor }0%1 not viable: " "%select{%ordinal6|'this'}5 argument (%2) is in " "address space %3, but parameter must be in address space %4">; def note_ovl_candidate_bad_gc : Note<"candidate " @@ -3254,7 +3375,8 @@ def note_ovl_candidate_bad_gc : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 not viable: " + "inherited constructor|" + "inherited constructor }0%1 not viable: " "%select{%ordinal6|'this'}5 argument (%2) has %select{no|__weak|__strong}3 " "ownership, but parameter has %select{no|__weak|__strong}4 ownership">; def note_ovl_candidate_bad_ownership : Note<"candidate " @@ -3265,7 +3387,8 @@ def note_ovl_candidate_bad_ownership : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 not viable: " + "inherited constructor|" + "inherited constructor }0%1 not viable: " "%select{%ordinal6|'this'}5 argument (%2) has " "%select{no|__unsafe_unretained|__strong|__weak|__autoreleasing}3 ownership," " but parameter has %select{no|__unsafe_unretained|__strong|__weak|" @@ -3273,7 +3396,7 @@ def note_ovl_candidate_bad_ownership : Note<"candidate " def note_ovl_candidate_bad_cvr_this : Note<"candidate " "%select{|function|||function|||||" "function (the implicit copy assignment operator)|" - "function (the implicit move assignment operator)|}0 not viable: " + "function (the implicit move assignment operator)||}0 not viable: " "'this' argument has type %2, but method is not marked " "%select{const|restrict|const or restrict|volatile|const or volatile|" "volatile or restrict|const, volatile, or restrict}3">; @@ -3285,11 +3408,23 @@ def note_ovl_candidate_bad_cvr : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1 not viable: " + "inherited constructor|" + "inherited constructor }0%1 not viable: " "%ordinal4 argument (%2) would lose " "%select{const|restrict|const and restrict|volatile|const and volatile|" "volatile and restrict|const, volatile, and restrict}3 qualifier" "%select{||s||s|s|s}3">; +def note_ovl_candidate_bad_unaligned : Note<"candidate " + "%select{function|function|constructor|" + "function |function |constructor |" + "constructor (the implicit default constructor)|" + "constructor (the implicit copy constructor)|" + "constructor (the implicit move constructor)|" + "function (the implicit copy assignment operator)|" + "function (the implicit move assignment operator)|" + "inherited constructor|" + "inherited constructor }0%1 not viable: " + "%ordinal4 argument (%2) would lose __unaligned qualifier">; def note_ovl_candidate_bad_base_to_derived_conv : Note<"candidate " "%select{function|function|constructor|" "function |function |constructor |" @@ -3298,20 +3433,23 @@ def note_ovl_candidate_bad_base_to_derived_conv : Note<"candidate " "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0%1" - " not viable: cannot %select{convert from|convert from|bind}2 " + "inherited constructor|" + "inherited constructor }0%1 not viable: " + "cannot %select{convert from|convert from|bind}2 " "%select{base class pointer|superclass|base class object of type}2 %3 to " "%select{derived class pointer|subclass|derived class reference}2 %4 for " "%ordinal5 argument">; def note_ovl_candidate_bad_target : Note< "candidate %select{function|function|constructor|" - "function |function |constructor |" + "function|function|constructor|" "constructor (the implicit default constructor)|" "constructor (the implicit copy constructor)|" "constructor (the implicit move constructor)|" "function (the implicit copy assignment operator)|" "function (the implicit move assignment operator)|" - "constructor (inherited)}0 not viable: call to " + "inherited constructor|" + "inherited constructor}0 not viable: " + "call to " "%select{__device__|__global__|__host__|__host__ __device__|invalid}1 function from" " %select{__device__|__global__|__host__|__host__ __device__|invalid}2 function">; def note_implicit_member_target_infer_collision : Note< @@ -3515,8 +3653,8 @@ def note_template_unnamed_type_here : Note< "unnamed type used in template argument was declared here">; def err_template_arg_overload_type : Error< "template argument is the type of an unresolved overloaded function">; -def err_template_arg_not_class_template : Error< - "template argument does not refer to a class template or template " +def err_template_arg_not_valid_template : Error< + "template argument does not refer to a class or alias template, or template " "template parameter">; def note_template_arg_refers_here_func : Note< "template argument refers to function template %0, here">; @@ -3627,6 +3765,8 @@ def err_template_spec_unknown_kind : Error< "class template">; def note_specialized_entity : Note< "explicitly specialized declaration is here">; +def note_explicit_specialization_declared_here : Note< + "explicit specialization declared here">; def err_template_spec_decl_function_scope : Error< "explicit specialization of %0 in function scope">; def err_template_spec_decl_class_scope : Error< @@ -3749,6 +3889,8 @@ def err_partial_spec_ordering_ambiguous : Error< def note_partial_spec_match : Note<"partial specialization matches %0">; def err_partial_spec_redeclared : Error< "class template partial specialization %0 cannot be redeclared">; +def note_partial_specialization_declared_here : Note< + "explicit specialization declared here">; def note_prev_partial_spec_here : Note< "previous declaration of class template partial specialization %0 is here">; def err_partial_spec_fully_specialized : Error< @@ -3815,7 +3957,18 @@ def note_template_type_alias_instantiation_here : Note< "in instantiation of template type alias %0 requested here">; def note_template_exception_spec_instantiation_here : Note< "in instantiation of exception specification for %0 requested here">; - +def warn_var_template_missing : Warning<"instantiation of variable %q0 " + "required here, but no definition is available">, + InGroup<UndefinedVarTemplate>; +def warn_func_template_missing : Warning<"instantiation of function %q0 " + "required here, but no definition is available">, + InGroup<UndefinedFuncTemplate>, DefaultIgnore; +def note_forward_template_decl : Note< + "forward declaration of template entity is here">; +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_default_arg_instantiation_here : Note< "in instantiation of default argument for '%0' required here">; def note_default_function_arg_instantiation_here : Note< @@ -4108,8 +4261,6 @@ def note_implicitly_deleted : Note< "explicitly defaulted function was implicitly deleted here">; def note_inherited_deleted_here : Note< "deleted constructor was inherited here">; -def note_cannot_inherit : Note< - "constructor cannot be inherited">; def warn_not_enough_argument : Warning< "not enough variable arguments in %0 declaration to fit a sentinel">, InGroup<Sentinel>; @@ -4132,7 +4283,7 @@ def err_redefinition : Error<"redefinition of %0">; def err_alias_after_tentative : Error<"alias definition of %0 after tentative definition">; def err_alias_is_definition : - Error<"definition %0 cannot also be an alias">; + Error<"definition %0 cannot also be an %select{alias|ifunc}1">; def err_definition_of_implicitly_declared_member : Error< "definition of implicitly declared %select{default constructor|copy " "constructor|move constructor|copy assignment operator|move assignment " @@ -4144,24 +4295,36 @@ def err_definition_of_explicitly_defaulted_member : Error< def err_redefinition_extern_inline : Error< "redefinition of a 'extern inline' function %0 is not supported in " "%select{C99 mode|C++}1">; +def warn_attr_abi_tag_namespace : Warning< + "'abi_tag' attribute on %select{non-inline|anonymous}0 namespace ignored">, + InGroup<IgnoredAttributes>; +def err_abi_tag_on_redeclaration : Error< + "cannot add 'abi_tag' attribute in a redeclaration">; +def err_new_abi_tag_on_redeclaration : Error< + "'abi_tag' %0 missing in original declaration">; def note_deleted_dtor_no_operator_delete : Note< "virtual destructor requires an unambiguous, accessible 'operator delete'">; def note_deleted_special_member_class_subobject : Note< - "%select{default constructor|copy constructor|move constructor|" - "copy assignment operator|move assignment operator|destructor}0 of " + "%select{default constructor of|copy constructor of|move constructor of|" + "copy assignment operator of|move assignment operator of|destructor of|" + "constructor inherited by}0 " "%1 is implicitly deleted because " "%select{base class %3|%select{||||variant }4field %3}2 has " "%select{no|a deleted|multiple|an inaccessible|a non-trivial}4 " "%select{%select{default constructor|copy constructor|move constructor|copy " - "assignment operator|move assignment operator|destructor}0|destructor}5" + "assignment operator|move assignment operator|destructor|" + "%select{default|corresponding|default|default|default}4 constructor}0|" + "destructor}5" "%select{||s||}4">; def note_deleted_default_ctor_uninit_field : Note< - "default constructor of %0 is implicitly deleted because field %1 of " - "%select{reference|const-qualified}3 type %2 would not be initialized">; + "%select{default constructor of|constructor inherited by}0 " + "%1 is implicitly deleted because field %2 of " + "%select{reference|const-qualified}4 type %3 would not be initialized">; def note_deleted_default_ctor_all_const : Note< - "default constructor of %0 is implicitly deleted because all " - "%select{data members|data members of an anonymous union member}1" + "%select{default constructor of|constructor inherited by}0 " + "%1 is implicitly deleted because all " + "%select{data members|data members of an anonymous union member}2" " are const-qualified">; def note_deleted_copy_ctor_rvalue_reference : Note< "copy constructor of %0 is implicitly deleted because field %1 is of " @@ -4179,6 +4342,7 @@ def warn_undefined_internal : Warning< InGroup<DiagGroup<"undefined-internal">>; def warn_undefined_inline : Warning<"inline function %q0 is not defined">, InGroup<DiagGroup<"undefined-inline">>; +def err_undefined_inline_var : Error<"inline variable %q0 is not defined">; def note_used_here : Note<"used here">; def err_internal_linkage_redeclaration : Error< @@ -4254,7 +4418,7 @@ def err_redefinition_different_typedef : Error< "%select{typedef|type alias|type alias template}0 " "redefinition with different types%diff{ ($ vs $)|}1,2">; def err_tag_reference_non_tag : Error< - "elaborated type refers to %select{a non-tag type|a typedef|a type alias|a template|a type alias template}0">; + "elaborated type refers to %select{a non-tag type|a typedef|a type alias|a template|a type alias template|a template template argument}0">; def err_tag_reference_conflict : Error< "implicit declaration introduced by elaborated type conflicts with " "%select{a declaration|a typedef|a type alias|a template}0 of the same name">; @@ -4517,6 +4681,8 @@ def note_protected_by_vla_typedef : Note< "jump bypasses initialization of VLA typedef">; def note_protected_by_vla_type_alias : Note< "jump bypasses initialization of VLA type alias">; +def note_protected_by_constexpr_if : Note< + "jump enters controlled statement of constexpr if">; def note_protected_by_vla : Note< "jump bypasses initialization of variable length array">; def note_protected_by_objc_try : Note< @@ -5171,8 +5337,6 @@ def err_typecheck_pointer_arith_void_type : Error< "arithmetic on%select{ a|}0 pointer%select{|s}0 to void">; def err_typecheck_decl_incomplete_type : Error< "variable has incomplete type %0">; -def err_typecheck_decl_incomplete_type___float128 : Error< - "support for type '__float128' is not yet implemented">; def ext_typecheck_decl_incomplete_type : ExtWarn< "tentative definition of variable with internal linkage has incomplete non-array type %0">, InGroup<DiagGroup<"tentative-definition-incomplete-type">>; @@ -5257,7 +5421,11 @@ def ext_typecheck_indirection_through_void_pointer : ExtWarn< "ISO C++ does not allow indirection on operand of type %0">, InGroup<DiagGroup<"void-ptr-dereference">>; def warn_indirection_through_null : Warning< - "indirection of non-volatile null pointer will be deleted, not trap">, InGroup<NullDereference>; + "indirection of non-volatile null pointer will be deleted, not trap">, + InGroup<NullDereference>; +def warn_binding_null_to_reference : Warning< + "binding dereferenced null pointer to reference has undefined behavior">, + InGroup<NullDereference>; def note_indirection_through_null : Note< "consider using __builtin_trap() or qualifying pointer with 'volatile'">; def warn_pointer_indirection_from_incompatible_type : Warning< @@ -5301,7 +5469,9 @@ def ext_typecheck_comparison_of_distinct_pointers_nonstandard : ExtWarn< "composite pointer type %2">, InGroup<CompareDistinctPointerType>; def err_typecheck_op_on_nonoverlapping_address_space_pointers : Error< "%select{comparison between %diff{ ($ and $)|}0,1" - "|arithmetic operation with operands of type %diff{ ($ and $)|}0,1}2" + "|arithmetic operation with operands of type %diff{ ($ and $)|}0,1" + "|conditional operator with the second and third operands of type " + "%diff{ ($ and $)|}0,1}2" " which are pointers to non-overlapping address spaces">; def err_typecheck_assign_const : Error< @@ -5572,6 +5742,16 @@ def note_parameter_here : Note< def note_method_return_type_change : Note< "compiler has implicitly changed method %0 return type">; +def warn_impl_required_for_class_property : Warning< + "class property %0 requires method %1 to be defined - " + "use @dynamic or provide a method implementation " + "in this class implementation">, + InGroup<ObjCPropertyImpl>; +def warn_impl_required_in_category_for_class_property : Warning< + "class property %0 requires method %1 to be defined - " + "use @dynamic or provide a method implementation in this category">, + InGroup<ObjCPropertyImpl>; + // C++ casts // These messages adhere to the TryCast pattern: %0 is an int specifying the // cast type, %1 is the source type, %2 is the destination type. @@ -5771,6 +5951,8 @@ def err_catch_incomplete_ref : Error< "cannot catch reference to incomplete type %0">; def err_catch_incomplete : Error<"cannot catch incomplete type %0">; def err_catch_rvalue_ref : Error<"cannot catch exceptions by rvalue reference">; +def err_catch_variably_modified : Error< + "cannot catch variably modified type %0">; def err_qualified_catch_declarator : Error< "exception declarator cannot be qualified">; def err_early_catch_all : Error<"catch-all handler must come last">; @@ -5802,12 +5984,14 @@ def warn_non_virtual_dtor : Warning< "%0 has virtual functions but non-virtual destructor">, InGroup<NonVirtualDtor>, DefaultIgnore; def warn_delete_non_virtual_dtor : Warning< - "delete called on non-final %0 that has virtual functions " - "but non-virtual destructor">, + "%select{delete|destructor}0 called on non-final %1 that has " + "virtual functions but non-virtual destructor">, InGroup<DeleteNonVirtualDtor>, DefaultIgnore; +def note_delete_non_virtual : Note< + "qualify call to silence this warning">; def warn_delete_abstract_non_virtual_dtor : Warning< - "delete called on %0 that is abstract but has non-virtual destructor">, - InGroup<DeleteNonVirtualDtor>; + "%select{delete|destructor}0 called on %1 that is abstract but has " + "non-virtual destructor">, InGroup<DeleteNonVirtualDtor>; def warn_overloaded_virtual : Warning< "%q0 hides overloaded virtual %select{function|functions}1">, InGroup<OverloadedVirtual>, DefaultIgnore; @@ -5927,6 +6111,13 @@ let CategoryName = "Lambda Issue" in { "cannot deduce type for lambda capture %0 from initializer of type %2">; def err_init_capture_deduction_failure_from_init_list : Error< "cannot deduce type for lambda capture %0 from initializer list">; + + // C++1z '*this' captures. + def warn_cxx14_compat_star_this_lambda_capture : Warning< + "by value capture of '*this' is incompatible with C++ standards before C++1z">, + InGroup<CXXPre1zCompat>, DefaultIgnore; + def ext_star_this_lambda_capture_cxx1z : ExtWarn< + "capture of '*this' by copy is a C++1z extension">, InGroup<CXX1z>; } def err_return_in_captured_stmt : Error< @@ -6392,9 +6583,13 @@ def err_nontemporal_builtin_must_be_pointer_intfltptr_or_vector : Error< "pointer, or a vector of such types (%0 invalid)">; def err_deleted_function_use : Error<"attempt to use a deleted function">; +def err_deleted_inherited_ctor_use : Error< + "constructor inherited by %0 from base class %1 is implicitly deleted">; def err_kern_type_not_void_return : Error< "kernel function type %0 must have void return type">; +def err_kern_is_nonstatic_method : Error< + "kernel function %0 must be a free function or static member function">; def err_config_scalar_return : Error< "CUDA special function 'cudaConfigureCall' must have scalar return type">; def err_kern_call_not_global_function : Error< @@ -6404,10 +6599,31 @@ def err_global_call_not_config : Error< def err_ref_bad_target : Error< "reference to %select{__device__|__global__|__host__|__host__ __device__}0 " "function %1 in %select{__device__|__global__|__host__|__host__ __device__}2 function">; -def warn_host_calls_from_host_device : Warning< - "calling __host__ function %0 from __host__ __device__ function %1 can lead to runtime errors">, +def warn_kern_is_method : Extension< + "kernel function %0 is a member function; this may not be accepted by nvcc">, InGroup<CudaCompat>; - +def warn_kern_is_inline : Warning< + "ignored 'inline' attribute on kernel function %0">, + InGroup<CudaCompat>; +def err_variadic_device_fn : Error< + "CUDA device code does not support variadic functions">; +def err_va_arg_in_device : Error< + "CUDA device code does not support va_arg">; +def err_alias_not_supported_on_nvptx : Error<"CUDA does not support aliases">; +def err_cuda_unattributed_constexpr_cannot_overload_device : Error< + "constexpr function '%0' without __host__ or __device__ attributes cannot " + "overload __device__ function with same signature. Add a __host__ " + "attribute, or build with -fno-cuda-host-device-constexpr.">; +def note_cuda_conflicting_device_function_declared_here : Note< + "conflicting __device__ function declared here">; +def err_dynamic_var_init : Error< + "dynamic initialization is not supported for " + "__device__, __constant__, and __shared__ variables.">; +def err_shared_var_init : Error< + "initialization is not supported for __shared__ variables.">; +def err_device_static_local_var : Error< + "Within a __device__/__global__ function, " + "only __shared__ variables may be marked \"static\"">; def warn_non_pod_vararg_with_format_string : Warning< "cannot pass %select{non-POD|non-trivial}0 object of type %1 to variadic " "%select{function|block|method|constructor}2; expected type from format " @@ -6473,7 +6689,13 @@ def warn_cast_pointer_from_sel : Warning< def warn_function_def_in_objc_container : Warning< "function definition inside an Objective-C container is deprecated">, InGroup<FunctionDefInObjCContainer>; - + +def warn_cast_calling_conv : Warning< + "cast between incompatible calling conventions '%0' and '%1'; " + "calls through this pointer may abort at runtime">, + InGroup<DiagGroup<"cast-calling-convention">>; +def note_change_calling_conv_fixit : Note< + "consider defining %0 with the '%1' calling convention">; def warn_bad_function_cast : Warning< "cast from function call of type %0 to non-matching type %1">, InGroup<BadFunctionCast>, DefaultIgnore; @@ -6518,12 +6740,17 @@ def warn_side_effects_typeid : Warning< "expression with side effects will be evaluated despite being used as an " "operand to 'typeid'">, InGroup<PotentiallyEvaluatedExpression>; def warn_unused_result : Warning< - "ignoring return value of function declared with warn_unused_result " - "attribute">, InGroup<DiagGroup<"unused-result">>; + "ignoring return value of function declared with %0 attribute">, + InGroup<DiagGroup<"unused-result">>; def warn_unused_volatile : Warning< "expression result unused; assign into a variable to force a volatile load">, InGroup<DiagGroup<"unused-volatile-lvalue">>; +def ext_cxx14_attr : Extension< + "use of the %0 attribute is a C++14 extension">, InGroup<CXX14>; +def ext_cxx1z_attr : Extension< + "use of the %0 attribute is a C++1z extension">, InGroup<CXX1z>; + def warn_unused_comparison : Warning< "%select{%select{|in}1equality|relational}0 comparison result unused">, InGroup<UnusedComparison>; @@ -6849,9 +7076,16 @@ def err_literal_operator_id_outside_namespace : Error< "non-namespace scope '%0' cannot have a literal operator member">; def err_literal_operator_default_argument : Error< "literal operator cannot have a default argument">; -// FIXME: This diagnostic sucks -def err_literal_operator_params : Error< - "parameter declaration for literal operator %0 is not valid">; +def err_literal_operator_bad_param_count : Error< + "non-template literal operator must have one or two parameters">; +def err_literal_operator_invalid_param : Error< + "parameter of literal operator must have type 'unsigned long long', 'long double', 'char', 'wchar_t', 'char16_t', 'char32_t', or 'const char *'">; +def err_literal_operator_param : Error< + "invalid literal operator parameter type %0, did you mean %1?">; +def err_literal_operator_template_with_params : Error< + "literal operator template cannot have any parameters">; +def err_literal_operator_template : Error< + "template parameter list for literal operator must be either 'char...' or 'typename T, T...'">; def err_literal_operator_extern_c : Error< "literal operator must have C++ linkage">; def ext_string_literal_operator_template : ExtWarn< @@ -7061,6 +7295,8 @@ def warn_scanf_scanlist_incomplete : Warning< def note_format_string_defined : Note<"format string is defined here">; def note_format_fix_specifier : Note<"did you mean to use '%0'?">; def note_printf_c_str: Note<"did you mean to call the %0 method?">; +def note_format_security_fixit: Note< + "treat the string as an argument to avoid this">; def warn_null_arg : Warning< "null passed to a callee that requires a non-null argument">, @@ -7159,7 +7395,7 @@ def err_generic_sel_multi_match : Error< // Blocks def err_blocks_disable : Error<"blocks support disabled - compile with -fblocks" - " or pick a deployment target that supports them">; + " or %select{pick a deployment target that supports them|for OpenCL 2.0 or above}0">; def err_block_returning_array_function : Error< "block cannot return %select{array|function}0 type %1">; @@ -7228,16 +7464,15 @@ def note_insert_fallthrough_fixit : Note< def note_insert_break_fixit : Note< "insert 'break;' to avoid fall-through">; def err_fallthrough_attr_wrong_target : Error< - "clang::fallthrough attribute is only allowed on empty statements">; + "%0 attribute is only allowed on empty statements">; def note_fallthrough_insert_semi_fixit : Note<"did you forget ';'?">; def err_fallthrough_attr_outside_switch : Error< "fallthrough annotation is outside switch statement">; -def warn_fallthrough_attr_invalid_placement : Warning< - "fallthrough annotation does not directly precede switch label">, - InGroup<ImplicitFallthrough>; +def err_fallthrough_attr_invalid_placement : Error< + "fallthrough annotation does not directly precede switch label">; def warn_fallthrough_attr_unreachable : Warning< "fallthrough annotation in unreachable code">, - InGroup<ImplicitFallthrough>; + InGroup<ImplicitFallthrough>, DefaultIgnore; def warn_unreachable_default : Warning< "default label in switch which covers all enumeration values">, @@ -7281,10 +7516,13 @@ def err_va_start_used_in_wrong_abi_function : Error< "'va_start' used in %select{System V|Win64}0 ABI function">; def err_ms_va_start_used_in_sysv_function : Error< "'__builtin_ms_va_start' used in System V ABI function">; -def warn_second_parameter_of_va_start_not_last_named_argument : Warning< - "second parameter of 'va_start' not last named argument">, InGroup<Varargs>; -def warn_va_start_of_reference_type_is_undefined : Warning< - "'va_start' has undefined behavior with reference types">, InGroup<Varargs>; +def warn_second_arg_of_va_start_not_last_named_param : Warning< + "second argument to 'va_start' is not the last named parameter">, + InGroup<Varargs>; +def warn_va_start_type_is_undefined : Warning< + "passing %select{an object that undergoes default argument promotion|" + "an object of reference type|a parameter declared with the 'register' " + "keyword}0 to 'va_start' has undefined behavior">, InGroup<Varargs>; def err_first_argument_to_va_arg_not_of_type_va_list : Error< "first argument to 'va_arg' is of type %0 and not 'va_list'">; def err_second_parameter_to_va_arg_incomplete: Error< @@ -7471,8 +7709,8 @@ def err_c99_array_usage_cxx : Error< "feature, not permitted in C++">; def err_type_requires_extension : Error< "use of type %0 requires %1 extension to be enabled">; -def err_int128_unsupported : Error< - "__int128 is not supported on this target">; +def err_type_unsupported : Error< + "%0 is not supported on this target">; def err_nsconsumed_attribute_mismatch : Error< "overriding method has mismatched ns_consumed attribute on its" " parameter">; @@ -7541,6 +7779,8 @@ def err_typecheck_member_reference_ivar_suggest : Error< "%0 does not have a member named %1; did you mean %2?">; def err_property_not_found_suggest : Error< "property %0 not found on object of type %1; did you mean %2?">; +def err_class_property_found : Error< + "property %0 is a class property; did you mean to access it with class '%1'?">; def err_ivar_access_using_property_syntax_suggest : Error< "property %0 not found on object of type %1; did you mean to access instance variable %2?">; def warn_property_access_suggest : Warning< @@ -7600,9 +7840,6 @@ def err_asm_naked_this_ref : Error< def err_asm_naked_parm_ref : Error< "parameter references not allowed in naked functions">; -def ext_deprecated_attr_is_a_cxx14_extension : ExtWarn< - "use of the 'deprecated' attribute is a C++14 extension">, InGroup<CXX14>; - // OpenCL warnings and errors. def err_invalid_astype_of_different_size : Error< "invalid reinterpretation: sizes of %0 and %1 must match">; @@ -7612,8 +7849,8 @@ def err_opencl_ptrptr_kernel_param : Error< "kernel parameter cannot be declared as a pointer to a pointer">; def err_opencl_private_ptr_kernel_param : Error< "kernel parameter cannot be declared as a pointer to the __private address space">; -def err_opencl_non_kernel_variable : Error< - "non-kernel function variable cannot be declared in %0 address space">; +def err_opencl_function_variable : Error< + "%select{non-kernel function|function scope}0 variable cannot be declared in %1 address space">; def err_static_function_scope : Error< "variables in function scope cannot be declared static">; def err_opencl_bitfields : Error< @@ -7630,8 +7867,8 @@ def note_illegal_field_declared_here : Note< "field of illegal %select{type|pointer type}0 %1 declared here">; def err_event_t_global_var : Error< "the event_t type cannot be used to declare a program scope variable">; -def err_event_t_struct_field : Error< - "the event_t type cannot be used to declare a structure or union field">; +def err_opencl_type_struct_or_union_field : Error< + "the %0 type cannot be used to declare a structure or union field">; def err_event_t_addr_space_qual : Error< "the event_t type can only be used with __private address space qualifier">; def err_expected_kernel_void_return_type : Error< @@ -7640,8 +7877,10 @@ def err_sampler_argument_required : Error< "sampler_t variable required - got %0">; def err_wrong_sampler_addressspace: Error< "sampler type cannot be used with the __local and __global address space qualifiers">; +def error_opencl_cast_non_zero_to_event_t : Error< + "cannot cast non-zero value '%0' to 'event_t'">; def err_opencl_global_invalid_addr_space : Error< - "program scope variable must reside in %0 address space">; + "%select{program scope|static local|extern}0 variable must reside in %1 address space">; def err_missing_actual_pipe_type : Error< "missing actual type specifier for pipe">; def err_reference_pipe_type : Error < @@ -7658,11 +7897,71 @@ def err_atomic_init_constant : Error< " in the declaration statement in the program scope">; def err_opencl_implicit_vector_conversion : Error< "implicit conversions between vector types (%0 and %1) are not permitted">; +def err_opencl_block_proto_variadic : Error< + "invalid block prototype, variadic arguments are not allowed in OpenCL">; +def err_opencl_invalid_type_array : Error< + "array of %0 type is invalid in OpenCL">; +def err_opencl_ternary_with_block : Error< + "block type cannot be used as expression in ternary expression in OpenCL">; +def err_opencl_pointer_to_type : Error< + "pointer to type %0 is invalid in OpenCL">; +def err_opencl_type_can_only_be_used_as_function_parameter : Error < + "type %0 can only be used as a function parameter in OpenCL">; +def warn_opencl_attr_deprecated_ignored : Warning < + "%0 attribute is deprecated and ignored in OpenCL version %1">, + InGroup<IgnoredAttributes>; + +// OpenCL v2.0 s6.13.6 -- Builtin Pipe Functions +def err_opencl_builtin_pipe_first_arg : Error< + "first argument to %0 must be a pipe type">; +def err_opencl_builtin_pipe_arg_num : Error< + "invalid number of arguments to function: %0">; +def err_opencl_builtin_pipe_invalid_arg : Error< + "invalid argument type to function %0 (expecting %1 having %2)">; +def err_opencl_builtin_pipe_invalid_access_modifier : Error< + "invalid pipe access modifier (expecting %0)">; + +// OpenCL access qualifier +def err_opencl_invalid_access_qualifier : Error< + "access qualifier can only be used for pipe and image type">; +def err_opencl_invalid_read_write : Error< + "access qualifier %0 can not be used for %1 %select{|prior to OpenCL version 2.0}2">; +def err_opencl_multiple_access_qualifiers : Error< + "multiple access qualifiers">; +def note_opencl_typedef_access_qualifier : Note< + "previously declared '%0' here">; // OpenCL Section 6.8.g def err_opencl_unknown_type_specifier : Error< - "OpenCL does not support the '%0' %select{type qualifier|storage class specifier}1">; + "OpenCL version %0 does not support the '%1' %select{type qualifier|storage class specifier}2">; + +// OpenCL v2.0 s6.12.5 Blocks restrictions +def err_opencl_block_storage_type : Error< + "the __block storage type is not permitted">; +def err_opencl_invalid_block_declaration : Error< + "invalid block variable declaration - must be %select{const qualified|initialized}0">; +def err_opencl_extern_block_declaration : Error< + "invalid block variable declaration - using 'extern' storage class is disallowed">; + +// OpenCL v2.0 s6.13.9 - Address space qualifier functions. +def err_opencl_builtin_to_addr_arg_num : Error< + "invalid number of arguments to function: %0">; +def err_opencl_builtin_to_addr_invalid_arg : Error< + "invalid argument %0 to function: %1, expecting a generic pointer argument">; +// OpenCL v2.0 s6.13.17 Enqueue kernel restrictions. +def err_opencl_enqueue_kernel_incorrect_args : Error< + "illegal call to enqueue_kernel, incorrect argument types">; +def err_opencl_enqueue_kernel_expected_type : Error< + "illegal call to enqueue_kernel, expected %0 argument type">; +def err_opencl_enqueue_kernel_local_size_args : Error< + "mismatch in number of block parameters and local size arguments passed">; +def err_opencl_enqueue_kernel_invalid_local_size_type : Error< + "local memory sizes need to be specified as uint">; +def err_opencl_enqueue_kernel_blocks_non_local_void_args : Error< + "blocks used in device side enqueue are expected to have parameters of type 'local void*'">; +def err_opencl_enqueue_kernel_blocks_no_args : Error< + "blocks in this form of device side enqueue call are expected to have have no parameters">; } // end of sema category let CategoryName = "OpenMP Issue" in { @@ -7676,6 +7975,8 @@ def err_omp_global_var_arg : Error< "arguments of '#pragma omp %0' must have %select{global storage|static storage duration}1">; def err_omp_ref_type_arg : Error< "arguments of '#pragma omp %0' cannot be of reference type %1">; +def err_omp_region_not_file_context : Error< + "directive must be at file or namespace scope">; def err_omp_var_scope : Error< "'#pragma omp %0' must appear in the scope of the %q1 variable declaration">; def err_omp_var_used : Error< @@ -7692,10 +7993,28 @@ def err_omp_reduction_incomplete_type : Error< "a reduction list item with incomplete type %0">; def err_omp_unexpected_clause_value : Error< "expected %0 in OpenMP clause '%1'">; -def err_omp_expected_var_name : Error< - "expected variable name">; -def err_omp_expected_var_name_or_array_item : Error< - "expected variable name, array element or array section">; +def err_omp_expected_var_name_member_expr : Error< + "expected variable name%select{| or data member of current class}0">; +def err_omp_expected_var_name_member_expr_or_array_item : Error< + "expected variable name%select{|, data member of current class}0, array element or array section">; +def err_omp_expected_named_var_member_or_array_expression: Error< + "expected expression containing only member accesses and/or array sections based on named variables">; +def err_omp_bit_fields_forbidden_in_clause : Error< + "bit fields cannot be used to specify storage in a '%0' clause">; +def err_array_section_does_not_specify_contiguous_storage : Error< + "array section does not specify contiguous storage">; +def err_omp_union_type_not_allowed : Error< + "mapped storage cannot be derived from a union">; +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_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< + "original storage of expression in data environment is shared but data environment do not fully contain mapped expression storage">; +def err_omp_same_pointer_derreferenced : Error< + "same pointer derreferenced in multiple different ways in map clause expressions">; def note_omp_task_predetermined_firstprivate_here : Note< "predetermined as a firstprivate in a task construct here">; def err_omp_threadprivate_incomplete_type : Error< @@ -7733,6 +8052,8 @@ def err_omp_negative_expression_in_clause : Error< def err_omp_not_integral : Error< "expression must have integral or unscoped enumeration " "type, not %0">; +def err_omp_threadprivate_in_target : Error< + "threadprivate variables cannot be used in target constructs">; def err_omp_incomplete_type : Error< "expression has incomplete class type %0">; def err_omp_explicit_conversion : Error< @@ -7759,12 +8080,23 @@ 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< + "%0 appears multiple times in clauses on the same declare target directive">; +def err_omp_declare_target_to_and_link : Error< + "%0 must not appear in both clauses 'to' and 'link'">; +def warn_omp_not_in_target_context : Warning< + "declaration is not declared in any declare target region">, + InGroup<OpenMPTarget>; def err_omp_aligned_expected_array_or_ptr : Error< "argument of aligned clause should be array" "%select{ or pointer|, pointer, reference to array or reference to pointer}1" ", not %0">; def err_omp_aligned_twice : Error< - "a variable cannot appear in more than one aligned clause">; + "%select{a variable|a parameter|'this'}0 cannot appear in more than one aligned clause">; def err_omp_local_var_in_threadprivate_init : Error< "variable with local storage in initial value of threadprivate variable">; def err_omp_loop_not_canonical_init : Error< @@ -7797,9 +8129,10 @@ def warn_omp_loop_64_bit_var : Warning< "OpenMP loop iteration variable cannot have more than 64 bits size and will be narrowed">, InGroup<OpenMPLoopForm>; def err_omp_unknown_reduction_identifier : Error< - "incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'">; -def err_omp_reduction_type_array : Error< - "a reduction list item with array type %0">; + "incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', " + "'&&', '||', 'min' or 'max' or declare reduction for type %0">; +def err_omp_not_resolved_reduction_identifier : Error< + "unable to resolve declare reduction construct for type %0">; def err_omp_reduction_ref_type_arg : Error< "argument of OpenMP clause 'reduction' must reference the same object in all threads">; def err_omp_clause_not_arithmetic_type_arg : Error< @@ -7808,6 +8141,8 @@ def err_omp_clause_floating_type_arg : Error< "arguments of OpenMP clause 'reduction' with bitwise operators cannot be of floating type">; def err_omp_once_referenced : Error< "variable can appear only once in OpenMP '%0' clause">; +def err_omp_once_referenced_in_target_update : Error< + "variable can appear only once in OpenMP 'target update' construct">; def note_omp_referenced : Note< "previously referenced here">; def err_omp_reduction_in_task : Error< @@ -7883,12 +8218,19 @@ def err_omp_single_copyprivate_with_nowait : Error< "the 'copyprivate' clause must not be used with the 'nowait' clause">; def note_omp_nowait_clause_here : Note< "'nowait' clause is here">; +def err_omp_single_decl_in_declare_simd : Error< + "single declaration is expected after 'declare simd' directive">; +def err_omp_function_expected : Error< + "'#pragma omp declare simd' can only be applied to functions">; def err_omp_wrong_cancel_region : Error< "one of 'for', 'parallel', 'sections' or 'taskgroup' is expected">; def err_omp_parent_cancel_region_nowait : Error< "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be nowait">; def err_omp_parent_cancel_region_ordered : Error< "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be ordered">; +def err_omp_reduction_wrong_type : Error<"reduction type cannot be %select{qualified with 'const', 'volatile' or 'restrict'|a function|a reference|an array}0 type">; +def err_omp_wrong_var_in_declare_reduction : Error<"only %select{'omp_priv' or 'omp_orig'|'omp_in' or 'omp_out'}0 variables are allowed in %select{initializer|combiner}0 expression">; +def err_omp_declare_reduction_redefinition : Error<"redefinition of user-defined reduction for type %0">; def err_omp_array_section_use : Error<"OpenMP array section is not allowed here">; def err_omp_typecheck_section_value : Error< "subscripted value is not an array or pointer">; @@ -7930,12 +8272,16 @@ def err_omp_map_shared_storage : Error< "variable already marked as mapped in current construct">; def err_omp_not_mappable_type : Error< "type %0 is not mappable to target">; +def err_omp_invalid_map_type_for_directive : Error< + "%select{map type '%1' is not allowed|map type must be specified}0 for '#pragma omp %2'">; +def err_omp_no_map_for_directive : Error< + "expected at least one map clause for '#pragma omp %0'">; def note_omp_polymorphic_in_target : Note< "mappable type cannot be polymorphic">; def note_omp_static_member_in_target : Note< "mappable type cannot contain static members">; -def err_omp_threadprivate_in_map : Error< - "threadprivate variables are not allowed in map clause">; +def err_omp_threadprivate_in_clause : Error< + "threadprivate variables are not allowed in '%0' clause">; def err_omp_wrong_ordered_loop_count : Error< "the parameter of the 'ordered' clause must be greater than or equal to the parameter of the 'collapse' clause">; def note_collapse_loop_count : Note< @@ -7960,8 +8306,6 @@ def err_omp_firstprivate_distribute_in_teams_reduction : Error< "reduction variable in '#pragma omp teams' cannot be firstprivate in '#pragma omp distribute'">; def err_omp_depend_clause_thread_simd : Error< "'depend' clauses cannot be mixed with '%0' clause">; -def err_omp_depend_sink_wrong_expr : Error< - "expected expression form x[+-d], where x is the loop iteration variable and d is a constant non-negative integer">; def err_omp_depend_sink_expected_loop_iteration : Error< "expected %0 loop iteration variable">; def err_omp_depend_sink_unexpected_expr : Error< @@ -7980,6 +8324,23 @@ def err_omp_schedule_nonmonotonic_ordered : Error< "'schedule' clause with 'nonmonotonic' modifier cannot be specified if an 'ordered' clause is specified">; def err_omp_ordered_simd : Error< "'ordered' clause with a parameter can not be specified in '#pragma omp %0' directive">; +def err_omp_variable_in_map_and_dsa : Error< + "%0 variable cannot be in a map clause in '#pragma omp %1' directive">; +def err_omp_param_or_this_in_clause : Error< + "expected reference to one of the parameters of function %0%select{| or 'this'}1">; +def err_omp_expected_uniform_param : Error< + "expected a reference to a parameter specified in a 'uniform' clause">; +def err_omp_expected_int_param : Error< + "expected a reference to an integer-typed parameter">; +def err_omp_at_least_one_motion_clause_required : Error< + "expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'">; +def err_omp_usedeviceptr_not_a_pointer : Error< + "expected pointer or reference to pointer in 'use_device_ptr' clause">; +def err_omp_argument_type_isdeviceptr : Error < + "expected pointer, array, reference to pointer, or reference to array in 'is_device_ptr clause'">; +def warn_omp_nesting_simd : Warning< + "OpenMP only allows an ordered construct with the simd clause nested in a simd construct">, + InGroup<SourceUsesOpenMP>; } // end of OpenMP category let CategoryName = "Related Result Type Issue" in { @@ -8018,10 +8379,17 @@ def err_module_private_local_class : Error< "local %select{struct|interface|union|class|enum}0 cannot be declared " "__module_private__">; def err_module_unimported_use : Error< - "%select{declaration|definition|default argument}0 of %1 must be imported " + "%select{declaration|definition|default argument|" + "explicit specialization|partial specialization}0 of %1 must be imported " + "from module '%2' before it is required">; +def err_module_unimported_use_header : Error< + "missing '#include %3'; " + "%select{declaration|definition|default argument|" + "explicit specialization|partial specialization}0 of %1 must be imported " "from module '%2' before it is required">; def err_module_unimported_use_multiple : Error< - "%select{declaration|definition|default argument}0 of %1 must be imported " + "%select{declaration|definition|default argument|" + "explicit specialization|partial specialization}0 of %1 must be imported " "from one of the following modules before it is required:%2">; def ext_module_import_in_extern_c : ExtWarn< "import of C++ module '%0' appears within extern \"C\" language linkage " @@ -8221,4 +8589,12 @@ def warn_objc_redundant_qualified_class_type : Warning< "parameterized class %0 already conforms to the protocols listed; did you " "forget a '*'?">, InGroup<ObjCProtocolQualifiers>; +def warn_block_literal_attributes_on_omitted_return_type : Warning< + "attribute %0 ignored, because it cannot be applied to omitted return type">, + InGroup<IgnoredAttributes>; + +def warn_block_literal_qualifiers_on_omitted_return_type : Warning< + "'%0' qualifier on omitted return type %1 has no effect">, + InGroup<IgnoredQualifiers>; + } // end of sema component. diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index 17758ec3f398..b6a9ca702842 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -52,6 +52,7 @@ public: /// descriptor for the file. class FileEntry { const char *Name; // Name of the file. + std::string RealPathName; // Real path to the file; could be empty. off_t Size; // File size in bytes. time_t ModTime; // Modification time of file. const DirectoryEntry *Dir; // Directory file lives in. @@ -82,6 +83,7 @@ public: } const char *getName() const { return Name; } + StringRef tryGetRealPathName() const { return RealPathName; } bool isValid() const { return IsValid; } off_t getSize() const { return Size; } unsigned getUID() const { return UID; } diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h index d672314f56e2..fffb50493bfe 100644 --- a/include/clang/Basic/IdentifierTable.h +++ b/include/clang/Basic/IdentifierTable.h @@ -62,6 +62,9 @@ class IdentifierInfo { // 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 @@ -69,7 +72,7 @@ class IdentifierInfo { // stored externally. bool IsModulesImport : 1; // True if this is the 'import' contextual // keyword. - // 30 bit left in 64-bit word. + // 29 bit left in 64-bit word. void *FETokenInfo; // Managed by the language front-end. llvm::StringMapEntry<IdentifierInfo*> *Entry; @@ -303,6 +306,18 @@ public: ChangedAfterLoad = true; } + /// \brief Determine whether the frontend token information for this + /// identifier has changed since it was loaded from an AST file. + bool hasFETokenInfoChangedSinceDeserialization() const { + return FEChangedAfterLoad; + } + + /// \brief Note that the frontend token information for this identifier has + /// changed since it was loaded from an AST file. + void setFETokenInfoChangedSinceDeserialization() { + FEChangedAfterLoad = true; + } + /// \brief Determine whether the information for this identifier is out of /// date with respect to the external source. bool isOutOfDate() const { return OutOfDate; } diff --git a/include/clang/Basic/Lambda.h b/include/clang/Basic/Lambda.h index e676e726dd7a..1c19f1dcc8b1 100644 --- a/include/clang/Basic/Lambda.h +++ b/include/clang/Basic/Lambda.h @@ -32,7 +32,8 @@ enum LambdaCaptureDefault { /// by reference. C++1y also allows "init-capture", where the initializer /// is an expression. enum LambdaCaptureKind { - LCK_This, ///< Capturing the \c this pointer + LCK_This, ///< Capturing the \c *this object by reference + LCK_StarThis, /// < Capturing the \c *this object by copy LCK_ByCopy, ///< Capturing by copy (a.k.a., by value) LCK_ByRef, ///< Capturing by reference LCK_VLAType ///< Capturing variable-length array type diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index cc70d6246c03..03561961dd21 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -24,11 +24,15 @@ // // VALUE_LANGOPT: for options that describe a value rather than a flag. // -// BENIGN_ENUM_LANGOPT, COMPATIBLE_ENUM_LANGOPT: combinations of the above. +// BENIGN_ENUM_LANGOPT, COMPATIBLE_ENUM_LANGOPT, +// BENIGN_VALUE_LANGOPT, COMPATIBLE_VALUE_LANGOPT: combinations of the above. // // FIXME: Clients should be able to more easily select whether they want // different levels of compatibility versus how to handle different kinds // of option. +// +// The Description field should be a noun phrase, for instance "frobbing all +// widgets" or "C's implicit blintz feature". //===----------------------------------------------------------------------===// #ifndef LANGOPT @@ -65,6 +69,16 @@ LANGOPT(Name, Bits, Default, Description) #endif +#ifndef COMPATIBLE_VALUE_LANGOPT +# define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \ + VALUE_LANGOPT(Name, Bits, Default, Description) +#endif + +#ifndef BENIGN_VALUE_LANGOPT +# define BENIGN_VALUE_LANGOPT(Name, Bits, Default, Description) \ + COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) +#endif + // FIXME: A lot of the BENIGN_ options should be COMPATIBLE_ instead. LANGOPT(C99 , 1, 0, "C99") LANGOPT(C11 , 1, 0, "C11") @@ -110,6 +124,7 @@ LANGOPT(Exceptions , 1, 0, "exception handling") LANGOPT(ObjCExceptions , 1, 0, "Objective-C exceptions") LANGOPT(CXXExceptions , 1, 0, "C++ exceptions") LANGOPT(SjLjExceptions , 1, 0, "setjmp-longjump exception handling") +LANGOPT(ExternCNoUnwind , 1, 0, "Assume extern C functions don't unwind") LANGOPT(TraditionalCPP , 1, 0, "traditional CPP emulation") LANGOPT(RTTI , 1, 1, "run-time type information") LANGOPT(RTTIData , 1, 1, "emit run-time type information data") @@ -123,31 +138,33 @@ LANGOPT(Coroutines , 1, 0, "C++ coroutines") BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers") LANGOPT(POSIXThreads , 1, 0, "POSIX thread support") LANGOPT(Blocks , 1, 0, "blocks extension to C") -BENIGN_LANGOPT(EmitAllDecls , 1, 0, "support for emitting all declarations") -LANGOPT(MathErrno , 1, 1, "errno support for math functions") -BENIGN_LANGOPT(HeinousExtensions , 1, 0, "Extensions that we really don't like and may be ripped out at any time") +BENIGN_LANGOPT(EmitAllDecls , 1, 0, "emitting all declarations") +LANGOPT(MathErrno , 1, 1, "errno in math functions") +BENIGN_LANGOPT(HeinousExtensions , 1, 0, "extensions that we really don't like and may be ripped out at any time") LANGOPT(Modules , 1, 0, "modules extension to C") +BENIGN_LANGOPT(CompilingModule, 1, 0, "compiling a module interface") COMPATIBLE_LANGOPT(ModulesDeclUse , 1, 0, "require declaration of module uses") -LANGOPT(ModulesSearchAll , 1, 1, "search even non-imported modules to find unresolved references") -COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "require declaration of module uses and all headers to be in modules") -BENIGN_LANGOPT(ModulesErrorRecovery, 1, 1, "automatically import modules as needed when performing error recovery") -BENIGN_LANGOPT(ImplicitModules, 1, 1, "build modules that are not specified via -fmodule-file") +BENIGN_LANGOPT(ModulesSearchAll , 1, 1, "searching even non-imported modules to find unresolved references") +COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "requiring declaration of module uses and all headers to be in modules") +BENIGN_LANGOPT(ModulesErrorRecovery, 1, 1, "automatically importing modules as needed when performing error recovery") +BENIGN_LANGOPT(ImplicitModules, 1, 1, "building modules that are not specified via -fmodule-file") COMPATIBLE_LANGOPT(ModulesLocalVisibility, 1, 0, "local submodule visibility") COMPATIBLE_LANGOPT(Optimize , 1, 0, "__OPTIMIZE__ predefined macro") COMPATIBLE_LANGOPT(OptimizeSize , 1, 0, "__OPTIMIZE_SIZE__ predefined macro") -LANGOPT(Static , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)") +COMPATIBLE_LANGOPT(Static , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)") VALUE_LANGOPT(PackStruct , 32, 0, "default struct packing maximum alignment") VALUE_LANGOPT(MaxTypeAlign , 32, 0, "default maximum alignment for types") -VALUE_LANGOPT(PICLevel , 2, 0, "__PIC__ level") -VALUE_LANGOPT(PIELevel , 2, 0, "__PIE__ level") -LANGOPT(GNUInline , 1, 0, "GNU inline semantics") +VALUE_LANGOPT(AlignDouble , 1, 0, "Controls if doubles should be aligned to 8 bytes (x86 only)") +COMPATIBLE_VALUE_LANGOPT(PICLevel , 2, 0, "__PIC__ level") +COMPATIBLE_VALUE_LANGOPT(PIE , 1, 0, "is pie") +COMPATIBLE_LANGOPT(GNUInline , 1, 0, "GNU inline semantics") COMPATIBLE_LANGOPT(NoInlineDefine , 1, 0, "__NO_INLINE__ predefined macro") COMPATIBLE_LANGOPT(Deprecated , 1, 0, "__DEPRECATED predefined macro") -LANGOPT(FastMath , 1, 0, "__FAST_MATH__ predefined macro") -LANGOPT(FiniteMathOnly , 1, 0, "__FINITE_MATH_ONLY__ predefined macro") -LANGOPT(UnsafeFPMath , 1, 0, "Unsafe Floating Point Math") +COMPATIBLE_LANGOPT(FastMath , 1, 0, "fast FP math optimizations, and __FAST_MATH__ predefined macro") +COMPATIBLE_LANGOPT(FiniteMathOnly , 1, 0, "__FINITE_MATH_ONLY__ predefined macro") +COMPATIBLE_LANGOPT(UnsafeFPMath , 1, 0, "Unsafe Floating Point Math") BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars") @@ -155,24 +172,27 @@ BENIGN_LANGOPT(AccessControl , 1, 1, "C++ access control") LANGOPT(CharIsSigned , 1, 1, "signed char") LANGOPT(ShortWChar , 1, 0, "unsigned short wchar_t") ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method") +ENUM_LANGOPT(DefaultCallingConv, DefaultCallingConvention, 3, DCC_None, "default calling convention") LANGOPT(ShortEnums , 1, 0, "short enum types") LANGOPT(OpenCL , 1, 0, "OpenCL") LANGOPT(OpenCLVersion , 32, 0, "OpenCL version") LANGOPT(NativeHalfType , 1, 0, "Native half type support") +LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns") LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns") LANGOPT(CUDA , 1, 0, "CUDA") -LANGOPT(OpenMP , 1, 0, "OpenMP support") +LANGOPT(OpenMP , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)") LANGOPT(OpenMPUseTLS , 1, 0, "Use TLS for threadprivates or runtime calls") LANGOPT(OpenMPIsDevice , 1, 0, "Generate code only for OpenMP target device") +LANGOPT(RenderScript , 1, 0, "RenderScript") -LANGOPT(CUDAIsDevice , 1, 0, "Compiling for CUDA device") -LANGOPT(CUDAAllowHostCallsFromHostDevice, 1, 0, "Allow host device functions to call host functions") -LANGOPT(CUDADisableTargetCallChecks, 1, 0, "Disable checks for call targets (host, device, etc.)") -LANGOPT(CUDATargetOverloads, 1, 0, "Enable function overloads based on CUDA target attributes") +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(CUDADeviceFlushDenormalsToZero, 1, 0, "flushing denormals to zero") +LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions") -LANGOPT(AssumeSaneOperatorNew , 1, 1, "implicit __attribute__((malloc)) for C++'s new operators") LANGOPT(SizedDeallocation , 1, 0, "enable sized deallocation functions") LANGOPT(ConceptsTS , 1, 0, "enable C++ Extensions for Concepts") BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision") @@ -198,8 +218,7 @@ LANGOPT(ObjCWeak , 1, 0, "Objective-C __weak in ARC and MRC files") LANGOPT(ObjCSubscriptingLegacyRuntime , 1, 0, "Subscripting support in legacy ObjectiveC runtime") LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map") ENUM_LANGOPT(AddressSpaceMapMangling , AddrSpaceMapMangling, 2, ASMM_Target, "OpenCL address space map mangling mode") - -LANGOPT(MRTD , 1, 0, "-mrtd calling convention") +LANGOPT(IncludeDefaultHeader, 1, 0, "Include default header file for OpenCL") BENIGN_LANGOPT(DelayedTemplateParsing , 1, 0, "delayed template parsing") LANGOPT(BlocksRuntimeOptional , 1, 0, "optional blocks runtime") @@ -243,4 +262,6 @@ LANGOPT(SanitizeAddressFieldPadding, 2, 0, "controls how aggressive is ASan " #undef COMPATIBLE_ENUM_LANGOPT #undef BENIGN_ENUM_LANGOPT #undef VALUE_LANGOPT +#undef COMPATIBLE_VALUE_LANGOPT +#undef BENIGN_VALUE_LANGOPT diff --git a/include/clang/Basic/LangOptions.h b/include/clang/Basic/LangOptions.h index 736d4e0930b1..6ec499f1c74a 100644 --- a/include/clang/Basic/LangOptions.h +++ b/include/clang/Basic/LangOptions.h @@ -65,6 +65,14 @@ public: PPTMK_FullGeneralityVirtualInheritance }; + enum DefaultCallingConvention { + DCC_None, + DCC_CDecl, + DCC_FastCall, + DCC_StdCall, + DCC_VectorCall + }; + enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off }; enum MSVCMajorVersion { @@ -92,14 +100,12 @@ public: /// If none is specified, abort (GCC-compatible behaviour). std::string OverflowHandler; - /// \brief The name of the current module. + /// \brief The name of the current module, of which the main source file + /// is a part. If CompilingModule is set, we are compiling the interface + /// of this module, otherwise we are compiling an implementation file of + /// it. std::string CurrentModule; - /// \brief The name of the module that the translation unit is an - /// implementation of. Prevents semantic imports, but does not otherwise - /// treat this as the CurrentModule. - std::string ImplementationOfModule; - /// \brief The names of any features to enable in module 'requires' decls /// in addition to the hard-coded list in Module.cpp and the target features. /// @@ -162,18 +168,6 @@ public: fp_contract(LangOpts.DefaultFPContract) {} }; -/// \brief OpenCL volatile options -class OpenCLOptions { -public: -#define OPENCLEXT(nm) unsigned nm : 1; -#include "clang/Basic/OpenCLExtensions.def" - - OpenCLOptions() { -#define OPENCLEXT(nm) nm = 0; -#include "clang/Basic/OpenCLExtensions.def" - } -}; - /// \brief Describes the kind of translation unit being processed. enum TranslationUnitKind { /// \brief The translation unit is a complete translation unit. diff --git a/include/clang/Basic/Makefile b/include/clang/Basic/Makefile deleted file mode 100644 index 5579a9990051..000000000000 --- a/include/clang/Basic/Makefile +++ /dev/null @@ -1,70 +0,0 @@ -CLANG_LEVEL := ../../.. -BUILT_SOURCES = \ - DiagnosticAnalysisKinds.inc DiagnosticASTKinds.inc \ - DiagnosticCommentKinds.inc \ - DiagnosticCommonKinds.inc DiagnosticDriverKinds.inc \ - DiagnosticFrontendKinds.inc DiagnosticLexKinds.inc \ - DiagnosticParseKinds.inc DiagnosticSemaKinds.inc \ - DiagnosticSerializationKinds.inc \ - AttrHasAttributeImpl.inc \ - DiagnosticIndexName.inc DiagnosticGroups.inc AttrList.inc arm_neon.inc \ - Version.inc - -TABLEGEN_INC_FILES_COMMON = 1 - -include $(CLANG_LEVEL)/Makefile - -INPUT_TDS = $(wildcard $(PROJ_SRC_DIR)/Diagnostic*.td) - -# Compute the Clang version from the LLVM version, unless specified explicitly. -ifndef CLANG_VERSION -CLANG_VERSION := $(subst svn,,$(LLVMVersion)) -CLANG_VERSION := $(subst rc,,$(CLANG_VERSION)) -endif - -CLANG_VERSION_COMPONENTS := $(subst ., ,$(CLANG_VERSION)) -CLANG_VERSION_MAJOR := $(word 1,$(CLANG_VERSION_COMPONENTS)) -CLANG_VERSION_MINOR := $(word 2,$(CLANG_VERSION_COMPONENTS)) -CLANG_VERSION_PATCHLEVEL := $(word 3,$(CLANG_VERSION_COMPONENTS)) -ifeq ($(CLANG_VERSION_PATCHLEVEL),) -CLANG_HAS_VERSION_PATCHLEVEL := 0 -else -CLANG_HAS_VERSION_PATCHLEVEL := 1 -endif - -$(ObjDir)/Diagnostic%Kinds.inc.tmp : Diagnostic.td $(INPUT_TDS) $(CLANG_TBLGEN) $(ObjDir)/.dir - $(Echo) "Building Clang $(patsubst Diagnostic%Kinds.inc.tmp,%,$(@F)) diagnostic tables with tblgen" - $(Verb) $(ClangTableGen) -gen-clang-diags-defs -clang-component=$(patsubst Diagnostic%Kinds.inc.tmp,%,$(@F)) -o $(call SYSPATH, $@) $< - -$(ObjDir)/DiagnosticIndexName.inc.tmp : Diagnostic.td $(INPUT_TDS) $(CLANG_TBLGEN) $(ObjDir)/.dir - $(Echo) "Building Clang diagnostic name index with tblgen" - $(Verb) $(ClangTableGen) -gen-clang-diags-index-name -o $(call SYSPATH, $@) $< - -$(ObjDir)/DiagnosticGroups.inc.tmp : Diagnostic.td DiagnosticGroups.td $(INPUT_TDS) $(CLANG_TBLGEN) $(ObjDir)/.dir - $(Echo) "Building Clang diagnostic groups with tblgen" - $(Verb) $(ClangTableGen) -gen-clang-diag-groups -o $(call SYSPATH, $@) $< - -$(ObjDir)/AttrList.inc.tmp : Attr.td $(CLANG_TBLGEN) $(ObjDir)/.dir - $(Echo) "Building Clang attribute list with tblgen" - $(Verb) $(ClangTableGen) -gen-clang-attr-list -o $(call SYSPATH, $@) \ - -I $(PROJ_SRC_DIR)/../.. $< - -$(ObjDir)/AttrHasAttributeImpl.inc.tmp : Attr.td $(CLANG_TBLGEN) \ - $(ObjDir)/.dir - $(Echo) "Building Clang __has_attribute implementation with tblgen" - $(Verb) $(ClangTableGen) -gen-clang-attr-has-attribute-impl -o $(call SYSPATH, $@) \ - -I $(PROJ_SRC_DIR)/../../ $< - -$(ObjDir)/arm_neon.inc.tmp : arm_neon.td $(CLANG_TBLGEN) $(ObjDir)/.dir - $(Echo) "Building Clang arm_neon.inc with tblgen" - $(Verb) $(ClangTableGen) -gen-arm-neon-sema -o $(call SYSPATH, $@) \ - -I $(PROJ_SRC_DIR)/../.. $< - -$(ObjDir)/Version.inc.tmp : Version.inc.in Makefile $(LLVM_OBJ_ROOT)/Makefile.config $(ObjDir)/.dir - $(Echo) "Updating Clang version info." - $(Verb)sed -e "s#@CLANG_VERSION@#$(CLANG_VERSION)#g" \ - -e "s#@CLANG_VERSION_MAJOR@#$(CLANG_VERSION_MAJOR)#g" \ - -e "s#@CLANG_VERSION_MINOR@#$(CLANG_VERSION_MINOR)#g" \ - -e "s#@CLANG_VERSION_PATCHLEVEL@#$(CLANG_VERSION_PATCHLEVEL)#g" \ - -e "s#@CLANG_HAS_VERSION_PATCHLEVEL@#$(CLANG_HAS_VERSION_PATCHLEVEL)#g" \ - $< > $@ diff --git a/include/clang/Basic/ObjCRuntime.h b/include/clang/Basic/ObjCRuntime.h index cf51b146b1dc..6975b6c9bb9e 100644 --- a/include/clang/Basic/ObjCRuntime.h +++ b/include/clang/Basic/ObjCRuntime.h @@ -308,6 +308,23 @@ public: } } + /// Is objc_unsafeClaimAutoreleasedReturnValue available? + bool hasARCUnsafeClaimAutoreleasedReturnValue() const { + switch (getKind()) { + case MacOSX: + return getVersion() >= VersionTuple(10, 11); + case iOS: + return getVersion() >= VersionTuple(9); + case WatchOS: + return getVersion() >= VersionTuple(2); + case GNUstep: + return false; + + default: + return false; + } + } + /// \brief Try to parse an Objective-C runtime specification from the given /// string. /// diff --git a/include/clang/Basic/OpenCLExtensions.def b/include/clang/Basic/OpenCLExtensions.def index 91fd9195b190..c5776d3bab43 100644 --- a/include/clang/Basic/OpenCLExtensions.def +++ b/include/clang/Basic/OpenCLExtensions.def @@ -11,25 +11,71 @@ // //===----------------------------------------------------------------------===// +// Macro OPENCLEXT or OPENCLEXT_INTERNAL can be defined to enumerate the +// OpenCL extensions listed in this file. +// +// If the extensions are to be enumerated without the supported OpenCL version, +// define OPENCLEXT(ext) where ext is the name of the extension. +// +// If the extensions are to be enumerated with supported OpenCL version, +// define OPENCLEXT_INTERNAL(ext, avail, core) where +// ext - name of the extension or optional core feature. +// avail - minimum OpenCL version supporting it. +// core - minimum OpenCL version when the extension becomes optional core +// feature or core feature. ~0U indicates not a core feature or an +// optional core feature. + +#ifndef OPENCLEXT_INTERNAL +#ifndef OPENCLEXT +#pragma error "macro OPENCLEXT or OPENCLEXT_INTERNAL is required" +#else +#define OPENCLEXT_INTERNAL(ext, ...) OPENCLEXT(ext) +#endif // OPENCLEXT +#endif // OPENCLEXT_INTERNAL + +// OpenCL 1.0. +OPENCLEXT_INTERNAL(cl_khr_3d_image_writes, 100, 200) +// fprounding mode is special since it is not mentioned beyond 1.0 +OPENCLEXT_INTERNAL(cl_khr_select_fprounding_mode, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_byte_addressable_store, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_fp16, 100, ~0U) +OPENCLEXT_INTERNAL(cl_khr_fp64, 100, 120) +OPENCLEXT_INTERNAL(cl_khr_global_int32_base_atomics, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_global_int32_extended_atomics, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_local_int32_base_atomics, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_local_int32_extended_atomics, 100, 110) +OPENCLEXT_INTERNAL(cl_khr_int64_base_atomics, 100, ~0U) +OPENCLEXT_INTERNAL(cl_khr_int64_extended_atomics, 100, ~0U) +OPENCLEXT_INTERNAL(cl_khr_gl_sharing, 100, ~0U) +OPENCLEXT_INTERNAL(cl_khr_icd, 100, ~0U) + // OpenCL 1.1. -OPENCLEXT(cl_khr_fp64) -OPENCLEXT(cl_khr_int64_base_atomics) -OPENCLEXT(cl_khr_int64_extended_atomics) -OPENCLEXT(cl_khr_fp16) -OPENCLEXT(cl_khr_gl_sharing) -OPENCLEXT(cl_khr_gl_event) -OPENCLEXT(cl_khr_d3d10_sharing) -OPENCLEXT(cl_khr_global_int32_base_atomics) -OPENCLEXT(cl_khr_global_int32_extended_atomics) -OPENCLEXT(cl_khr_local_int32_base_atomics) -OPENCLEXT(cl_khr_local_int32_extended_atomics) -OPENCLEXT(cl_khr_byte_addressable_store) -OPENCLEXT(cl_khr_3d_image_writes) +OPENCLEXT_INTERNAL(cl_khr_gl_event, 110, ~0U) +OPENCLEXT_INTERNAL(cl_khr_d3d10_sharing, 110, ~0U) + +// OpenCL 1.2. +OPENCLEXT_INTERNAL(cl_khr_context_abort, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_d3d11_sharing, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_depth_images, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_dx9_media_sharing, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_image2d_from_buffer, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_initialize_memory, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_gl_depth_images, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_gl_msaa_sharing, 120, ~0U) +OPENCLEXT_INTERNAL(cl_khr_spir, 120, ~0U) -// OpenCL 2.0 -OPENCLEXT(cl_khr_gl_msaa_sharing) +// OpenCL 2.0. +OPENCLEXT_INTERNAL(cl_khr_egl_event, 200, ~0U) +OPENCLEXT_INTERNAL(cl_khr_egl_image, 200, ~0U) +OPENCLEXT_INTERNAL(cl_khr_srgb_image_writes, 200, ~0U) +OPENCLEXT_INTERNAL(cl_khr_subgroups, 200, ~0U) +OPENCLEXT_INTERNAL(cl_khr_terminate_context, 200, ~0U) // Clang Extensions. -OPENCLEXT(cl_clang_storage_class_specifiers) +OPENCLEXT_INTERNAL(cl_clang_storage_class_specifiers, 100, ~0U) + +#undef OPENCLEXT_INTERNAL +#ifdef OPENCLEXT #undef OPENCLEXT +#endif diff --git a/include/clang/Basic/OpenCLImageTypes.def b/include/clang/Basic/OpenCLImageTypes.def new file mode 100644 index 000000000000..9b929929e2ba --- /dev/null +++ b/include/clang/Basic/OpenCLImageTypes.def @@ -0,0 +1,82 @@ +//===-- OpenCLImageTypes.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 image singleton types. +// Custom code should define one of those two macros: +// GENERIC_IMAGE_TYPE(Type, Id) - a generic image with its Id without an +// access type +// IMAGE_TYPE(Type, Id, SingletonId, AccessType, CGSuffix) - an image type +// with given ID, singleton ID access type and a codegen suffix + +#ifdef GENERIC_IMAGE_TYPE + +#define IMAGE_READ_TYPE(Type, Id) GENERIC_IMAGE_TYPE(Type, Id) +#define IMAGE_WRITE_TYPE(Type, Id) +#define IMAGE_READ_WRITE_TYPE(Type, Id) + +#else + +#ifndef IMAGE_READ_TYPE +#define IMAGE_READ_TYPE(Type, Id) \ + IMAGE_TYPE(Type, Id##RO, Id##ROTy, read_only, ro) +#endif +#ifndef IMAGE_WRITE_TYPE +#define IMAGE_WRITE_TYPE(Type, Id) \ + IMAGE_TYPE(Type, Id##WO, Id##WOTy, write_only, wo) +#endif +#ifndef IMAGE_READ_WRITE_TYPE +#define IMAGE_READ_WRITE_TYPE(Type, Id) \ + IMAGE_TYPE(Type, Id##RW, Id##RWTy, read_write, rw) +#endif + +#endif + +IMAGE_READ_TYPE(image1d, OCLImage1d) +IMAGE_READ_TYPE(image1d_array, OCLImage1dArray) +IMAGE_READ_TYPE(image1d_buffer, OCLImage1dBuffer) +IMAGE_READ_TYPE(image2d, OCLImage2d) +IMAGE_READ_TYPE(image2d_array, OCLImage2dArray) +IMAGE_READ_TYPE(image2d_depth, OCLImage2dDepth) +IMAGE_READ_TYPE(image2d_array_depth, OCLImage2dArrayDepth) +IMAGE_READ_TYPE(image2d_msaa, OCLImage2dMSAA) +IMAGE_READ_TYPE(image2d_array_msaa, OCLImage2dArrayMSAA) +IMAGE_READ_TYPE(image2d_msaa_depth, OCLImage2dMSAADepth) +IMAGE_READ_TYPE(image2d_array_msaa_depth, OCLImage2dArrayMSAADepth) +IMAGE_READ_TYPE(image3d, OCLImage3d) + +IMAGE_WRITE_TYPE(image1d, OCLImage1d) +IMAGE_WRITE_TYPE(image1d_array, OCLImage1dArray) +IMAGE_WRITE_TYPE(image1d_buffer, OCLImage1dBuffer) +IMAGE_WRITE_TYPE(image2d, OCLImage2d) +IMAGE_WRITE_TYPE(image2d_array, OCLImage2dArray) +IMAGE_WRITE_TYPE(image2d_depth, OCLImage2dDepth) +IMAGE_WRITE_TYPE(image2d_array_depth, OCLImage2dArrayDepth) +IMAGE_WRITE_TYPE(image2d_msaa, OCLImage2dMSAA) +IMAGE_WRITE_TYPE(image2d_array_msaa, OCLImage2dArrayMSAA) +IMAGE_WRITE_TYPE(image2d_msaa_depth, OCLImage2dMSAADepth) +IMAGE_WRITE_TYPE(image2d_array_msaa_depth, OCLImage2dArrayMSAADepth) +IMAGE_WRITE_TYPE(image3d, OCLImage3d) + +IMAGE_READ_WRITE_TYPE(image1d, OCLImage1d) +IMAGE_READ_WRITE_TYPE(image1d_array, OCLImage1dArray) +IMAGE_READ_WRITE_TYPE(image1d_buffer, OCLImage1dBuffer) +IMAGE_READ_WRITE_TYPE(image2d, OCLImage2d) +IMAGE_READ_WRITE_TYPE(image2d_array, OCLImage2dArray) +IMAGE_READ_WRITE_TYPE(image2d_depth, OCLImage2dDepth) +IMAGE_READ_WRITE_TYPE(image2d_array_depth, OCLImage2dArrayDepth) +IMAGE_READ_WRITE_TYPE(image2d_msaa, OCLImage2dMSAA) +IMAGE_READ_WRITE_TYPE(image2d_array_msaa, OCLImage2dArrayMSAA) +IMAGE_READ_WRITE_TYPE(image2d_msaa_depth, OCLImage2dMSAADepth) +IMAGE_READ_WRITE_TYPE(image2d_array_msaa_depth, OCLImage2dArrayMSAADepth) +IMAGE_READ_WRITE_TYPE(image3d, OCLImage3d) + +#undef IMAGE_TYPE +#undef GENERIC_IMAGE_TYPE +#undef IMAGE_READ_TYPE +#undef IMAGE_WRITE_TYPE +#undef IMAGE_READ_WRITE_TYPE
\ No newline at end of file diff --git a/include/clang/Basic/OpenCLOptions.h b/include/clang/Basic/OpenCLOptions.h new file mode 100644 index 000000000000..4aaa3d74ccbf --- /dev/null +++ b/include/clang/Basic/OpenCLOptions.h @@ -0,0 +1,68 @@ +//===--- OpenCLOptions.h ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Defines the clang::OpenCLOptions class. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_OPENCLOPTIONS_H +#define LLVM_CLANG_BASIC_OPENCLOPTIONS_H + +#include <string> +#include <vector> + +namespace clang { + +/// \brief OpenCL supported extensions and optional core features +class OpenCLOptions { +public: +#define OPENCLEXT(nm) unsigned nm : 1; +#include "clang/Basic/OpenCLExtensions.def" + + OpenCLOptions() { +#define OPENCLEXT(nm) nm = 0; +#include "clang/Basic/OpenCLExtensions.def" + } + + // Enable all options. + void setAll() { +#define OPENCLEXT(nm) nm = 1; +#include "clang/Basic/OpenCLExtensions.def" + } + + // Is supported with OpenCL version \p OCLVer. +#define OPENCLEXT_INTERNAL(Ext, Avail, ...) \ + bool is_##Ext##_supported(unsigned OCLVer) const { \ + return Ext && OCLVer >= Avail; \ + } +#include "clang/Basic/OpenCLExtensions.def" + + + // Is supported OpenCL extension with OpenCL version \p OCLVer. + // For supported optional core feature, return false. +#define OPENCLEXT_INTERNAL(Ext, Avail, Core) \ + bool is_##Ext##_supported_extension(unsigned CLVer) const { \ + return is_##Ext##_supported(CLVer) && (Core == ~0U || CLVer < Core); \ + } +#include "clang/Basic/OpenCLExtensions.def" + + // Is supported OpenCL core features with OpenCL version \p OCLVer. + // For supported extension, return false. +#define OPENCLEXT_INTERNAL(Ext, Avail, Core) \ + bool is_##Ext##_supported_core(unsigned CLVer) const { \ + return is_##Ext##_supported(CLVer) && Core != ~0U && CLVer >= Core; \ + } +#include "clang/Basic/OpenCLExtensions.def" + +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def index 44f77ad32fd4..5189779809b8 100644 --- a/include/clang/Basic/OpenMPKinds.def +++ b/include/clang/Basic/OpenMPKinds.def @@ -60,6 +60,21 @@ #ifndef OPENMP_TARGET_DATA_CLAUSE # define OPENMP_TARGET_DATA_CLAUSE(Name) #endif +#ifndef OPENMP_TARGET_ENTER_DATA_CLAUSE +#define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) +#endif +#ifndef OPENMP_TARGET_EXIT_DATA_CLAUSE +#define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) +#endif +#ifndef OPENMP_TARGET_PARALLEL_CLAUSE +# define OPENMP_TARGET_PARALLEL_CLAUSE(Name) +#endif +#ifndef OPENMP_TARGET_PARALLEL_FOR_CLAUSE +# define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) +#endif +#ifndef OPENMP_TARGET_UPDATE_CLAUSE +# define OPENMP_TARGET_UPDATE_CLAUSE(Name) +#endif #ifndef OPENMP_TEAMS_CLAUSE # define OPENMP_TEAMS_CLAUSE(Name) #endif @@ -102,6 +117,27 @@ #ifndef OPENMP_MAP_KIND #define OPENMP_MAP_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_DEFAULTMAP_MODIFIER +#define OPENMP_DEFAULTMAP_MODIFIER(Name) +#endif +#ifndef OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE +#define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) +#endif +#ifndef OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE +#define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) +#endif +#ifndef OPENMP_DISTRIBUTE_SIMD_CLAUSE +#define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) +#endif +#ifndef OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE +#define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) +#endif // OpenMP directives. OPENMP_DIRECTIVE(threadprivate) @@ -125,14 +161,27 @@ OPENMP_DIRECTIVE(target) OPENMP_DIRECTIVE(teams) OPENMP_DIRECTIVE(cancel) 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") +OPENMP_DIRECTIVE_EXT(target_parallel, "target parallel") +OPENMP_DIRECTIVE_EXT(target_parallel_for, "target parallel for") +OPENMP_DIRECTIVE_EXT(target_update, "target update") OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for") OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd") OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections") OPENMP_DIRECTIVE_EXT(for_simd, "for simd") OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point") +OPENMP_DIRECTIVE_EXT(declare_reduction, "declare reduction") +OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd") OPENMP_DIRECTIVE(taskloop) OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd") OPENMP_DIRECTIVE(distribute) +OPENMP_DIRECTIVE_EXT(declare_target, "declare target") +OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target") +OPENMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for") +OPENMP_DIRECTIVE_EXT(distribute_parallel_for_simd, "distribute parallel for simd") +OPENMP_DIRECTIVE_EXT(distribute_simd, "distribute simd") +OPENMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd") // OpenMP clauses. OPENMP_CLAUSE(if, OMPIfClause) @@ -175,6 +224,12 @@ OPENMP_CLAUSE(grainsize, OMPGrainsizeClause) OPENMP_CLAUSE(nogroup, OMPNogroupClause) OPENMP_CLAUSE(num_tasks, OMPNumTasksClause) OPENMP_CLAUSE(hint, OMPHintClause) +OPENMP_CLAUSE(dist_schedule, OMPDistScheduleClause) +OPENMP_CLAUSE(defaultmap, OMPDefaultmapClause) +OPENMP_CLAUSE(to, OMPToClause) +OPENMP_CLAUSE(from, OMPFromClause) +OPENMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause) +OPENMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause) // Clauses allowed for OpenMP directive 'parallel'. OPENMP_PARALLEL_CLAUSE(if) @@ -259,6 +314,12 @@ OPENMP_SCHEDULE_MODIFIER(monotonic) OPENMP_SCHEDULE_MODIFIER(nonmonotonic) OPENMP_SCHEDULE_MODIFIER(simd) +// Static attributes for 'defaultmap' clause. +OPENMP_DEFAULTMAP_KIND(scalar) + +// Modifiers for 'defaultmap' clause. +OPENMP_DEFAULTMAP_MODIFIER(tofrom) + // Static attributes for 'depend' clause. OPENMP_DEPEND_KIND(in) OPENMP_DEPEND_KIND(out) @@ -338,16 +399,82 @@ OPENMP_ATOMIC_CLAUSE(capture) OPENMP_ATOMIC_CLAUSE(seq_cst) // Clauses allowed for OpenMP directive 'target'. -// TODO More clauses for 'target' directive. OPENMP_TARGET_CLAUSE(if) OPENMP_TARGET_CLAUSE(device) OPENMP_TARGET_CLAUSE(map) +OPENMP_TARGET_CLAUSE(private) +OPENMP_TARGET_CLAUSE(nowait) +OPENMP_TARGET_CLAUSE(depend) +OPENMP_TARGET_CLAUSE(defaultmap) +OPENMP_TARGET_CLAUSE(firstprivate) +OPENMP_TARGET_CLAUSE(is_device_ptr) // Clauses allowed for OpenMP directive 'target data'. // TODO More clauses for 'target data' directive. OPENMP_TARGET_DATA_CLAUSE(if) OPENMP_TARGET_DATA_CLAUSE(device) OPENMP_TARGET_DATA_CLAUSE(map) +OPENMP_TARGET_DATA_CLAUSE(use_device_ptr) + +// Clauses allowed for OpenMP directive 'target enter data'. +OPENMP_TARGET_ENTER_DATA_CLAUSE(if) +OPENMP_TARGET_ENTER_DATA_CLAUSE(device) +OPENMP_TARGET_ENTER_DATA_CLAUSE(map) +OPENMP_TARGET_ENTER_DATA_CLAUSE(nowait) +OPENMP_TARGET_ENTER_DATA_CLAUSE(depend) + +// Clauses allowed for OpenMP directive 'target exit data'. +OPENMP_TARGET_EXIT_DATA_CLAUSE(if) +OPENMP_TARGET_EXIT_DATA_CLAUSE(device) +OPENMP_TARGET_EXIT_DATA_CLAUSE(map) +OPENMP_TARGET_EXIT_DATA_CLAUSE(nowait) +OPENMP_TARGET_EXIT_DATA_CLAUSE(depend) + +// Clauses allowed for OpenMP directive 'target parallel'. +// TODO: add target clauses 'is_device_ptr' +OPENMP_TARGET_PARALLEL_CLAUSE(if) +OPENMP_TARGET_PARALLEL_CLAUSE(device) +OPENMP_TARGET_PARALLEL_CLAUSE(map) +OPENMP_TARGET_PARALLEL_CLAUSE(private) +OPENMP_TARGET_PARALLEL_CLAUSE(firstprivate) +OPENMP_TARGET_PARALLEL_CLAUSE(nowait) +OPENMP_TARGET_PARALLEL_CLAUSE(depend) +OPENMP_TARGET_PARALLEL_CLAUSE(defaultmap) +OPENMP_TARGET_PARALLEL_CLAUSE(num_threads) +OPENMP_TARGET_PARALLEL_CLAUSE(default) +OPENMP_TARGET_PARALLEL_CLAUSE(proc_bind) +OPENMP_TARGET_PARALLEL_CLAUSE(shared) +OPENMP_TARGET_PARALLEL_CLAUSE(reduction) + +// Clauses allowed for OpenMP directive 'target parallel for'. +// TODO: add target clauses 'is_device_ptr' +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(if) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(device) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(map) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(private) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(firstprivate) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(lastprivate) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(nowait) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(depend) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(defaultmap) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(num_threads) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(default) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(proc_bind) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(shared) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(reduction) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(collapse) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(schedule) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(ordered) +OPENMP_TARGET_PARALLEL_FOR_CLAUSE(linear) + +// Clauses allowed for OpenMP directive 'target update'. +// TODO More clauses for 'target update' directive. +OPENMP_TARGET_UPDATE_CLAUSE(if) +OPENMP_TARGET_UPDATE_CLAUSE(device) +OPENMP_TARGET_UPDATE_CLAUSE(to) +OPENMP_TARGET_UPDATE_CLAUSE(from) +OPENMP_TARGET_UPDATE_CLAUSE(nowait) +OPENMP_TARGET_UPDATE_CLAUSE(depend) // Clauses allowed for OpenMP directive 'teams'. // TODO More clauses for 'teams' directive. @@ -418,6 +545,80 @@ OPENMP_DISTRIBUTE_CLAUSE(private) OPENMP_DISTRIBUTE_CLAUSE(firstprivate) OPENMP_DISTRIBUTE_CLAUSE(lastprivate) OPENMP_DISTRIBUTE_CLAUSE(collapse) +OPENMP_DISTRIBUTE_CLAUSE(dist_schedule) + +// Static attributes for 'dist_schedule' clause. +OPENMP_DIST_SCHEDULE_KIND(static) + +// Clauses allowed for OpenMP directive 'distribute parallel for' +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(firstprivate) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(lastprivate) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(collapse) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(dist_schedule) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(if) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_threads) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(default) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(proc_bind) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(private) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(shared) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(reduction) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(copyin) +OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(schedule) + +// Clauses allowed for OpenMP directive 'distribute parallel for simd' +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(collapse) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(dist_schedule) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(if) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_threads) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(default) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(private) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(shared) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(reduction) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(copyin) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(schedule) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(linear) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(aligned) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(safelen) +OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(simdlen) + +// Clauses allowed for OpenMP directive 'distribute simd' +OPENMP_DISTRIBUTE_SIMD_CLAUSE(private) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(firstprivate) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(lastprivate) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(collapse) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(dist_schedule) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(linear) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(aligned) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(safelen) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(simdlen) +OPENMP_DISTRIBUTE_SIMD_CLAUSE(reduction) + +// Clauses allowed for OpenMP directive 'target parallel for simd'. +// TODO: add target clauses 'is_device_ptr' +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(if) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(device) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(map) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(private) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(nowait) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(depend) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(defaultmap) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(num_threads) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(default) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(shared) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(reduction) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(collapse) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(schedule) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(ordered) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(linear) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(safelen) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(simdlen) +OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(aligned) #undef OPENMP_TASKLOOP_SIMD_CLAUSE #undef OPENMP_TASKLOOP_CLAUSE @@ -443,9 +644,21 @@ OPENMP_DISTRIBUTE_CLAUSE(collapse) #undef OPENMP_ATOMIC_CLAUSE #undef OPENMP_TARGET_CLAUSE #undef OPENMP_TARGET_DATA_CLAUSE +#undef OPENMP_TARGET_ENTER_DATA_CLAUSE +#undef OPENMP_TARGET_EXIT_DATA_CLAUSE +#undef OPENMP_TARGET_PARALLEL_CLAUSE +#undef OPENMP_TARGET_PARALLEL_FOR_CLAUSE #undef OPENMP_TEAMS_CLAUSE #undef OPENMP_SIMD_CLAUSE #undef OPENMP_FOR_CLAUSE #undef OPENMP_FOR_SIMD_CLAUSE #undef OPENMP_MAP_KIND #undef OPENMP_DISTRIBUTE_CLAUSE +#undef OPENMP_DIST_SCHEDULE_KIND +#undef OPENMP_DEFAULTMAP_KIND +#undef OPENMP_DEFAULTMAP_MODIFIER +#undef OPENMP_TARGET_UPDATE_CLAUSE +#undef OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE +#undef OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE +#undef OPENMP_DISTRIBUTE_SIMD_CLAUSE +#undef OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE diff --git a/include/clang/Basic/OpenMPKinds.h b/include/clang/Basic/OpenMPKinds.h index d4d3db80329d..0a8e890b7c44 100644 --- a/include/clang/Basic/OpenMPKinds.h +++ b/include/clang/Basic/OpenMPKinds.h @@ -35,6 +35,7 @@ enum OpenMPClauseKind { OMPC_##Name, #include "clang/Basic/OpenMPKinds.def" OMPC_threadprivate, + OMPC_uniform, OMPC_unknown }; @@ -95,6 +96,37 @@ enum OpenMPMapClauseKind { OMPC_MAP_unknown }; +/// \brief OpenMP attributes for 'dist_schedule' clause. +enum OpenMPDistScheduleClauseKind { +#define OPENMP_DIST_SCHEDULE_KIND(Name) OMPC_DIST_SCHEDULE_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_DIST_SCHEDULE_unknown +}; + +/// \brief OpenMP attributes for 'defaultmap' clause. +enum OpenMPDefaultmapClauseKind { +#define OPENMP_DEFAULTMAP_KIND(Name) \ + OMPC_DEFAULTMAP_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_DEFAULTMAP_unknown +}; + +/// \brief OpenMP modifiers for 'defaultmap' clause. +enum OpenMPDefaultmapClauseModifier { + OMPC_DEFAULTMAP_MODIFIER_unknown = OMPC_DEFAULTMAP_unknown, +#define OPENMP_DEFAULTMAP_MODIFIER(Name) \ + OMPC_DEFAULTMAP_MODIFIER_##Name, +#include "clang/Basic/OpenMPKinds.def" + OMPC_DEFAULTMAP_MODIFIER_last +}; + +/// Scheduling data for loop-based OpenMP directives. +struct OpenMPScheduleTy final { + OpenMPScheduleClauseKind Schedule = OMPC_SCHEDULE_unknown; + OpenMPScheduleClauseModifier M1 = OMPC_SCHEDULE_MODIFIER_unknown; + OpenMPScheduleClauseModifier M2 = OMPC_SCHEDULE_MODIFIER_unknown; +}; + OpenMPDirectiveKind getOpenMPDirectiveKind(llvm::StringRef Str); const char *getOpenMPDirectiveName(OpenMPDirectiveKind Kind); @@ -132,11 +164,20 @@ bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind); /// parallel', otherwise - false. bool isOpenMPParallelDirective(OpenMPDirectiveKind DKind); -/// \brief Checks if the specified directive is a target-kind directive. +/// \brief Checks if the specified directive is a target code offload directive. /// \param DKind Specified directive. -/// \return true - the directive is a target-like directive like 'omp target', +/// \return true - the directive is a target code offload directive like +/// 'omp target', 'omp target parallel', 'omp target xxx' /// otherwise - false. -bool isOpenMPTargetDirective(OpenMPDirectiveKind DKind); +bool isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind); + +/// \brief Checks if the specified directive is a target data offload directive. +/// \param DKind Specified directive. +/// \return true - the directive is a target data offload directive like +/// 'omp target data', 'omp target update', 'omp target enter data', +/// 'omp target exit data' +/// otherwise - false. +bool isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind); /// \brief Checks if the specified directive is a teams-kind directive. /// \param DKind Specified directive. @@ -169,6 +210,14 @@ bool isOpenMPPrivate(OpenMPClauseKind Kind); /// \return true - the clause is a threadprivate clause, otherwise - false. bool isOpenMPThreadPrivate(OpenMPClauseKind Kind); +/// Checks if the specified directive kind is one of tasking directives - task, +/// taskloop or taksloop simd. +bool isOpenMPTaskingDirective(OpenMPDirectiveKind Kind); + +/// Checks if the specified directive kind is one of the composite or combined +/// directives that need loop bound sharing across loops outlined in nested +/// functions +bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind); } #endif diff --git a/include/clang/Basic/PragmaKinds.h b/include/clang/Basic/PragmaKinds.h new file mode 100644 index 000000000000..b373a9e4e29e --- /dev/null +++ b/include/clang/Basic/PragmaKinds.h @@ -0,0 +1,31 @@ +//===--- PragmaKinds.h - #pragma comment() kinds ---------------*- 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_PRAGMA_KINDS_H +#define LLVM_CLANG_BASIC_PRAGMA_KINDS_H + +namespace clang { + +enum PragmaMSCommentKind { + PCK_Unknown, + PCK_Linker, // #pragma comment(linker, ...) + PCK_Lib, // #pragma comment(lib, ...) + PCK_Compiler, // #pragma comment(compiler, ...) + PCK_ExeStr, // #pragma comment(exestr, ...) + PCK_User // #pragma comment(user, ...) +}; + +enum PragmaMSStructKind { + PMSST_OFF, // #pragms ms_struct off + PMSST_ON // #pragms ms_struct on +}; + +} + +#endif diff --git a/include/clang/Basic/Sanitizers.def b/include/clang/Basic/Sanitizers.def index 4b6859362910..c81273ea5fd4 100644 --- a/include/clang/Basic/Sanitizers.def +++ b/include/clang/Basic/Sanitizers.def @@ -114,6 +114,13 @@ SANITIZER_GROUP("integer", Integer, SANITIZER("local-bounds", LocalBounds) SANITIZER_GROUP("bounds", Bounds, ArrayBounds | LocalBounds) +// EfficiencySanitizer +SANITIZER("efficiency-cache-frag", EfficiencyCacheFrag) +SANITIZER("efficiency-working-set", EfficiencyWorkingSet) +// Meta-group only used internally. +SANITIZER_GROUP("efficiency-all", Efficiency, + EfficiencyCacheFrag | EfficiencyWorkingSet) + // Magic group, containing all sanitizers. For example, "-fno-sanitize=all" // can be used to disable all the sanitizers. SANITIZER_GROUP("all", All, ~0ULL) diff --git a/include/clang/Basic/Sanitizers.h b/include/clang/Basic/Sanitizers.h index 98e70dee45e5..bfa8e516edd3 100644 --- a/include/clang/Basic/Sanitizers.h +++ b/include/clang/Basic/Sanitizers.h @@ -46,8 +46,6 @@ enum SanitizerOrdinal : uint64_t { } struct SanitizerSet { - SanitizerSet() : Mask(0) {} - /// \brief Check if a certain (single) sanitizer is enabled. bool has(SanitizerMask K) const { assert(llvm::isPowerOf2_64(K)); @@ -70,7 +68,7 @@ struct SanitizerSet { bool empty() const { return Mask == 0; } /// \brief Bitmask of enabled sanitizers. - SanitizerMask Mask; + SanitizerMask Mask = 0; }; /// Parse a single value from a -fsanitize= or -fno-sanitize= value list. diff --git a/include/clang/Basic/SourceLocation.h b/include/clang/Basic/SourceLocation.h index 0aeba5e3f372..006cf3dc950c 100644 --- a/include/clang/Basic/SourceLocation.h +++ b/include/clang/Basic/SourceLocation.h @@ -373,22 +373,22 @@ public: /// \brief Return the presumed filename of this location. /// /// This can be affected by \#line etc. - const char *getFilename() const { return Filename; } + const char *getFilename() const { assert(isValid()); return Filename; } /// \brief Return the presumed line number of this location. /// /// This can be affected by \#line etc. - unsigned getLine() const { return Line; } + unsigned getLine() const { assert(isValid()); return Line; } /// \brief Return the presumed column number of this location. /// /// This cannot be affected by \#line, but is packaged here for convenience. - unsigned getColumn() const { return Col; } + unsigned getColumn() const { assert(isValid()); return Col; } /// \brief Return the presumed include location of this location. /// /// This can be affected by GNU linemarker directives. - SourceLocation getIncludeLoc() const { return IncludeLoc; } + SourceLocation getIncludeLoc() const { assert(isValid()); return IncludeLoc; } }; diff --git a/include/clang/Basic/SourceManager.h b/include/clang/Basic/SourceManager.h index 99392a098274..23ad73894fd3 100644 --- a/include/clang/Basic/SourceManager.h +++ b/include/clang/Basic/SourceManager.h @@ -61,7 +61,6 @@ class SourceManager; class FileManager; class FileEntry; class LineTableInfo; -class LangOptions; class ASTWriter; class ASTReader; @@ -798,6 +797,15 @@ public: IncludeLoc, FileCharacter, LoadedID, LoadedOffset); } + /// \brief Get the FileID for \p SourceFile if it exists. Otherwise, create a + /// new FileID for the \p SourceFile. + FileID getOrCreateFileID(const FileEntry *SourceFile, + SrcMgr::CharacteristicKind FileCharacter) { + FileID ID = translateFile(SourceFile); + return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(), + FileCharacter); + } + /// \brief Return a new SourceLocation that encodes the /// fact that a token from SpellingLoc should actually be referenced from /// ExpansionLoc, and that it represents the expansion of a macro argument diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index e284171f7773..fffd4b1cd20b 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -54,6 +54,7 @@ namespace clang { TST_half, // OpenCL half, ARM NEON __fp16 TST_float, TST_double, + TST_float128, TST_bool, // _Bool TST_decimal32, // _Decimal32 TST_decimal64, // _Decimal64 @@ -73,16 +74,18 @@ namespace clang { TST_auto_type, // __auto_type extension TST_unknown_anytype, // __unknown_anytype extension TST_atomic, // C11 _Atomic - TST_error // erroneous type +#define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types +#include "clang/Basic/OpenCLImageTypes.def" + TST_error // erroneous type }; - + /// \brief Structure that packs information about the type specifiers that /// were written in a particular type specifier sequence. struct WrittenBuiltinSpecs { /*DeclSpec::TST*/ unsigned Type : 5; /*DeclSpec::TSS*/ unsigned Sign : 2; /*DeclSpec::TSW*/ unsigned Width : 2; - bool ModeAttr : 1; + unsigned ModeAttr : 1; }; /// \brief A C++ access specifier (public, private, protected), plus the @@ -238,7 +241,10 @@ namespace clang { CC_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp"))) CC_IntelOclBicc, // __attribute__((intel_ocl_bicc)) CC_SpirFunction, // default for OpenCL functions on SPIR target - CC_SpirKernel // inferred for OpenCL kernels on SPIR target + CC_OpenCLKernel, // inferred for OpenCL kernels + CC_Swift, // __attribute__((swiftcall)) + CC_PreserveMost, // __attribute__((preserve_most)) + CC_PreserveAll, // __attribute__((preserve_all)) }; /// \brief Checks whether the given calling convention supports variadic @@ -251,7 +257,8 @@ namespace clang { case CC_X86Pascal: case CC_X86VectorCall: case CC_SpirFunction: - case CC_SpirKernel: + case CC_OpenCLKernel: + case CC_Swift: return false; default: return true; @@ -283,6 +290,28 @@ namespace clang { /// Retrieve the spelling of the given nullability kind. llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive = false); + + /// \brief Kinds of parameter ABI. + enum class ParameterABI { + /// This parameter uses ordinary ABI rules for its type. + Ordinary, + + /// This parameter (which must have pointer type) is a Swift + /// indirect result parameter. + SwiftIndirectResult, + + /// This parameter (which must have pointer-to-pointer type) uses + /// the special Swift error-result ABI treatment. There can be at + /// most one parameter on a given function that uses this treatment. + SwiftErrorResult, + + /// This parameter (which must have pointer type) uses the special + /// Swift context-pointer ABI treatment. There can be at + /// most one parameter on a given function that uses this treatment. + SwiftContext + }; + + llvm::StringRef getParameterABISpelling(ParameterABI kind); } // end namespace clang #endif // LLVM_CLANG_BASIC_SPECIFIERS_H diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index 36519ea29c98..973b3bb6fd17 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -126,6 +126,7 @@ def ArrayTypeTraitExpr : DStmt<Expr>; def ExpressionTraitExpr : DStmt<Expr>; def DependentScopeDeclRefExpr : DStmt<Expr>; def CXXConstructExpr : DStmt<Expr>; +def CXXInheritedCtorInitExpr : DStmt<Expr>; def CXXBindTemporaryExpr : DStmt<Expr>; def ExprWithCleanups : DStmt<Expr>; def CXXTemporaryObjectExpr : DStmt<CXXConstructExpr>; @@ -164,6 +165,7 @@ def ObjCIsaExpr : DStmt<Expr>; def ObjCIndirectCopyRestoreExpr : DStmt<Expr>; def ObjCBoolLiteralExpr : DStmt<Expr>; def ObjCSubscriptRefExpr : DStmt<Expr>; +def ObjCAvailabilityCheckExpr : DStmt<Expr>; // Obj-C ARC Expressions. def ObjCBridgedCastExpr : DStmt<ExplicitCastExpr>; @@ -216,9 +218,18 @@ def OMPOrderedDirective : DStmt<OMPExecutableDirective>; def OMPAtomicDirective : DStmt<OMPExecutableDirective>; def OMPTargetDirective : DStmt<OMPExecutableDirective>; def OMPTargetDataDirective : DStmt<OMPExecutableDirective>; +def OMPTargetEnterDataDirective : DStmt<OMPExecutableDirective>; +def OMPTargetExitDataDirective : DStmt<OMPExecutableDirective>; +def OMPTargetParallelDirective : DStmt<OMPExecutableDirective>; +def OMPTargetParallelForDirective : DStmt<OMPExecutableDirective>; +def OMPTargetUpdateDirective : DStmt<OMPExecutableDirective>; def OMPTeamsDirective : DStmt<OMPExecutableDirective>; def OMPCancellationPointDirective : DStmt<OMPExecutableDirective>; def OMPCancelDirective : DStmt<OMPExecutableDirective>; def OMPTaskLoopDirective : DStmt<OMPLoopDirective>; def OMPTaskLoopSimdDirective : DStmt<OMPLoopDirective>; def OMPDistributeDirective : DStmt<OMPLoopDirective>; +def OMPDistributeParallelForDirective : DStmt<OMPLoopDirective>; +def OMPDistributeParallelForSimdDirective : DStmt<OMPLoopDirective>; +def OMPDistributeSimdDirective : DStmt<OMPLoopDirective>; +def OMPTargetParallelForSimdDirective : DStmt<OMPLoopDirective>; diff --git a/include/clang/Basic/TargetCXXABI.h b/include/clang/Basic/TargetCXXABI.h index 67247ead2eb4..f7d4b920ca15 100644 --- a/include/clang/Basic/TargetCXXABI.h +++ b/include/clang/Basic/TargetCXXABI.h @@ -239,7 +239,7 @@ public: /// \brief Can an out-of-line inline function serve as a key function? /// /// This flag is only useful in ABIs where type data (for example, - /// v-tables and type_info objects) are emitted only after processing + /// vtables and type_info objects) are emitted only after processing /// the definition of a special "key" virtual function. (This is safe /// because the ODR requires that every virtual function be defined /// somewhere in a program.) This usually permits such data to be diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index f1d833817077..f458c166a7a8 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -21,13 +21,14 @@ #include "clang/Basic/TargetCXXABI.h" #include "clang/Basic/TargetOptions.h" #include "clang/Basic/VersionTuple.h" -#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/APInt.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/Triple.h" +#include "llvm/IR/DataLayout.h" #include "llvm/Support/DataTypes.h" #include <cassert> #include <string> @@ -57,13 +58,14 @@ protected: bool BigEndian; bool TLSSupported; bool NoAsmVariants; // True if {|} are normal characters. + bool HasFloat128; unsigned char PointerWidth, PointerAlign; unsigned char BoolWidth, BoolAlign; unsigned char IntWidth, IntAlign; unsigned char HalfWidth, HalfAlign; unsigned char FloatWidth, FloatAlign; unsigned char DoubleWidth, DoubleAlign; - unsigned char LongDoubleWidth, LongDoubleAlign; + unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align; unsigned char LargeArrayMinWidth, LargeArrayAlign; unsigned char LongWidth, LongAlign; unsigned char LongLongWidth, LongLongAlign; @@ -74,11 +76,10 @@ protected: unsigned short MaxVectorAlign; unsigned short MaxTLSAlign; unsigned short SimdDefaultAlign; - const char *DataLayoutString; - const char *UserLabelPrefix; + std::unique_ptr<llvm::DataLayout> DataLayout; const char *MCountName; const llvm::fltSemantics *HalfFormat, *FloatFormat, *DoubleFormat, - *LongDoubleFormat; + *LongDoubleFormat, *Float128Format; unsigned char RegParmMax, SSERegParmMax; TargetCXXABI TheCXXABI; const LangAS::Map *AddrSpaceMap; @@ -95,6 +96,10 @@ protected: // TargetInfo Constructor. Default initializes all fields. TargetInfo(const llvm::Triple &T); + void resetDataLayout(StringRef DL) { + DataLayout.reset(new llvm::DataLayout(DL)); + } + public: /// \brief Construct a target for the given options. /// @@ -132,7 +137,8 @@ public: NoFloat = 255, Float = 0, Double, - LongDouble + LongDouble, + Float128 }; /// \brief The different kinds of __builtin_va_list types defined by @@ -202,6 +208,9 @@ protected: /// zero-length bitfield. unsigned UseZeroLengthBitfieldAlignment : 1; + /// \brief Whether explicit bit field alignment attributes are honored. + unsigned UseExplicitBitFieldAlignment : 1; + /// If non-zero, specifies a fixed alignment value for bitfields that follow /// zero length bitfield, regardless of the zero length bitfield type. unsigned ZeroLengthBitfieldBoundary; @@ -320,6 +329,9 @@ public: return getPointerWidth(0) >= 64; } // FIXME + /// \brief Determine whether the __float128 type is supported on this target. + virtual bool hasFloat128Type() const { return HasFloat128; } + /// \brief Return the alignment that is suitable for storing any /// object with a fundamental alignment requirement. unsigned getSuitableAlign() const { return SuitableAlign; } @@ -372,6 +384,14 @@ public: return *LongDoubleFormat; } + /// getFloat128Width/Align/Format - Return the size/align/format of + /// '__float128'. + unsigned getFloat128Width() const { return 128; } + unsigned getFloat128Align() const { return Float128Align; } + const llvm::fltSemantics &getFloat128Format() const { + return *Float128Format; + } + /// \brief Return true if the 'long double' type should be mangled like /// __float128. virtual bool useFloat128ManglingForLongDouble() const { return false; } @@ -407,30 +427,37 @@ public: /// types for the given target. unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; } + /// Return the alignment (in bits) of the thrown exception object. This is + /// only meaningful for targets that allocate C++ exceptions in a system + /// runtime, such as those using the Itanium C++ ABI. + virtual unsigned getExnObjectAlignment() const { + // Itanium says that an _Unwind_Exception has to be "double-word" + // aligned (and thus the end of it is also so-aligned), meaning 16 + // bytes. Of course, that was written for the actual Itanium, + // which is a 64-bit platform. Classically, the ABI doesn't really + // specify the alignment on other platforms, but in practice + // libUnwind declares the struct with __attribute__((aligned)), so + // we assume that alignment here. (It's generally 16 bytes, but + // some targets overwrite it.) + return getDefaultAlignForAttributeAligned(); + } + /// \brief Return the size of intmax_t and uintmax_t for this target, in bits. unsigned getIntMaxTWidth() const { return getTypeWidth(IntMaxType); } // Return the size of unwind_word for this target. - unsigned getUnwindWordWidth() const { return getPointerWidth(0); } + virtual unsigned getUnwindWordWidth() const { return getPointerWidth(0); } /// \brief Return the "preferred" register width on this target. - unsigned getRegisterWidth() const { + virtual unsigned getRegisterWidth() const { // Currently we assume the register width on the target matches the pointer // width, we can introduce a new variable for this if/when some target wants // it. return PointerWidth; } - /// \brief Returns the default value of the __USER_LABEL_PREFIX__ macro, - /// which is the prefix given to user symbols by default. - /// - /// On most platforms this is "_", but it is "" on some, and "." on others. - const char *getUserLabelPrefix() const { - return UserLabelPrefix; - } - /// \brief Returns the name of the mcount instrumentation function. const char *getMCountName() const { return MCountName; @@ -466,6 +493,12 @@ public: return ZeroLengthBitfieldBoundary; } + /// \brief Check whether explicit bitfield alignment attributes should be + // honored, as in "__attribute__((aligned(2))) int b : 1;". + bool useExplicitBitFieldAlignment() const { + return UseExplicitBitFieldAlignment; + } + /// \brief Check whether this target support '\#pragma options align=mac68k'. bool hasAlignMac68kSupport() const { return HasAlignMac68kSupport; @@ -712,9 +745,9 @@ public: return Triple; } - const char *getDataLayoutString() const { - assert(DataLayoutString && "Uninitialized DataLayoutString!"); - return DataLayoutString; + const llvm::DataLayout &getDataLayout() const { + assert(DataLayout && "Uninitialized DataLayout!"); + return *DataLayout; } struct GCCRegAlias { @@ -868,6 +901,8 @@ public: /// \brief Return the register number that __builtin_eh_return_regno would /// return with the specified argument. + /// This corresponds with TargetLowering's getExceptionPointerRegister + /// and getExceptionSelectorRegister in the backend. virtual int getEHDataRegisterNumber(unsigned RegNo) const { return -1; } @@ -931,6 +966,27 @@ public: return false; } + /// \brief Whether target allows to overalign ABI-specified prefered alignment + virtual bool allowsLargerPreferedTypeAlignment() const { return true; } + + /// \brief Set supported OpenCL extensions and optional core features. + virtual void setSupportedOpenCLOpts() {} + + /// \brief Get supported OpenCL extensions and optional core features. + OpenCLOptions &getSupportedOpenCLOpts() { + return getTargetOpts().SupportedOpenCLOptions; + } + + /// \brief Get const supported OpenCL extensions and optional core features. + const OpenCLOptions &getSupportedOpenCLOpts() const { + return getTargetOpts().SupportedOpenCLOptions; + } + + /// \brief Check the target is valid after it is fully initialized. + virtual bool validateTarget(DiagnosticsEngine &Diags) const { + return true; + } + protected: virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return PointerWidth; diff --git a/include/clang/Basic/TargetOptions.h b/include/clang/Basic/TargetOptions.h index ca0cca78bfc8..fde294c92251 100644 --- a/include/clang/Basic/TargetOptions.h +++ b/include/clang/Basic/TargetOptions.h @@ -17,6 +17,7 @@ #include <string> #include <vector> +#include "clang/Basic/OpenCLOptions.h" namespace clang { @@ -27,6 +28,10 @@ public: /// target will be selected to match the host. std::string Triple; + /// When compiling for the device side, contains the triple used to compile + /// for the host. + std::string HostTriple; + /// If given, the name of the target CPU to generate code for. std::string CPU; @@ -36,6 +41,9 @@ public: /// If given, the name of the target ABI to use. std::string ABI; + /// The EABI version to use + std::string EABIVersion; + /// If given, the version string of the linker in use. std::string LinkerVersion; @@ -45,8 +53,11 @@ public: /// The list of target specific features to enable or disable -- this should /// be a list of strings starting with by '+' or '-'. std::vector<std::string> Features; - + std::vector<std::string> Reciprocals; + + /// Supported OpenCL extensions and optional core features. + OpenCLOptions SupportedOpenCLOptions; }; } // end namespace clang diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index 026945141d24..882c6e4cac2c 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -219,6 +219,9 @@ PUNCTUATOR(at, "@") PUNCTUATOR(lesslessless, "<<<") PUNCTUATOR(greatergreatergreater, ">>>") +// CL support +PUNCTUATOR(caretcaret, "^^") + // C99 6.4.1: Keywords. These turn into kw_* tokens. // Flags allowed: // KEYALL - This is a keyword in all variants of C and C++, or it @@ -377,6 +380,7 @@ KEYWORD(__builtin_offsetof , KEYALL) TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX) KEYWORD(__builtin_va_arg , KEYALL) KEYWORD(__extension__ , KEYALL) +KEYWORD(__float128 , KEYALL) KEYWORD(__imag , KEYALL) KEYWORD(__int128 , KEYALL) KEYWORD(__label__ , KEYALL) @@ -403,6 +407,9 @@ TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX) TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX) TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX) +// MSVC14.0 / VS2015 Type Traits +TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX) + // GNU and MS Type Traits TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX) TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX) @@ -515,6 +522,8 @@ ALIAS("read_write", __read_write , KEYOPENCL) // OpenCL builtins KEYWORD(__builtin_astype , KEYOPENCL) KEYWORD(vec_step , KEYOPENCL|KEYALTIVEC|KEYZVECTOR) +#define GENERIC_IMAGE_TYPE(ImgType, Id) KEYWORD(ImgType##_t, KEYOPENCL) +#include "clang/Basic/OpenCLImageTypes.def" // OpenMP Type Traits KEYWORD(__builtin_omp_required_simd_align, KEYALL) @@ -621,6 +630,8 @@ KEYWORD(__builtin_convertvector , KEYALL) ALIAS("__char16_t" , char16_t , KEYCXX) ALIAS("__char32_t" , char32_t , KEYCXX) +KEYWORD(__builtin_available , KEYALL) + // Clang-specific keywords enabled only in testing. TESTING_KEYWORD(__unknown_anytype , KEYALL) @@ -659,6 +670,7 @@ OBJC2_AT_KEYWORD(optional) OBJC2_AT_KEYWORD(synthesize) OBJC2_AT_KEYWORD(dynamic) OBJC2_AT_KEYWORD(import) +OBJC2_AT_KEYWORD(available) // TODO: What to do about context-sensitive keywords like: // bycopy/byref/in/inout/oneway/out? diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h index 765246b4cc54..730ecba3d4fa 100644 --- a/include/clang/Basic/TypeTraits.h +++ b/include/clang/Basic/TypeTraits.h @@ -74,6 +74,7 @@ namespace clang { BTT_IsConvertibleTo, BTT_IsSame, BTT_TypeCompatible, + BTT_IsAssignable, BTT_IsNothrowAssignable, BTT_IsTriviallyAssignable, BTT_Last = BTT_IsTriviallyAssignable, diff --git a/include/clang/Basic/VersionTuple.h b/include/clang/Basic/VersionTuple.h index 784f3f322d69..da3b01903ed9 100644 --- a/include/clang/Basic/VersionTuple.h +++ b/include/clang/Basic/VersionTuple.h @@ -25,39 +25,44 @@ namespace clang { /// \brief Represents a version number in the form major[.minor[.subminor[.build]]]. class VersionTuple { unsigned Major : 31; + + unsigned UsesUnderscores : 1; + unsigned Minor : 31; - unsigned Subminor : 31; - unsigned Build : 31; unsigned HasMinor : 1; + + unsigned Subminor : 31; unsigned HasSubminor : 1; + + unsigned Build : 31; unsigned HasBuild : 1; - unsigned UsesUnderscores : 1; public: VersionTuple() - : Major(0), Minor(0), Subminor(0), Build(0), HasMinor(false), - HasSubminor(false), HasBuild(false), UsesUnderscores(false) {} + : Major(0), UsesUnderscores(false), Minor(0), HasMinor(false), + Subminor(0), HasSubminor(false), Build(0), HasBuild(false) {} explicit VersionTuple(unsigned Major) - : Major(Major), Minor(0), Subminor(0), Build(0), HasMinor(false), - HasSubminor(false), HasBuild(false), UsesUnderscores(false) {} + : Major(Major), UsesUnderscores(false), Minor(0), HasMinor(false), + Subminor(0), HasSubminor(false), Build(0), HasBuild(false) {} explicit VersionTuple(unsigned Major, unsigned Minor, bool UsesUnderscores = false) - : Major(Major), Minor(Minor), Subminor(0), Build(0), HasMinor(true), - HasSubminor(false), HasBuild(false), UsesUnderscores(UsesUnderscores) {} + : Major(Major), UsesUnderscores(UsesUnderscores), Minor(Minor), + HasMinor(true), Subminor(0), HasSubminor(false), Build(0), + HasBuild(false) {} explicit VersionTuple(unsigned Major, unsigned Minor, unsigned Subminor, bool UsesUnderscores = false) - : Major(Major), Minor(Minor), Subminor(Subminor), Build(0), - HasMinor(true), HasSubminor(true), HasBuild(false), - UsesUnderscores(UsesUnderscores) {} + : Major(Major), UsesUnderscores(UsesUnderscores), Minor(Minor), + HasMinor(true), Subminor(Subminor), HasSubminor(true), Build(0), + HasBuild(false) {} explicit VersionTuple(unsigned Major, unsigned Minor, unsigned Subminor, unsigned Build, bool UsesUnderscores = false) - : Major(Major), Minor(Minor), Subminor(Subminor), Build(Build), - HasMinor(true), HasSubminor(true), HasBuild(true), - UsesUnderscores(UsesUnderscores) {} + : Major(Major), UsesUnderscores(UsesUnderscores), Minor(Minor), + HasMinor(true), Subminor(Subminor), HasSubminor(true), Build(Build), + HasBuild(true) {} /// \brief Determine whether this version information is empty /// (e.g., all version components are zero). diff --git a/include/clang/Basic/VirtualFileSystem.h b/include/clang/Basic/VirtualFileSystem.h index bab88c90b0a8..6ac0812dbb17 100644 --- a/include/clang/Basic/VirtualFileSystem.h +++ b/include/clang/Basic/VirtualFileSystem.h @@ -20,6 +20,7 @@ #include "llvm/Support/FileSystem.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/raw_ostream.h" +#include <utility> namespace llvm { class MemoryBuffer; @@ -90,6 +91,13 @@ public: virtual ~File(); /// \brief Get the status of the file. virtual llvm::ErrorOr<Status> status() = 0; + /// \brief Get the name of the file + virtual llvm::ErrorOr<std::string> getName() { + if (auto Status = status()) + return Status->getName().str(); + else + return Status.getError(); + } /// \brief 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, @@ -116,7 +124,8 @@ class directory_iterator { std::shared_ptr<detail::DirIterImpl> Impl; // Input iterator semantics on copy public: - directory_iterator(std::shared_ptr<detail::DirIterImpl> I) : Impl(I) { + 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. @@ -176,6 +185,11 @@ public: bool operator!=(const recursive_directory_iterator &RHS) const { return !(*this == RHS); } + /// \brief Gets the current level. Starting path is at level 0. + int level() const { + assert(State->size() && "Cannot get level without any iteration state"); + return State->size()-1; + } }; /// \brief The virtual file system interface. @@ -310,6 +324,7 @@ llvm::sys::fs::UniqueID getNextVirtualUniqueID(); IntrusiveRefCntPtr<FileSystem> getVFSFromYAML(std::unique_ptr<llvm::MemoryBuffer> Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, + StringRef YAMLFilePath, void *DiagContext = nullptr, IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem()); @@ -323,6 +338,9 @@ struct YAMLVFSEntry { class YAMLVFSWriter { std::vector<YAMLVFSEntry> Mappings; Optional<bool> IsCaseSensitive; + Optional<bool> IsOverlayRelative; + Optional<bool> UseExternalNames; + std::string OverlayDir; public: YAMLVFSWriter() {} @@ -330,6 +348,14 @@ public: void setCaseSensitivity(bool CaseSensitive) { IsCaseSensitive = CaseSensitive; } + void setUseExternalNames(bool UseExtNames) { + UseExternalNames = UseExtNames; + } + void setOverlayDir(StringRef OverlayDirectory) { + IsOverlayRelative = true; + OverlayDir.assign(OverlayDirectory.str()); + } + void write(llvm::raw_ostream &OS); }; diff --git a/include/clang/Basic/arm_neon.td b/include/clang/Basic/arm_neon.td index 6d95c1ec157a..5605fc6de2b6 100644 --- a/include/clang/Basic/arm_neon.td +++ b/include/clang/Basic/arm_neon.td @@ -339,6 +339,7 @@ def OP_MLALHi : Op<(call "vmlal", $p0, (call "vget_high", $p1), (call "vget_high", $p2))>; def OP_MLALHi_N : Op<(call "vmlal_n", $p0, (call "vget_high", $p1), $p2)>; def OP_MLS : Op<(op "-", $p0, (op "*", $p1, $p2))>; +def OP_FMLS : Op<(call "vfma", $p0, (op "-", $p1), $p2)>; def OP_MLSL : Op<(op "-", $p0, (call "vmull", $p1, $p2))>; def OP_MLSLHi : Op<(call "vmlsl", $p0, (call "vget_high", $p1), (call "vget_high", $p2))>; @@ -347,7 +348,7 @@ def OP_MUL_N : Op<(op "*", $p0, (dup $p1))>; def OP_MLA_N : Op<(op "+", $p0, (op "*", $p1, (dup $p2)))>; def OP_MLS_N : Op<(op "-", $p0, (op "*", $p1, (dup $p2)))>; def OP_FMLA_N : Op<(call "vfma", $p0, $p1, (dup $p2))>; -def OP_FMLS_N : Op<(call "vfms", $p0, $p1, (dup $p2))>; +def OP_FMLS_N : Op<(call "vfma", $p0, (op "-", $p1), (dup $p2))>; def OP_MLAL_N : Op<(op "+", $p0, (call "vmull", $p1, (dup $p2)))>; def OP_MLSL_N : Op<(op "-", $p0, (call "vmull", $p1, (dup $p2)))>; def OP_MUL_LN : Op<(op "*", $p0, (splat $p1, $p2))>; @@ -377,8 +378,8 @@ def OP_QRDMLAH : Op<(call "vqadd", $p0, (call "vqrdmulh", $p1, $p2))>; def OP_QRDMLSH : Op<(call "vqsub", $p0, (call "vqrdmulh", $p1, $p2))>; def OP_QRDMLAH_LN : Op<(call "vqadd", $p0, (call "vqrdmulh", $p1, (splat $p2, $p3)))>; def OP_QRDMLSH_LN : Op<(call "vqsub", $p0, (call "vqrdmulh", $p1, (splat $p2, $p3)))>; -def OP_FMS_LN : Op<(call "vfma_lane", $p0, $p1, (op "-", $p2), $p3)>; -def OP_FMS_LNQ : Op<(call "vfma_laneq", $p0, $p1, (op "-", $p2), $p3)>; +def OP_FMS_LN : Op<(call "vfma_lane", $p0, (op "-", $p1), $p2, $p3)>; +def OP_FMS_LNQ : Op<(call "vfma_laneq", $p0, (op "-", $p1), $p2, $p3)>; def OP_TRN1 : Op<(shuffle $p0, $p1, (interleave (decimate mask0, 2), (decimate mask1, 2)))>; def OP_ZIP1 : Op<(shuffle $p0, $p1, (lowhalf (interleave mask0, mask1)))>; @@ -703,8 +704,10 @@ def VGET_LOW : NoTestOpInst<"vget_low", "dk", "csilhfUcUsUiUlPcPs", OP_LO>; //////////////////////////////////////////////////////////////////////////////// // E.3.22 Converting vectors -def VCVT_F16_F32 : SInst<"vcvt_f16_f32", "md", "Hf">; -def VCVT_F32_F16 : SInst<"vcvt_f32_f16", "wd", "h">; +let ArchGuard = "(__ARM_FP & 2)" in { + def VCVT_F16_F32 : SInst<"vcvt_f16_f32", "md", "Hf">; + def VCVT_F32_F16 : SInst<"vcvt_f32_f16", "wd", "h">; +} def VCVT_S32 : SInst<"vcvt_s32", "xd", "fQf">; def VCVT_U32 : SInst<"vcvt_u32", "ud", "fQf">; @@ -824,7 +827,10 @@ def VREINTERPRET //////////////////////////////////////////////////////////////////////////////// // Vector fused multiply-add operations -def VFMA : SInst<"vfma", "dddd", "fQf">; +let ArchGuard = "defined(__ARM_FEATURE_FMA)" in { + def VFMA : SInst<"vfma", "dddd", "fQf">; + def VFMS : SOpInst<"vfms", "dddd", "fQf", OP_FMLS>; +} //////////////////////////////////////////////////////////////////////////////// // fp16 vector operations @@ -908,7 +914,7 @@ def FDIV : IOpInst<"vdiv", "ddd", "fdQfQd", OP_DIV>; //////////////////////////////////////////////////////////////////////////////// // Vector fused multiply-add operations def FMLA : SInst<"vfma", "dddd", "dQd">; -def FMLS : SInst<"vfms", "dddd", "fdQfQd">; +def FMLS : SOpInst<"vfms", "dddd", "dQd", OP_FMLS>; //////////////////////////////////////////////////////////////////////////////// // MUL, MLA, MLS, FMA, FMS definitions with scalar argument @@ -961,7 +967,7 @@ def XTN2 : SOpInst<"vmovn_high", "qhk", "silUsUiUl", OP_XTN>; //////////////////////////////////////////////////////////////////////////////// // Signed integer saturating extract and unsigned narrow to high -def SQXTUN2 : SOpInst<"vqmovun_high", "qhk", "sil", OP_SQXTUN>; +def SQXTUN2 : SOpInst<"vqmovun_high", "emd", "HsHiHl", OP_SQXTUN>; //////////////////////////////////////////////////////////////////////////////// // Integer saturating extract and narrow to high |