1 //===- Intrinsics.td - Defines all LLVM intrinsics ---------*- tablegen -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines properties of all LLVM intrinsics. 11 // 12 //===----------------------------------------------------------------------===// 13 14 include "llvm/CodeGen/ValueTypes.td" 15 16 //===----------------------------------------------------------------------===// 17 // Properties we keep track of for intrinsics. 18 //===----------------------------------------------------------------------===// 19 20 class IntrinsicProperty; 21 22 // Intr*Mem - Memory properties. If no property is set, the worst case 23 // is assumed (it may read and write any memory it can get access to and it may 24 // have other side effects). 25 26 // IntrNoMem - The intrinsic does not access memory or have any other side 27 // effects. It may be CSE'd deleted if dead, etc. 28 def IntrNoMem : IntrinsicProperty; 29 30 // IntrReadMem - This intrinsic only reads from memory. It does not write to 31 // memory and has no other side effects. Therefore, it cannot be moved across 32 // potentially aliasing stores. However, it can be reordered otherwise and can 33 // be deleted if dead. 34 def IntrReadMem : IntrinsicProperty; 35 36 // IntrWriteMem - This intrinsic only writes to memory, but does not read from 37 // memory, and has no other side effects. This means dead stores before calls 38 // to this intrinsics may be removed. 39 def IntrWriteMem : IntrinsicProperty; 40 41 // IntrArgMemOnly - This intrinsic only accesses memory that its pointer-typed 42 // argument(s) points to, but may access an unspecified amount. Other than 43 // reads from and (possibly volatile) writes to memory, it has no side effects. 44 def IntrArgMemOnly : IntrinsicProperty; 45 46 // IntrInaccessibleMemOnly -- This intrinsic only accesses memory that is not 47 // accessible by the module being compiled. This is a weaker form of IntrNoMem. 48 def IntrInaccessibleMemOnly : IntrinsicProperty; 49 50 // IntrInaccessibleMemOrArgMemOnly -- This intrinsic only accesses memory that 51 // its pointer-typed arguments point to or memory that is not accessible 52 // by the module being compiled. This is a weaker form of IntrArgMemOnly. 53 def IntrInaccessibleMemOrArgMemOnly : IntrinsicProperty; 54 55 // Commutative - This intrinsic is commutative: X op Y == Y op X. 56 def Commutative : IntrinsicProperty; 57 58 // Throws - This intrinsic can throw. 59 def Throws : IntrinsicProperty; 60 61 // NoCapture - The specified argument pointer is not captured by the intrinsic. 62 class NoCapture<int argNo> : IntrinsicProperty { 63 int ArgNo = argNo; 64 } 65 66 // Returned - The specified argument is always the return value of the 67 // intrinsic. 68 class Returned<int argNo> : IntrinsicProperty { 69 int ArgNo = argNo; 70 } 71 72 // ReadOnly - The specified argument pointer is not written to through the 73 // pointer by the intrinsic. 74 class ReadOnly<int argNo> : IntrinsicProperty { 75 int ArgNo = argNo; 76 } 77 78 // WriteOnly - The intrinsic does not read memory through the specified 79 // argument pointer. 80 class WriteOnly<int argNo> : IntrinsicProperty { 81 int ArgNo = argNo; 82 } 83 84 // ReadNone - The specified argument pointer is not dereferenced by the 85 // intrinsic. 86 class ReadNone<int argNo> : IntrinsicProperty { 87 int ArgNo = argNo; 88 } 89 90 def IntrNoReturn : IntrinsicProperty; 91 92 // IntrNoduplicate - Calls to this intrinsic cannot be duplicated. 93 // Parallels the noduplicate attribute on LLVM IR functions. 94 def IntrNoDuplicate : IntrinsicProperty; 95 96 // IntrConvergent - Calls to this intrinsic are convergent and may not be made 97 // control-dependent on any additional values. 98 // Parallels the convergent attribute on LLVM IR functions. 99 def IntrConvergent : IntrinsicProperty; 100 101 // This property indicates that the intrinsic is safe to speculate. 102 def IntrSpeculatable : IntrinsicProperty; 103 104 // This property can be used to override the 'has no other side effects' 105 // language of the IntrNoMem, IntrReadMem, IntrWriteMem, and IntrArgMemOnly 106 // intrinsic properties. By default, intrinsics are assumed to have side 107 // effects, so this property is only necessary if you have defined one of 108 // the memory properties listed above. 109 // For this property, 'side effects' has the same meaning as 'side effects' 110 // defined by the hasSideEffects property of the TableGen Instruction class. 111 def IntrHasSideEffects : IntrinsicProperty; 112 113 //===----------------------------------------------------------------------===// 114 // Types used by intrinsics. 115 //===----------------------------------------------------------------------===// 116 117 class LLVMType<ValueType vt> { 118 ValueType VT = vt; 119 } 120 121 class LLVMQualPointerType<LLVMType elty, int addrspace> 122 : LLVMType<iPTR>{ 123 LLVMType ElTy = elty; 124 int AddrSpace = addrspace; 125 } 126 127 class LLVMPointerType<LLVMType elty> 128 : LLVMQualPointerType<elty, 0>; 129 130 class LLVMAnyPointerType<LLVMType elty> 131 : LLVMType<iPTRAny>{ 132 LLVMType ElTy = elty; 133 } 134 135 // Match the type of another intrinsic parameter. Number is an index into the 136 // list of overloaded types for the intrinsic, excluding all the fixed types. 137 // The Number value must refer to a previously listed type. For example: 138 // Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_anyfloat_ty, LLVMMatchType<0>]> 139 // has two overloaded types, the 2nd and 3rd arguments. LLVMMatchType<0> 140 // refers to the first overloaded type, which is the 2nd argument. 141 class LLVMMatchType<int num> 142 : LLVMType<OtherVT>{ 143 int Number = num; 144 } 145 146 // Match the type of another intrinsic parameter that is expected to be based on 147 // an integral type (i.e. either iN or <N x iM>), but change the scalar size to 148 // be twice as wide or half as wide as the other type. This is only useful when 149 // the intrinsic is overloaded, so the matched type should be declared as iAny. 150 class LLVMExtendedType<int num> : LLVMMatchType<num>; 151 class LLVMTruncatedType<int num> : LLVMMatchType<num>; 152 class LLVMVectorSameWidth<int num, LLVMType elty> 153 : LLVMMatchType<num> { 154 ValueType ElTy = elty.VT; 155 } 156 class LLVMPointerTo<int num> : LLVMMatchType<num>; 157 class LLVMPointerToElt<int num> : LLVMMatchType<num>; 158 class LLVMVectorOfAnyPointersToElt<int num> : LLVMMatchType<num>; 159 160 // Match the type of another intrinsic parameter that is expected to be a 161 // vector type, but change the element count to be half as many 162 class LLVMHalfElementsVectorType<int num> : LLVMMatchType<num>; 163 164 def llvm_void_ty : LLVMType<isVoid>; 165 def llvm_any_ty : LLVMType<Any>; 166 def llvm_anyint_ty : LLVMType<iAny>; 167 def llvm_anyfloat_ty : LLVMType<fAny>; 168 def llvm_anyvector_ty : LLVMType<vAny>; 169 def llvm_i1_ty : LLVMType<i1>; 170 def llvm_i8_ty : LLVMType<i8>; 171 def llvm_i16_ty : LLVMType<i16>; 172 def llvm_i32_ty : LLVMType<i32>; 173 def llvm_i64_ty : LLVMType<i64>; 174 def llvm_half_ty : LLVMType<f16>; 175 def llvm_float_ty : LLVMType<f32>; 176 def llvm_double_ty : LLVMType<f64>; 177 def llvm_f80_ty : LLVMType<f80>; 178 def llvm_f128_ty : LLVMType<f128>; 179 def llvm_ppcf128_ty : LLVMType<ppcf128>; 180 def llvm_ptr_ty : LLVMPointerType<llvm_i8_ty>; // i8* 181 def llvm_ptrptr_ty : LLVMPointerType<llvm_ptr_ty>; // i8** 182 def llvm_anyptr_ty : LLVMAnyPointerType<llvm_i8_ty>; // (space)i8* 183 def llvm_empty_ty : LLVMType<OtherVT>; // { } 184 def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>; // { }* 185 def llvm_metadata_ty : LLVMType<MetadataVT>; // !{...} 186 def llvm_token_ty : LLVMType<token>; // token 187 188 def llvm_x86mmx_ty : LLVMType<x86mmx>; 189 def llvm_ptrx86mmx_ty : LLVMPointerType<llvm_x86mmx_ty>; // <1 x i64>* 190 191 def llvm_v2i1_ty : LLVMType<v2i1>; // 2 x i1 192 def llvm_v4i1_ty : LLVMType<v4i1>; // 4 x i1 193 def llvm_v8i1_ty : LLVMType<v8i1>; // 8 x i1 194 def llvm_v16i1_ty : LLVMType<v16i1>; // 16 x i1 195 def llvm_v32i1_ty : LLVMType<v32i1>; // 32 x i1 196 def llvm_v64i1_ty : LLVMType<v64i1>; // 64 x i1 197 def llvm_v512i1_ty : LLVMType<v512i1>; // 512 x i1 198 def llvm_v1024i1_ty : LLVMType<v1024i1>; //1024 x i1 199 200 def llvm_v1i8_ty : LLVMType<v1i8>; // 1 x i8 201 def llvm_v2i8_ty : LLVMType<v2i8>; // 2 x i8 202 def llvm_v4i8_ty : LLVMType<v4i8>; // 4 x i8 203 def llvm_v8i8_ty : LLVMType<v8i8>; // 8 x i8 204 def llvm_v16i8_ty : LLVMType<v16i8>; // 16 x i8 205 def llvm_v32i8_ty : LLVMType<v32i8>; // 32 x i8 206 def llvm_v64i8_ty : LLVMType<v64i8>; // 64 x i8 207 def llvm_v128i8_ty : LLVMType<v128i8>; //128 x i8 208 def llvm_v256i8_ty : LLVMType<v256i8>; //256 x i8 209 210 def llvm_v1i16_ty : LLVMType<v1i16>; // 1 x i16 211 def llvm_v2i16_ty : LLVMType<v2i16>; // 2 x i16 212 def llvm_v4i16_ty : LLVMType<v4i16>; // 4 x i16 213 def llvm_v8i16_ty : LLVMType<v8i16>; // 8 x i16 214 def llvm_v16i16_ty : LLVMType<v16i16>; // 16 x i16 215 def llvm_v32i16_ty : LLVMType<v32i16>; // 32 x i16 216 def llvm_v64i16_ty : LLVMType<v64i16>; // 64 x i16 217 def llvm_v128i16_ty : LLVMType<v128i16>; //128 x i16 218 219 def llvm_v1i32_ty : LLVMType<v1i32>; // 1 x i32 220 def llvm_v2i32_ty : LLVMType<v2i32>; // 2 x i32 221 def llvm_v4i32_ty : LLVMType<v4i32>; // 4 x i32 222 def llvm_v8i32_ty : LLVMType<v8i32>; // 8 x i32 223 def llvm_v16i32_ty : LLVMType<v16i32>; // 16 x i32 224 def llvm_v32i32_ty : LLVMType<v32i32>; // 32 x i32 225 def llvm_v64i32_ty : LLVMType<v64i32>; // 64 x i32 226 227 def llvm_v1i64_ty : LLVMType<v1i64>; // 1 x i64 228 def llvm_v2i64_ty : LLVMType<v2i64>; // 2 x i64 229 def llvm_v4i64_ty : LLVMType<v4i64>; // 4 x i64 230 def llvm_v8i64_ty : LLVMType<v8i64>; // 8 x i64 231 def llvm_v16i64_ty : LLVMType<v16i64>; // 16 x i64 232 def llvm_v32i64_ty : LLVMType<v32i64>; // 32 x i64 233 234 def llvm_v1i128_ty : LLVMType<v1i128>; // 1 x i128 235 236 def llvm_v2f16_ty : LLVMType<v2f16>; // 2 x half (__fp16) 237 def llvm_v4f16_ty : LLVMType<v4f16>; // 4 x half (__fp16) 238 def llvm_v8f16_ty : LLVMType<v8f16>; // 8 x half (__fp16) 239 def llvm_v1f32_ty : LLVMType<v1f32>; // 1 x float 240 def llvm_v2f32_ty : LLVMType<v2f32>; // 2 x float 241 def llvm_v4f32_ty : LLVMType<v4f32>; // 4 x float 242 def llvm_v8f32_ty : LLVMType<v8f32>; // 8 x float 243 def llvm_v16f32_ty : LLVMType<v16f32>; // 16 x float 244 def llvm_v1f64_ty : LLVMType<v1f64>; // 1 x double 245 def llvm_v2f64_ty : LLVMType<v2f64>; // 2 x double 246 def llvm_v4f64_ty : LLVMType<v4f64>; // 4 x double 247 def llvm_v8f64_ty : LLVMType<v8f64>; // 8 x double 248 249 def llvm_vararg_ty : LLVMType<isVoid>; // this means vararg here 250 251 252 //===----------------------------------------------------------------------===// 253 // Intrinsic Definitions. 254 //===----------------------------------------------------------------------===// 255 256 // Intrinsic class - This is used to define one LLVM intrinsic. The name of the 257 // intrinsic definition should start with "int_", then match the LLVM intrinsic 258 // name with the "llvm." prefix removed, and all "."s turned into "_"s. For 259 // example, llvm.bswap.i16 -> int_bswap_i16. 260 // 261 // * RetTypes is a list containing the return types expected for the 262 // intrinsic. 263 // * ParamTypes is a list containing the parameter types expected for the 264 // intrinsic. 265 // * Properties can be set to describe the behavior of the intrinsic. 266 // 267 class SDPatternOperator; 268 class Intrinsic<list<LLVMType> ret_types, 269 list<LLVMType> param_types = [], 270 list<IntrinsicProperty> properties = [], 271 string name = ""> : SDPatternOperator { 272 string LLVMName = name; 273 string TargetPrefix = ""; // Set to a prefix for target-specific intrinsics. 274 list<LLVMType> RetTypes = ret_types; 275 list<LLVMType> ParamTypes = param_types; 276 list<IntrinsicProperty> IntrProperties = properties; 277 278 bit isTarget = 0; 279 } 280 281 /// GCCBuiltin - If this intrinsic exactly corresponds to a GCC builtin, this 282 /// specifies the name of the builtin. This provides automatic CBE and CFE 283 /// support. 284 class GCCBuiltin<string name> { 285 string GCCBuiltinName = name; 286 } 287 288 class MSBuiltin<string name> { 289 string MSBuiltinName = name; 290 } 291 292 293 //===--------------- Variable Argument Handling Intrinsics ----------------===// 294 // 295 296 def int_vastart : Intrinsic<[], [llvm_ptr_ty], [], "llvm.va_start">; 297 def int_vacopy : Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty], [], 298 "llvm.va_copy">; 299 def int_vaend : Intrinsic<[], [llvm_ptr_ty], [], "llvm.va_end">; 300 301 //===------------------- Garbage Collection Intrinsics --------------------===// 302 // 303 def int_gcroot : Intrinsic<[], 304 [llvm_ptrptr_ty, llvm_ptr_ty]>; 305 def int_gcread : Intrinsic<[llvm_ptr_ty], 306 [llvm_ptr_ty, llvm_ptrptr_ty], 307 [IntrReadMem, IntrArgMemOnly]>; 308 def int_gcwrite : Intrinsic<[], 309 [llvm_ptr_ty, llvm_ptr_ty, llvm_ptrptr_ty], 310 [IntrArgMemOnly, NoCapture<1>, NoCapture<2>]>; 311 312 //===--------------------- Code Generator Intrinsics ----------------------===// 313 // 314 def int_returnaddress : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem]>; 315 def int_addressofreturnaddress : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>; 316 def int_frameaddress : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty], [IntrNoMem]>; 317 def int_read_register : Intrinsic<[llvm_anyint_ty], [llvm_metadata_ty], 318 [IntrReadMem], "llvm.read_register">; 319 def int_write_register : Intrinsic<[], [llvm_metadata_ty, llvm_anyint_ty], 320 [], "llvm.write_register">; 321 322 // Gets the address of the local variable area. This is typically a copy of the 323 // stack, frame, or base pointer depending on the type of prologue. 324 def int_localaddress : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>; 325 326 // Escapes local variables to allow access from other functions. 327 def int_localescape : Intrinsic<[], [llvm_vararg_ty]>; 328 329 // Given a function and the localaddress of a parent frame, returns a pointer 330 // to an escaped allocation indicated by the index. 331 def int_localrecover : Intrinsic<[llvm_ptr_ty], 332 [llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty], 333 [IntrNoMem]>; 334 // Note: we treat stacksave/stackrestore as writemem because we don't otherwise 335 // model their dependencies on allocas. 336 def int_stacksave : Intrinsic<[llvm_ptr_ty]>, 337 GCCBuiltin<"__builtin_stack_save">; 338 def int_stackrestore : Intrinsic<[], [llvm_ptr_ty]>, 339 GCCBuiltin<"__builtin_stack_restore">; 340 341 def int_get_dynamic_area_offset : Intrinsic<[llvm_anyint_ty]>; 342 343 def int_thread_pointer : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>, 344 GCCBuiltin<"__builtin_thread_pointer">; 345 346 // IntrInaccessibleMemOrArgMemOnly is a little more pessimistic than strictly 347 // necessary for prefetch, however it does conveniently prevent the prefetch 348 // from being reordered overly much with respect to nearby access to the same 349 // memory while not impeding optimization. 350 def int_prefetch 351 : Intrinsic<[], [ llvm_ptr_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty ], 352 [ IntrInaccessibleMemOrArgMemOnly, ReadOnly<0>, NoCapture<0> ]>; 353 def int_pcmarker : Intrinsic<[], [llvm_i32_ty]>; 354 355 def int_readcyclecounter : Intrinsic<[llvm_i64_ty]>; 356 357 // The assume intrinsic is marked as arbitrarily writing so that proper 358 // control dependencies will be maintained. 359 def int_assume : Intrinsic<[], [llvm_i1_ty], []>; 360 361 // Stack Protector Intrinsic - The stackprotector intrinsic writes the stack 362 // guard to the correct place on the stack frame. 363 def int_stackprotector : Intrinsic<[], [llvm_ptr_ty, llvm_ptrptr_ty], []>; 364 def int_stackguard : Intrinsic<[llvm_ptr_ty], [], []>; 365 366 // A counter increment for instrumentation based profiling. 367 def int_instrprof_increment : Intrinsic<[], 368 [llvm_ptr_ty, llvm_i64_ty, 369 llvm_i32_ty, llvm_i32_ty], 370 []>; 371 372 // A counter increment with step for instrumentation based profiling. 373 def int_instrprof_increment_step : Intrinsic<[], 374 [llvm_ptr_ty, llvm_i64_ty, 375 llvm_i32_ty, llvm_i32_ty, llvm_i64_ty], 376 []>; 377 378 // A call to profile runtime for value profiling of target expressions 379 // through instrumentation based profiling. 380 def int_instrprof_value_profile : Intrinsic<[], 381 [llvm_ptr_ty, llvm_i64_ty, 382 llvm_i64_ty, llvm_i32_ty, 383 llvm_i32_ty], 384 []>; 385 386 //===------------------- Standard C Library Intrinsics --------------------===// 387 // 388 389 def int_memcpy : Intrinsic<[], 390 [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, 391 llvm_i32_ty, llvm_i1_ty], 392 [IntrArgMemOnly, NoCapture<0>, NoCapture<1>, 393 WriteOnly<0>, ReadOnly<1>]>; 394 def int_memmove : Intrinsic<[], 395 [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, 396 llvm_i32_ty, llvm_i1_ty], 397 [IntrArgMemOnly, NoCapture<0>, NoCapture<1>, 398 ReadOnly<1>]>; 399 def int_memset : Intrinsic<[], 400 [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty, 401 llvm_i32_ty, llvm_i1_ty], 402 [IntrArgMemOnly, NoCapture<0>, WriteOnly<0>]>; 403 404 // FIXME: Add version of these floating point intrinsics which allow non-default 405 // rounding modes and FP exception handling. 406 407 let IntrProperties = [IntrNoMem, IntrSpeculatable] in { 408 def int_fma : Intrinsic<[llvm_anyfloat_ty], 409 [LLVMMatchType<0>, LLVMMatchType<0>, 410 LLVMMatchType<0>]>; 411 def int_fmuladd : Intrinsic<[llvm_anyfloat_ty], 412 [LLVMMatchType<0>, LLVMMatchType<0>, 413 LLVMMatchType<0>]>; 414 415 // These functions do not read memory, but are sensitive to the 416 // rounding mode. LLVM purposely does not model changes to the FP 417 // environment so they can be treated as readnone. 418 def int_sqrt : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 419 def int_powi : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>, llvm_i32_ty]>; 420 def int_sin : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 421 def int_cos : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 422 def int_pow : Intrinsic<[llvm_anyfloat_ty], 423 [LLVMMatchType<0>, LLVMMatchType<0>]>; 424 def int_log : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 425 def int_log10: Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 426 def int_log2 : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 427 def int_exp : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 428 def int_exp2 : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 429 def int_fabs : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 430 def int_copysign : Intrinsic<[llvm_anyfloat_ty], 431 [LLVMMatchType<0>, LLVMMatchType<0>]>; 432 def int_floor : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 433 def int_ceil : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 434 def int_trunc : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 435 def int_rint : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 436 def int_nearbyint : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 437 def int_round : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>]>; 438 def int_canonicalize : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>], 439 [IntrNoMem]>; 440 } 441 442 def int_minnum : Intrinsic<[llvm_anyfloat_ty], 443 [LLVMMatchType<0>, LLVMMatchType<0>], 444 [IntrNoMem, IntrSpeculatable, Commutative] 445 >; 446 def int_maxnum : Intrinsic<[llvm_anyfloat_ty], 447 [LLVMMatchType<0>, LLVMMatchType<0>], 448 [IntrNoMem, IntrSpeculatable, Commutative] 449 >; 450 451 // NOTE: these are internal interfaces. 452 def int_setjmp : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>; 453 def int_longjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>; 454 def int_sigsetjmp : Intrinsic<[llvm_i32_ty] , [llvm_ptr_ty, llvm_i32_ty]>; 455 def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>; 456 457 // Internal interface for object size checking 458 def int_objectsize : Intrinsic<[llvm_anyint_ty], 459 [llvm_anyptr_ty, llvm_i1_ty, llvm_i1_ty], 460 [IntrNoMem, IntrSpeculatable]>, 461 GCCBuiltin<"__builtin_object_size">; 462 463 //===--------------- Constrained Floating Point Intrinsics ----------------===// 464 // 465 466 let IntrProperties = [IntrInaccessibleMemOnly] in { 467 def int_experimental_constrained_fadd : Intrinsic<[ llvm_anyfloat_ty ], 468 [ LLVMMatchType<0>, 469 LLVMMatchType<0>, 470 llvm_metadata_ty, 471 llvm_metadata_ty ]>; 472 def int_experimental_constrained_fsub : Intrinsic<[ llvm_anyfloat_ty ], 473 [ LLVMMatchType<0>, 474 LLVMMatchType<0>, 475 llvm_metadata_ty, 476 llvm_metadata_ty ]>; 477 def int_experimental_constrained_fmul : Intrinsic<[ llvm_anyfloat_ty ], 478 [ LLVMMatchType<0>, 479 LLVMMatchType<0>, 480 llvm_metadata_ty, 481 llvm_metadata_ty ]>; 482 def int_experimental_constrained_fdiv : Intrinsic<[ llvm_anyfloat_ty ], 483 [ LLVMMatchType<0>, 484 LLVMMatchType<0>, 485 llvm_metadata_ty, 486 llvm_metadata_ty ]>; 487 def int_experimental_constrained_frem : Intrinsic<[ llvm_anyfloat_ty ], 488 [ LLVMMatchType<0>, 489 LLVMMatchType<0>, 490 llvm_metadata_ty, 491 llvm_metadata_ty ]>; 492 493 // These intrinsics are sensitive to the rounding mode so we need constrained 494 // versions of each of them. When strict rounding and exception control are 495 // not required the non-constrained versions of these intrinsics should be 496 // used. 497 def int_experimental_constrained_sqrt : Intrinsic<[ llvm_anyfloat_ty ], 498 [ LLVMMatchType<0>, 499 llvm_metadata_ty, 500 llvm_metadata_ty ]>; 501 def int_experimental_constrained_powi : Intrinsic<[ llvm_anyfloat_ty ], 502 [ LLVMMatchType<0>, 503 llvm_i32_ty, 504 llvm_metadata_ty, 505 llvm_metadata_ty ]>; 506 def int_experimental_constrained_sin : Intrinsic<[ llvm_anyfloat_ty ], 507 [ LLVMMatchType<0>, 508 llvm_metadata_ty, 509 llvm_metadata_ty ]>; 510 def int_experimental_constrained_cos : Intrinsic<[ llvm_anyfloat_ty ], 511 [ LLVMMatchType<0>, 512 llvm_metadata_ty, 513 llvm_metadata_ty ]>; 514 def int_experimental_constrained_pow : Intrinsic<[ llvm_anyfloat_ty ], 515 [ LLVMMatchType<0>, 516 LLVMMatchType<0>, 517 llvm_metadata_ty, 518 llvm_metadata_ty ]>; 519 def int_experimental_constrained_log : Intrinsic<[ llvm_anyfloat_ty ], 520 [ LLVMMatchType<0>, 521 llvm_metadata_ty, 522 llvm_metadata_ty ]>; 523 def int_experimental_constrained_log10: Intrinsic<[ llvm_anyfloat_ty ], 524 [ LLVMMatchType<0>, 525 llvm_metadata_ty, 526 llvm_metadata_ty ]>; 527 def int_experimental_constrained_log2 : Intrinsic<[ llvm_anyfloat_ty ], 528 [ LLVMMatchType<0>, 529 llvm_metadata_ty, 530 llvm_metadata_ty ]>; 531 def int_experimental_constrained_exp : Intrinsic<[ llvm_anyfloat_ty ], 532 [ LLVMMatchType<0>, 533 llvm_metadata_ty, 534 llvm_metadata_ty ]>; 535 def int_experimental_constrained_exp2 : Intrinsic<[ llvm_anyfloat_ty ], 536 [ LLVMMatchType<0>, 537 llvm_metadata_ty, 538 llvm_metadata_ty ]>; 539 def int_experimental_constrained_rint : Intrinsic<[ llvm_anyfloat_ty ], 540 [ LLVMMatchType<0>, 541 llvm_metadata_ty, 542 llvm_metadata_ty ]>; 543 def int_experimental_constrained_nearbyint : Intrinsic<[ llvm_anyfloat_ty ], 544 [ LLVMMatchType<0>, 545 llvm_metadata_ty, 546 llvm_metadata_ty ]>; 547 } 548 // FIXME: Add intrinsics for fcmp, fptrunc, fpext, fptoui and fptosi. 549 // FIXME: Add intrinsics for fabs, copysign, floor, ceil, trunc and round? 550 551 552 //===------------------------- Expect Intrinsics --------------------------===// 553 // 554 def int_expect : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, 555 LLVMMatchType<0>], [IntrNoMem]>; 556 557 //===-------------------- Bit Manipulation Intrinsics ---------------------===// 558 // 559 560 // None of these intrinsics accesses memory at all. 561 let IntrProperties = [IntrNoMem, IntrSpeculatable] in { 562 def int_bswap: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>; 563 def int_ctpop: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>; 564 def int_ctlz : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>; 565 def int_cttz : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>; 566 def int_bitreverse : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>; 567 } 568 569 //===------------------------ Debugger Intrinsics -------------------------===// 570 // 571 572 // None of these intrinsics accesses memory at all...but that doesn't 573 // mean the optimizers can change them aggressively. Special handling 574 // needed in a few places. These synthetic intrinsics have no 575 // side-effects and just mark information about their operands. 576 let IntrProperties = [IntrNoMem, IntrSpeculatable] in { 577 def int_dbg_declare : Intrinsic<[], 578 [llvm_metadata_ty, 579 llvm_metadata_ty, 580 llvm_metadata_ty]>; 581 def int_dbg_value : Intrinsic<[], 582 [llvm_metadata_ty, llvm_i64_ty, 583 llvm_metadata_ty, 584 llvm_metadata_ty]>; 585 } 586 587 //===------------------ Exception Handling Intrinsics----------------------===// 588 // 589 590 // The result of eh.typeid.for depends on the enclosing function, but inside a 591 // given function it is 'const' and may be CSE'd etc. 592 def int_eh_typeid_for : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty], [IntrNoMem]>; 593 594 def int_eh_return_i32 : Intrinsic<[], [llvm_i32_ty, llvm_ptr_ty]>; 595 def int_eh_return_i64 : Intrinsic<[], [llvm_i64_ty, llvm_ptr_ty]>; 596 597 // eh.exceptionpointer returns the pointer to the exception caught by 598 // the given `catchpad`. 599 def int_eh_exceptionpointer : Intrinsic<[llvm_anyptr_ty], [llvm_token_ty], 600 [IntrNoMem]>; 601 602 // Gets the exception code from a catchpad token. Only used on some platforms. 603 def int_eh_exceptioncode : Intrinsic<[llvm_i32_ty], [llvm_token_ty], [IntrNoMem]>; 604 605 // __builtin_unwind_init is an undocumented GCC intrinsic that causes all 606 // callee-saved registers to be saved and restored (regardless of whether they 607 // are used) in the calling function. It is used by libgcc_eh. 608 def int_eh_unwind_init: Intrinsic<[]>, 609 GCCBuiltin<"__builtin_unwind_init">; 610 611 def int_eh_dwarf_cfa : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty]>; 612 613 let IntrProperties = [IntrNoMem] in { 614 def int_eh_sjlj_lsda : Intrinsic<[llvm_ptr_ty]>; 615 def int_eh_sjlj_callsite : Intrinsic<[], [llvm_i32_ty]>; 616 } 617 def int_eh_sjlj_functioncontext : Intrinsic<[], [llvm_ptr_ty]>; 618 def int_eh_sjlj_setjmp : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>; 619 def int_eh_sjlj_longjmp : Intrinsic<[], [llvm_ptr_ty], [IntrNoReturn]>; 620 def int_eh_sjlj_setup_dispatch : Intrinsic<[], []>; 621 622 //===---------------- Generic Variable Attribute Intrinsics----------------===// 623 // 624 def int_var_annotation : Intrinsic<[], 625 [llvm_ptr_ty, llvm_ptr_ty, 626 llvm_ptr_ty, llvm_i32_ty], 627 [], "llvm.var.annotation">; 628 def int_ptr_annotation : Intrinsic<[LLVMAnyPointerType<llvm_anyint_ty>], 629 [LLVMMatchType<0>, llvm_ptr_ty, llvm_ptr_ty, 630 llvm_i32_ty], 631 [], "llvm.ptr.annotation">; 632 def int_annotation : Intrinsic<[llvm_anyint_ty], 633 [LLVMMatchType<0>, llvm_ptr_ty, 634 llvm_ptr_ty, llvm_i32_ty], 635 [], "llvm.annotation">; 636 637 //===------------------------ Trampoline Intrinsics -----------------------===// 638 // 639 def int_init_trampoline : Intrinsic<[], 640 [llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty], 641 [IntrArgMemOnly, NoCapture<0>]>, 642 GCCBuiltin<"__builtin_init_trampoline">; 643 644 def int_adjust_trampoline : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], 645 [IntrReadMem, IntrArgMemOnly]>, 646 GCCBuiltin<"__builtin_adjust_trampoline">; 647 648 //===------------------------ Overflow Intrinsics -------------------------===// 649 // 650 651 // Expose the carry flag from add operations on two integrals. 652 def int_sadd_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 653 [LLVMMatchType<0>, LLVMMatchType<0>], 654 [IntrNoMem, IntrSpeculatable]>; 655 def int_uadd_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 656 [LLVMMatchType<0>, LLVMMatchType<0>], 657 [IntrNoMem, IntrSpeculatable]>; 658 659 def int_ssub_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 660 [LLVMMatchType<0>, LLVMMatchType<0>], 661 [IntrNoMem, IntrSpeculatable]>; 662 def int_usub_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 663 [LLVMMatchType<0>, LLVMMatchType<0>], 664 [IntrNoMem, IntrSpeculatable]>; 665 666 def int_smul_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 667 [LLVMMatchType<0>, LLVMMatchType<0>], 668 [IntrNoMem, IntrSpeculatable]>; 669 def int_umul_with_overflow : Intrinsic<[llvm_anyint_ty, llvm_i1_ty], 670 [LLVMMatchType<0>, LLVMMatchType<0>], 671 [IntrNoMem, IntrSpeculatable]>; 672 673 //===------------------------- Memory Use Markers -------------------------===// 674 // 675 def int_lifetime_start : Intrinsic<[], 676 [llvm_i64_ty, llvm_anyptr_ty], 677 [IntrArgMemOnly, NoCapture<1>]>; 678 def int_lifetime_end : Intrinsic<[], 679 [llvm_i64_ty, llvm_anyptr_ty], 680 [IntrArgMemOnly, NoCapture<1>]>; 681 def int_invariant_start : Intrinsic<[llvm_descriptor_ty], 682 [llvm_i64_ty, llvm_anyptr_ty], 683 [IntrArgMemOnly, NoCapture<1>]>; 684 def int_invariant_end : Intrinsic<[], 685 [llvm_descriptor_ty, llvm_i64_ty, 686 llvm_anyptr_ty], 687 [IntrArgMemOnly, NoCapture<2>]>; 688 689 // invariant.group.barrier can't be marked with 'readnone' (IntrNoMem), 690 // because it would cause CSE of two barriers with the same argument. 691 // Readonly and argmemonly says that barrier only reads its argument and 692 // it can be CSE only if memory didn't change between 2 barriers call, 693 // which is valid. 694 // The argument also can't be marked with 'returned' attribute, because 695 // it would remove barrier. 696 def int_invariant_group_barrier : Intrinsic<[llvm_ptr_ty], 697 [llvm_ptr_ty], 698 [IntrReadMem, IntrArgMemOnly]>; 699 700 //===------------------------ Stackmap Intrinsics -------------------------===// 701 // 702 def int_experimental_stackmap : Intrinsic<[], 703 [llvm_i64_ty, llvm_i32_ty, llvm_vararg_ty], 704 [Throws]>; 705 def int_experimental_patchpoint_void : Intrinsic<[], 706 [llvm_i64_ty, llvm_i32_ty, 707 llvm_ptr_ty, llvm_i32_ty, 708 llvm_vararg_ty], 709 [Throws]>; 710 def int_experimental_patchpoint_i64 : Intrinsic<[llvm_i64_ty], 711 [llvm_i64_ty, llvm_i32_ty, 712 llvm_ptr_ty, llvm_i32_ty, 713 llvm_vararg_ty], 714 [Throws]>; 715 716 717 //===------------------------ Garbage Collection Intrinsics ---------------===// 718 // These are documented in docs/Statepoint.rst 719 720 def int_experimental_gc_statepoint : Intrinsic<[llvm_token_ty], 721 [llvm_i64_ty, llvm_i32_ty, 722 llvm_anyptr_ty, llvm_i32_ty, 723 llvm_i32_ty, llvm_vararg_ty], 724 [Throws]>; 725 726 def int_experimental_gc_result : Intrinsic<[llvm_any_ty], [llvm_token_ty], 727 [IntrReadMem]>; 728 def int_experimental_gc_relocate : Intrinsic<[llvm_any_ty], 729 [llvm_token_ty, llvm_i32_ty, llvm_i32_ty], 730 [IntrReadMem]>; 731 732 //===------------------------ Coroutine Intrinsics ---------------===// 733 // These are documented in docs/Coroutines.rst 734 735 // Coroutine Structure Intrinsics. 736 737 def int_coro_id : Intrinsic<[llvm_token_ty], [llvm_i32_ty, llvm_ptr_ty, 738 llvm_ptr_ty, llvm_ptr_ty], 739 [IntrArgMemOnly, IntrReadMem, 740 ReadNone<1>, ReadOnly<2>, NoCapture<2>]>; 741 def int_coro_alloc : Intrinsic<[llvm_i1_ty], [llvm_token_ty], []>; 742 def int_coro_begin : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty], 743 [WriteOnly<1>]>; 744 745 def int_coro_free : Intrinsic<[llvm_ptr_ty], [llvm_token_ty, llvm_ptr_ty], 746 [IntrReadMem, IntrArgMemOnly, ReadOnly<1>, 747 NoCapture<1>]>; 748 def int_coro_end : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_i1_ty], []>; 749 750 def int_coro_frame : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>; 751 def int_coro_size : Intrinsic<[llvm_anyint_ty], [], [IntrNoMem]>; 752 753 def int_coro_save : Intrinsic<[llvm_token_ty], [llvm_ptr_ty], []>; 754 def int_coro_suspend : Intrinsic<[llvm_i8_ty], [llvm_token_ty, llvm_i1_ty], []>; 755 756 def int_coro_param : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_ptr_ty], 757 [IntrNoMem, ReadNone<0>, ReadNone<1>]>; 758 759 // Coroutine Manipulation Intrinsics. 760 761 def int_coro_resume : Intrinsic<[], [llvm_ptr_ty], [Throws]>; 762 def int_coro_destroy : Intrinsic<[], [llvm_ptr_ty], [Throws]>; 763 def int_coro_done : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty], 764 [IntrArgMemOnly, ReadOnly<0>, NoCapture<0>]>; 765 def int_coro_promise : Intrinsic<[llvm_ptr_ty], 766 [llvm_ptr_ty, llvm_i32_ty, llvm_i1_ty], 767 [IntrNoMem, NoCapture<0>]>; 768 769 // Coroutine Lowering Intrinsics. Used internally by coroutine passes. 770 771 def int_coro_subfn_addr : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i8_ty], 772 [IntrReadMem, IntrArgMemOnly, ReadOnly<0>, 773 NoCapture<0>]>; 774 775 ///===-------------------------- Other Intrinsics --------------------------===// 776 // 777 def int_flt_rounds : Intrinsic<[llvm_i32_ty]>, 778 GCCBuiltin<"__builtin_flt_rounds">; 779 def int_trap : Intrinsic<[], [], [IntrNoReturn]>, 780 GCCBuiltin<"__builtin_trap">; 781 def int_debugtrap : Intrinsic<[]>, 782 GCCBuiltin<"__builtin_debugtrap">; 783 784 // Support for dynamic deoptimization (or de-specialization) 785 def int_experimental_deoptimize : Intrinsic<[llvm_any_ty], [llvm_vararg_ty], 786 [Throws]>; 787 788 // Support for speculative runtime guards 789 def int_experimental_guard : Intrinsic<[], [llvm_i1_ty, llvm_vararg_ty], 790 [Throws]>; 791 792 // NOP: calls/invokes to this intrinsic are removed by codegen 793 def int_donothing : Intrinsic<[], [], [IntrNoMem]>; 794 795 // Intrisics to support half precision floating point format 796 let IntrProperties = [IntrNoMem] in { 797 def int_convert_to_fp16 : Intrinsic<[llvm_i16_ty], [llvm_anyfloat_ty]>; 798 def int_convert_from_fp16 : Intrinsic<[llvm_anyfloat_ty], [llvm_i16_ty]>; 799 } 800 801 // Clear cache intrinsic, default to ignore (ie. emit nothing) 802 // maps to void __clear_cache() on supporting platforms 803 def int_clear_cache : Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty], 804 [], "llvm.clear_cache">; 805 806 //===-------------------------- Masked Intrinsics -------------------------===// 807 // 808 def int_masked_store : Intrinsic<[], [llvm_anyvector_ty, 809 LLVMAnyPointerType<LLVMMatchType<0>>, 810 llvm_i32_ty, 811 LLVMVectorSameWidth<0, llvm_i1_ty>], 812 [IntrArgMemOnly]>; 813 814 def int_masked_load : Intrinsic<[llvm_anyvector_ty], 815 [LLVMAnyPointerType<LLVMMatchType<0>>, llvm_i32_ty, 816 LLVMVectorSameWidth<0, llvm_i1_ty>, LLVMMatchType<0>], 817 [IntrReadMem, IntrArgMemOnly]>; 818 819 def int_masked_gather: Intrinsic<[llvm_anyvector_ty], 820 [LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty, 821 LLVMVectorSameWidth<0, llvm_i1_ty>, 822 LLVMMatchType<0>], 823 [IntrReadMem]>; 824 825 def int_masked_scatter: Intrinsic<[], 826 [llvm_anyvector_ty, 827 LLVMVectorOfAnyPointersToElt<0>, llvm_i32_ty, 828 LLVMVectorSameWidth<0, llvm_i1_ty>]>; 829 830 def int_masked_expandload: Intrinsic<[llvm_anyvector_ty], 831 [LLVMPointerToElt<0>, 832 LLVMVectorSameWidth<0, llvm_i1_ty>, 833 LLVMMatchType<0>], 834 [IntrReadMem]>; 835 836 def int_masked_compressstore: Intrinsic<[], 837 [llvm_anyvector_ty, 838 LLVMPointerToElt<0>, 839 LLVMVectorSameWidth<0, llvm_i1_ty>], 840 [IntrArgMemOnly]>; 841 842 // Test whether a pointer is associated with a type metadata identifier. 843 def int_type_test : Intrinsic<[llvm_i1_ty], [llvm_ptr_ty, llvm_metadata_ty], 844 [IntrNoMem]>; 845 846 // Safely loads a function pointer from a virtual table pointer using type metadata. 847 def int_type_checked_load : Intrinsic<[llvm_ptr_ty, llvm_i1_ty], 848 [llvm_ptr_ty, llvm_i32_ty, llvm_metadata_ty], 849 [IntrNoMem]>; 850 851 def int_load_relative: Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], 852 [IntrReadMem, IntrArgMemOnly]>; 853 854 // Xray intrinsics 855 //===----------------------------------------------------------------------===// 856 // Custom event logging for x-ray. 857 // Takes a pointer to a string and the length of the string. 858 def int_xray_customevent : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], 859 [NoCapture<0>, ReadOnly<0>, IntrWriteMem]>; 860 //===----------------------------------------------------------------------===// 861 862 //===------ Memory intrinsics with element-wise atomicity guarantees ------===// 863 // 864 865 // @llvm.memcpy.element.unordered.atomic.*(dest, src, length, elementsize) 866 def int_memcpy_element_unordered_atomic 867 : Intrinsic<[], 868 [ 869 llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty 870 ], 871 [ 872 IntrArgMemOnly, NoCapture<0>, NoCapture<1>, WriteOnly<0>, 873 ReadOnly<1> 874 ]>; 875 876 //===------------------------ Reduction Intrinsics ------------------------===// 877 // 878 def int_experimental_vector_reduce_fadd : Intrinsic<[llvm_anyfloat_ty], 879 [llvm_anyfloat_ty, 880 llvm_anyvector_ty], 881 [IntrNoMem]>; 882 def int_experimental_vector_reduce_fmul : Intrinsic<[llvm_anyfloat_ty], 883 [llvm_anyfloat_ty, 884 llvm_anyvector_ty], 885 [IntrNoMem]>; 886 def int_experimental_vector_reduce_add : Intrinsic<[llvm_anyint_ty], 887 [llvm_anyvector_ty], 888 [IntrNoMem]>; 889 def int_experimental_vector_reduce_mul : Intrinsic<[llvm_anyint_ty], 890 [llvm_anyvector_ty], 891 [IntrNoMem]>; 892 def int_experimental_vector_reduce_and : Intrinsic<[llvm_anyint_ty], 893 [llvm_anyvector_ty], 894 [IntrNoMem]>; 895 def int_experimental_vector_reduce_or : Intrinsic<[llvm_anyint_ty], 896 [llvm_anyvector_ty], 897 [IntrNoMem]>; 898 def int_experimental_vector_reduce_xor : Intrinsic<[llvm_anyint_ty], 899 [llvm_anyvector_ty], 900 [IntrNoMem]>; 901 def int_experimental_vector_reduce_smax : Intrinsic<[llvm_anyint_ty], 902 [llvm_anyvector_ty], 903 [IntrNoMem]>; 904 def int_experimental_vector_reduce_smin : Intrinsic<[llvm_anyint_ty], 905 [llvm_anyvector_ty], 906 [IntrNoMem]>; 907 def int_experimental_vector_reduce_umax : Intrinsic<[llvm_anyint_ty], 908 [llvm_anyvector_ty], 909 [IntrNoMem]>; 910 def int_experimental_vector_reduce_umin : Intrinsic<[llvm_anyint_ty], 911 [llvm_anyvector_ty], 912 [IntrNoMem]>; 913 def int_experimental_vector_reduce_fmax : Intrinsic<[llvm_anyfloat_ty], 914 [llvm_anyvector_ty], 915 [IntrNoMem]>; 916 def int_experimental_vector_reduce_fmin : Intrinsic<[llvm_anyfloat_ty], 917 [llvm_anyvector_ty], 918 [IntrNoMem]>; 919 920 //===----- Intrinsics that are used to provide predicate information -----===// 921 922 def int_ssa_copy : Intrinsic<[llvm_any_ty], [LLVMMatchType<0>], 923 [IntrNoMem, Returned<0>]>; 924 //===----------------------------------------------------------------------===// 925 // Target-specific intrinsics 926 //===----------------------------------------------------------------------===// 927 928 include "llvm/IR/IntrinsicsPowerPC.td" 929 include "llvm/IR/IntrinsicsX86.td" 930 include "llvm/IR/IntrinsicsARM.td" 931 include "llvm/IR/IntrinsicsAArch64.td" 932 include "llvm/IR/IntrinsicsXCore.td" 933 include "llvm/IR/IntrinsicsHexagon.td" 934 include "llvm/IR/IntrinsicsNVVM.td" 935 include "llvm/IR/IntrinsicsMips.td" 936 include "llvm/IR/IntrinsicsAMDGPU.td" 937 include "llvm/IR/IntrinsicsBPF.td" 938 include "llvm/IR/IntrinsicsSystemZ.td" 939 include "llvm/IR/IntrinsicsWebAssembly.td" 940
