LLVM 24.0.0git
Intrinsics.cpp
Go to the documentation of this file.
1//===-- Intrinsics.cpp - Intrinsic Function Handling ------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements functions required for supporting intrinsic functions.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/IR/Intrinsics.h"
17#include "llvm/IR/Function.h"
18#include "llvm/IR/IntrinsicsAArch64.h"
19#include "llvm/IR/IntrinsicsAMDGPU.h"
20#include "llvm/IR/IntrinsicsARM.h"
21#include "llvm/IR/IntrinsicsBPF.h"
22#include "llvm/IR/IntrinsicsHexagon.h"
23#include "llvm/IR/IntrinsicsLoongArch.h"
24#include "llvm/IR/IntrinsicsMips.h"
25#include "llvm/IR/IntrinsicsPowerPC.h"
26#include "llvm/IR/IntrinsicsR600.h"
27#include "llvm/IR/IntrinsicsRISCV.h"
28#include "llvm/IR/IntrinsicsS390.h"
29#include "llvm/IR/IntrinsicsSPIRV.h"
30#include "llvm/IR/IntrinsicsVE.h"
31#include "llvm/IR/IntrinsicsX86.h"
32#include "llvm/IR/IntrinsicsXCore.h"
33#include "llvm/IR/Module.h"
35#include "llvm/IR/Type.h"
38
39using namespace llvm;
40
41// Forward declaration of static functions.
42static bool isSignatureValid(FunctionType *FTy,
44 unsigned NumArgs, bool IsVarArg,
45 SmallVectorImpl<Type *> &OverloadTys,
46 raw_ostream &OS,
47 unsigned NumMissingTrailingParams = 0);
48
49/// Table of string intrinsic names indexed by enum value.
50#define GET_INTRINSIC_NAME_TABLE
51#include "llvm/IR/IntrinsicImpl.inc"
52
53/// Table of required target features indexed by enum value.
54#define GET_INTRINSIC_TARGET_FEATURES_TABLE
55#include "llvm/IR/IntrinsicImpl.inc"
56
58 assert(id < num_intrinsics && "Invalid intrinsic ID!");
59 return IntrinsicNameTable[IntrinsicNameOffsetTable[id]];
60}
61
63 assert(id < num_intrinsics && "invalid intrinsic ID!");
64 return IntrinsicTargetFeaturesTable[IntrinsicTargetFeaturesOffsetTable[id]];
65}
66
68 assert(id < num_intrinsics && "Invalid intrinsic ID!");
70 "This version of getName does not support overloading");
71 return getBaseName(id);
72}
73
74/// Returns a stable mangling for the type specified for use in the name
75/// mangling scheme used by 'any' types in intrinsic signatures. The mangling
76/// of named types is simply their name. Manglings for unnamed types consist
77/// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
78/// combined with the mangling of their component types. A vararg function
79/// type will have a suffix of 'vararg'. Since function types can contain
80/// other function types, we close a function type mangling with suffix 'f'
81/// which can't be confused with it's prefix. This ensures we don't have
82/// collisions between two unrelated function types. Otherwise, you might
83/// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
84/// The HasUnnamedType boolean is set if an unnamed type was encountered,
85/// indicating that extra care must be taken to ensure a unique name.
86static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) {
87 std::string Result;
88 if (PointerType *PTyp = dyn_cast<PointerType>(Ty)) {
89 Result += "p" + utostr(PTyp->getAddressSpace());
90 } else if (ArrayType *ATyp = dyn_cast<ArrayType>(Ty)) {
91 Result += "a" + utostr(ATyp->getNumElements()) +
92 getMangledTypeStr(ATyp->getElementType(), HasUnnamedType);
93 } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
94 if (!STyp->isLiteral()) {
95 Result += "s_";
96 if (STyp->hasName())
97 Result += STyp->getName();
98 else
99 HasUnnamedType = true;
100 } else {
101 Result += "sl_";
102 for (auto *Elem : STyp->elements())
103 Result += getMangledTypeStr(Elem, HasUnnamedType);
104 }
105 // Ensure nested structs are distinguishable.
106 Result += "s";
107 } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
108 Result += "f_" + getMangledTypeStr(FT->getReturnType(), HasUnnamedType);
109 for (size_t i = 0; i < FT->getNumParams(); i++)
110 Result += getMangledTypeStr(FT->getParamType(i), HasUnnamedType);
111 if (FT->isVarArg())
112 Result += "vararg";
113 // Ensure nested function types are distinguishable.
114 Result += "f";
115 } else if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
116 ElementCount EC = VTy->getElementCount();
117 if (EC.isScalable())
118 Result += "nx";
119 Result += "v" + utostr(EC.getKnownMinValue()) +
120 getMangledTypeStr(VTy->getElementType(), HasUnnamedType);
121 } else if (TargetExtType *TETy = dyn_cast<TargetExtType>(Ty)) {
122 Result += "t";
123 Result += TETy->getName();
124 for (Type *ParamTy : TETy->type_params())
125 Result += "_" + getMangledTypeStr(ParamTy, HasUnnamedType);
126 for (unsigned IntParam : TETy->int_params())
127 Result += "_" + utostr(IntParam);
128 // Ensure nested target extension types are distinguishable.
129 Result += "t";
130 } else if (Ty) {
131 switch (Ty->getTypeID()) {
132 default:
133 llvm_unreachable("Unhandled type");
134 case Type::VoidTyID:
135 Result += "isVoid";
136 break;
138 Result += "Metadata";
139 break;
140 case Type::HalfTyID:
141 Result += "f16";
142 break;
143 case Type::BFloatTyID:
144 Result += "bf16";
145 break;
146 case Type::FloatTyID:
147 Result += "f32";
148 break;
149 case Type::DoubleTyID:
150 Result += "f64";
151 break;
153 Result += "f80";
154 break;
155 case Type::FP128TyID:
156 Result += "f128";
157 break;
159 Result += "ppcf128";
160 break;
162 Result += "x86amx";
163 break;
165 Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
166 break;
167 case Type::ByteTyID:
168 Result += "b" + utostr(cast<ByteType>(Ty)->getBitWidth());
169 break;
170 }
171 }
172 return Result;
173}
174
176 ArrayRef<Type *> OverloadTys, Module *M,
177 FunctionType *FT,
178 bool EarlyModuleCheck) {
179
180 assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!");
181 assert((OverloadTys.empty() || Intrinsic::isOverloaded(Id)) &&
182 "This version of getName is for overloaded intrinsics only");
183 (void)EarlyModuleCheck;
184 assert((!EarlyModuleCheck || M ||
185 !any_of(OverloadTys, llvm::IsaPred<PointerType>)) &&
186 "Intrinsic overloading on pointer types need to provide a Module");
187 bool HasUnnamedType = false;
188 std::string Result(Intrinsic::getBaseName(Id));
189 for (Type *Ty : OverloadTys)
190 Result += "." + getMangledTypeStr(Ty, HasUnnamedType);
191 if (HasUnnamedType) {
192 assert(M && "unnamed types need a module");
193 if (!FT)
194 FT = Intrinsic::getType(M->getContext(), Id, OverloadTys);
195 else
196 assert(FT == Intrinsic::getType(M->getContext(), Id, OverloadTys) &&
197 "Provided FunctionType must match arguments");
198 return M->getUniqueIntrinsicName(Result, Id, FT);
199 }
200 return Result;
201}
202
203std::string Intrinsic::getName(ID Id, ArrayRef<Type *> OverloadTys, Module *M,
204 FunctionType *FT) {
205 assert(M && "We need to have a Module");
206 return getIntrinsicNameImpl(Id, OverloadTys, M, FT, true);
207}
208
210 ArrayRef<Type *> OverloadTys) {
211 return getIntrinsicNameImpl(Id, OverloadTys, nullptr, nullptr, false);
212}
213
214/// IIT_Info - These are enumerators that describe the entries returned by the
215/// getIntrinsicInfoTableEntries function.
216///
217/// Defined in Intrinsics.td.
219#define GET_INTRINSIC_IITINFO
220#include "llvm/IR/IntrinsicImpl.inc"
221};
222
223static_assert(IIT_Done == 0, "IIT_Done expected to be 0");
224
225static void
226DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
228 using namespace Intrinsic;
229
230 auto IsScalableVector = [&]() {
231 IIT_Info NextInfo = IIT_Info(Infos[NextElt]);
232 if (NextInfo != IIT_SCALABLE_VEC)
233 return false;
234 // Eat the IIT_SCALABLE_VEC token.
235 ++NextElt;
236 return true;
237 };
238
239 IIT_Info Info = IIT_Info(Infos[NextElt++]);
240
241 switch (Info) {
242 case IIT_Done:
243 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
244 return;
245 case IIT_VARARG:
246 OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
247 return;
248 case IIT_MMX:
249 OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
250 return;
251 case IIT_AMX:
252 OutputTable.push_back(IITDescriptor::get(IITDescriptor::AMX, 0));
253 return;
254 case IIT_TOKEN:
255 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
256 return;
257 case IIT_METADATA:
258 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
259 return;
260 case IIT_F16:
261 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
262 return;
263 case IIT_BF16:
264 OutputTable.push_back(IITDescriptor::get(IITDescriptor::BFloat, 0));
265 return;
266 case IIT_F32:
267 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
268 return;
269 case IIT_F64:
270 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
271 return;
272 case IIT_F128:
273 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
274 return;
275 case IIT_PPCF128:
276 OutputTable.push_back(IITDescriptor::get(IITDescriptor::PPCQuad, 0));
277 return;
278 case IIT_I1:
279 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
280 return;
281 case IIT_I2:
282 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 2));
283 return;
284 case IIT_I4:
285 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 4));
286 return;
287 case IIT_AARCH64_SVCOUNT:
288 OutputTable.push_back(IITDescriptor::get(IITDescriptor::AArch64Svcount, 0));
289 return;
290 case IIT_I8:
291 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
292 return;
293 case IIT_I16:
294 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 16));
295 return;
296 case IIT_I32:
297 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
298 return;
299 case IIT_I64:
300 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
301 return;
302 case IIT_I128:
303 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
304 return;
305 case IIT_V1:
306 OutputTable.push_back(IITDescriptor::getVector(1, IsScalableVector()));
307 DecodeIITType(NextElt, Infos, OutputTable);
308 return;
309 case IIT_V2:
310 OutputTable.push_back(IITDescriptor::getVector(2, IsScalableVector()));
311 DecodeIITType(NextElt, Infos, OutputTable);
312 return;
313 case IIT_V3:
314 OutputTable.push_back(IITDescriptor::getVector(3, IsScalableVector()));
315 DecodeIITType(NextElt, Infos, OutputTable);
316 return;
317 case IIT_V4:
318 OutputTable.push_back(IITDescriptor::getVector(4, IsScalableVector()));
319 DecodeIITType(NextElt, Infos, OutputTable);
320 return;
321 case IIT_V6:
322 OutputTable.push_back(IITDescriptor::getVector(6, IsScalableVector()));
323 DecodeIITType(NextElt, Infos, OutputTable);
324 return;
325 case IIT_V8:
326 OutputTable.push_back(IITDescriptor::getVector(8, IsScalableVector()));
327 DecodeIITType(NextElt, Infos, OutputTable);
328 return;
329 case IIT_V10:
330 OutputTable.push_back(IITDescriptor::getVector(10, IsScalableVector()));
331 DecodeIITType(NextElt, Infos, OutputTable);
332 return;
333 case IIT_V16:
334 OutputTable.push_back(IITDescriptor::getVector(16, IsScalableVector()));
335 DecodeIITType(NextElt, Infos, OutputTable);
336 return;
337 case IIT_V32:
338 OutputTable.push_back(IITDescriptor::getVector(32, IsScalableVector()));
339 DecodeIITType(NextElt, Infos, OutputTable);
340 return;
341 case IIT_V64:
342 OutputTable.push_back(IITDescriptor::getVector(64, IsScalableVector()));
343 DecodeIITType(NextElt, Infos, OutputTable);
344 return;
345 case IIT_V128:
346 OutputTable.push_back(IITDescriptor::getVector(128, IsScalableVector()));
347 DecodeIITType(NextElt, Infos, OutputTable);
348 return;
349 case IIT_V256:
350 OutputTable.push_back(IITDescriptor::getVector(256, IsScalableVector()));
351 DecodeIITType(NextElt, Infos, OutputTable);
352 return;
353 case IIT_V512:
354 OutputTable.push_back(IITDescriptor::getVector(512, IsScalableVector()));
355 DecodeIITType(NextElt, Infos, OutputTable);
356 return;
357 case IIT_V1024:
358 OutputTable.push_back(IITDescriptor::getVector(1024, IsScalableVector()));
359 DecodeIITType(NextElt, Infos, OutputTable);
360 return;
361 case IIT_V2048:
362 OutputTable.push_back(IITDescriptor::getVector(2048, IsScalableVector()));
363 DecodeIITType(NextElt, Infos, OutputTable);
364 return;
365 case IIT_V4096:
366 OutputTable.push_back(IITDescriptor::getVector(4096, IsScalableVector()));
367 DecodeIITType(NextElt, Infos, OutputTable);
368 return;
369 case IIT_EXTERNREF:
370 OutputTable.push_back(IITDescriptor::get(IITDescriptor::WasmExternref, 0));
371 return;
372 case IIT_FUNCREF:
373 OutputTable.push_back(IITDescriptor::get(IITDescriptor::WasmFuncref, 0));
374 return;
375 case IIT_PTR:
376 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
377 return;
378 case IIT_PTR_AS: // pointer with address space.
379 OutputTable.push_back(
380 IITDescriptor::get(IITDescriptor::Pointer, Infos[NextElt++]));
381 return;
382 case IIT_ANY: {
383 unsigned OverloadIndex = Infos[NextElt++];
384 unsigned ArgKindEnums = Infos[NextElt++];
385 unsigned Packed = (ArgKindEnums << 8) | OverloadIndex;
386 OutputTable.push_back(
387 IITDescriptor::get(IITDescriptor::Overloaded, Packed));
388 return;
389 }
390 case IIT_MATCH: {
391 unsigned OverloadIndex = Infos[NextElt++];
392 OutputTable.push_back(
393 IITDescriptor::get(IITDescriptor::Match, OverloadIndex));
394 return;
395 }
396 case IIT_EXTEND_ARG: {
397 unsigned OverloadIndex = Infos[NextElt++];
398 OutputTable.push_back(
399 IITDescriptor::get(IITDescriptor::Extend, OverloadIndex));
400 return;
401 }
402 case IIT_TRUNC_ARG: {
403 unsigned OverloadIndex = Infos[NextElt++];
404 OutputTable.push_back(
405 IITDescriptor::get(IITDescriptor::Trunc, OverloadIndex));
406 return;
407 }
408 case IIT_ONE_NTH_ELTS_VEC_ARG: {
409 unsigned short OverloadIndex = Infos[NextElt++];
410 unsigned short N = Infos[NextElt++];
411 OutputTable.push_back(IITDescriptor::get(IITDescriptor::OneNthEltsVec,
412 /*Hi=*/N, /*Lo=*/OverloadIndex));
413 return;
414 }
415 case IIT_SAME_VEC_WIDTH_ARG: {
416 unsigned OverloadIndex = Infos[NextElt++];
417 OutputTable.push_back(
418 IITDescriptor::get(IITDescriptor::SameVecWidth, OverloadIndex));
419 // IIT_SAME_VEC_WIDTH_ARG entry is followed by the element type.
420 DecodeIITType(NextElt, Infos, OutputTable);
421 return;
422 }
423 case IIT_ANY_SAME_VEC_WIDTH_ARG: {
424 unsigned short OverloadIndex = Infos[NextElt++];
425 unsigned short RefOverloadIndex = Infos[NextElt++];
426 unsigned short ElementConstraint = Infos[NextElt++];
427 // Pack the element constraint into bits [4:7], leaving the low 4 bits for
428 // this type's overload index.
429 OutputTable.push_back(IITDescriptor::get(
430 IITDescriptor::AnySameVecWidth, /*Hi=*/RefOverloadIndex,
431 /*Lo=*/ElementConstraint << 4 | OverloadIndex));
432 return;
433 }
434 case IIT_STRUCT: {
435 unsigned StructElts = Infos[NextElt++] + 2;
436
437 OutputTable.push_back(
438 IITDescriptor::get(IITDescriptor::Struct, StructElts));
439
440 for (unsigned i = 0; i != StructElts; ++i)
441 DecodeIITType(NextElt, Infos, OutputTable);
442 return;
443 }
444 case IIT_SUBDIVIDE2_ARG: {
445 unsigned OverloadIndex = Infos[NextElt++];
446 OutputTable.push_back(
447 IITDescriptor::get(IITDescriptor::Subdivide2, OverloadIndex));
448 return;
449 }
450 case IIT_SUBDIVIDE4_ARG: {
451 unsigned OverloadIndex = Infos[NextElt++];
452 OutputTable.push_back(
453 IITDescriptor::get(IITDescriptor::Subdivide4, OverloadIndex));
454 return;
455 }
456 case IIT_VEC_ELEMENT: {
457 unsigned OverloadIndex = Infos[NextElt++];
458 OutputTable.push_back(
459 IITDescriptor::get(IITDescriptor::VecElement, OverloadIndex));
460 return;
461 }
462 case IIT_VEC_OF_BITCASTS_TO_INT: {
463 unsigned OverloadIndex = Infos[NextElt++];
464 OutputTable.push_back(
465 IITDescriptor::get(IITDescriptor::VecOfBitcastsToInt, OverloadIndex));
466 return;
467 }
468 case IIT_SCALABLE_VEC:
469 break;
470 }
471 llvm_unreachable("unhandled");
472}
473
474#define GET_INTRINSIC_GENERATOR_GLOBAL
475#include "llvm/IR/IntrinsicImpl.inc"
476
477std::tuple<ArrayRef<Intrinsic::IITDescriptor>, unsigned, bool>
480 // Note that `FixedEncodingTy` is defined in IntrinsicImpl.inc and can be
481 // uint16_t or uint32_t based on the the value of `Use16BitFixedEncoding` in
482 // IntrinsicEmitter.cpp.
483 constexpr unsigned FixedEncodingBits = sizeof(FixedEncodingTy) * CHAR_BIT;
484 constexpr unsigned MSBPosition = FixedEncodingBits - 1;
485 // Mask with all bits 1 except the most significant bit.
486 constexpr unsigned Mask = (1U << MSBPosition) - 1;
487
488 FixedEncodingTy TableVal = IIT_Table[id - 1];
489
490 // Array to hold the inlined fixed encoding values expanded from nibbles to
491 // bytes. Its size can be be atmost FixedEncodingBits / 4 i.e., number
492 // of nibbles that can fit in `FixedEncodingTy` + 1 (the IIT_Done terminator
493 // that is not explicitly encoded). Note that if there are trailing 0 bytes
494 // in the encoding (for example, payload following one of the IIT tokens),
495 // the inlined encoding does not encode the actual size of the encoding, so
496 // we always assume its size of this maximum length possible, followed by the
497 // IIT_Done terminator token (whose value is 0).
498 unsigned char IITValues[FixedEncodingBits / 4 + 1] = {0};
499
500 ArrayRef<unsigned char> IITEntries;
501 unsigned NextElt = 0;
502 // Check to see if the intrinsic's type was inlined in the fixed encoding
503 // table.
504 if (TableVal >> MSBPosition) {
505 // This is an offset into the IIT_LongEncodingTable.
506 IITEntries = IIT_LongEncodingTable;
507
508 // Strip sentinel bit.
509 NextElt = TableVal & Mask;
510 } else {
511 // If the entry was encoded into a single word in the table itself, decode
512 // it from an array of nibbles to an array of bytes.
513 do {
514 IITValues[NextElt++] = TableVal & 0xF;
515 TableVal >>= 4;
516 } while (TableVal);
517
518 IITEntries = IITValues;
519 NextElt = 0;
520 }
521
522 // Okay, decode the table into the output vector of IITDescriptors.
523 DecodeIITType(NextElt, IITEntries, T);
524 unsigned NumArgs = 0;
525 while (IITEntries[NextElt] != IIT_Done) {
526 DecodeIITType(NextElt, IITEntries, T);
527 ++NumArgs;
528 }
529
531
532 bool IsVarArg = false;
533 if (TableRef.back().Kind == Intrinsic::IITDescriptor::VarArg) {
534 IsVarArg = true;
535 TableRef.consume_back();
536 --NumArgs;
537 }
538 return {TableRef, NumArgs, IsVarArg};
539}
540
542 ArrayRef<Type *> OverloadTys,
543 LLVMContext &Context) {
544 using namespace Intrinsic;
545
546 IITDescriptor D = Infos.consume_front();
547
548 switch (D.Kind) {
549 case IITDescriptor::Void:
550 return Type::getVoidTy(Context);
551 case IITDescriptor::MMX:
553 case IITDescriptor::AMX:
554 return Type::getX86_AMXTy(Context);
555 case IITDescriptor::Token:
556 return Type::getTokenTy(Context);
557 case IITDescriptor::Metadata:
558 return Type::getMetadataTy(Context);
559 case IITDescriptor::Half:
560 return Type::getHalfTy(Context);
561 case IITDescriptor::BFloat:
562 return Type::getBFloatTy(Context);
563 case IITDescriptor::Float:
564 return Type::getFloatTy(Context);
565 case IITDescriptor::Double:
566 return Type::getDoubleTy(Context);
567 case IITDescriptor::Quad:
568 return Type::getFP128Ty(Context);
569 case IITDescriptor::PPCQuad:
570 return Type::getPPC_FP128Ty(Context);
571 case IITDescriptor::AArch64Svcount:
572 return TargetExtType::get(Context, "aarch64.svcount");
573 case IITDescriptor::WasmExternref:
574 return TargetExtType::get(Context, "wasm.externref");
575 case IITDescriptor::WasmFuncref:
576 return TargetExtType::get(Context, "wasm.funcref");
577 case IITDescriptor::Integer:
578 return IntegerType::get(Context, D.IntegerWidth);
579 case IITDescriptor::Vector:
580 return VectorType::get(DecodeFixedType(Infos, OverloadTys, Context),
581 D.VectorWidth);
582 case IITDescriptor::Pointer:
583 return PointerType::get(Context, D.PointerAddressSpace);
584 case IITDescriptor::Struct: {
586 for (unsigned i = 0, e = D.StructNumElements; i != e; ++i)
587 Elts.push_back(DecodeFixedType(Infos, OverloadTys, Context));
588 return StructType::get(Context, Elts);
589 }
590 // For any overload type or partially dependent type, substitute it with the
591 // corresponding concrete type from OverloadTys. Additionally, do the same
592 // for the fully dependent type that matches an overload type.
593 case IITDescriptor::Overloaded:
594 case IITDescriptor::AnySameVecWidth:
595 case IITDescriptor::Match:
596 return OverloadTys[D.getOverloadIndex()];
597 case IITDescriptor::Extend:
598 return OverloadTys[D.getOverloadIndex()]->getExtendedType();
599 case IITDescriptor::Trunc:
600 return OverloadTys[D.getOverloadIndex()]->getTruncatedType();
601 case IITDescriptor::Subdivide2:
602 case IITDescriptor::Subdivide4: {
603 Type *Ty = OverloadTys[D.getOverloadIndex()];
605 assert(VTy && "Expected overload type to be a Vector Type");
606 int SubDivs = D.Kind == IITDescriptor::Subdivide2 ? 1 : 2;
607 return VectorType::getSubdividedVectorType(VTy, SubDivs);
608 }
609 case IITDescriptor::OneNthEltsVec:
611 cast<VectorType>(OverloadTys[D.getOverloadIndex()]),
612 D.getVectorDivisor());
613 case IITDescriptor::SameVecWidth: {
614 Type *EltTy = DecodeFixedType(Infos, OverloadTys, Context);
615 Type *Ty = OverloadTys[D.getOverloadIndex()];
616 if (auto *VTy = dyn_cast<VectorType>(Ty))
617 return VectorType::get(EltTy, VTy->getElementCount());
618 return EltTy;
619 }
620 case IITDescriptor::VecElement: {
621 Type *Ty = OverloadTys[D.getOverloadIndex()];
622 if (VectorType *VTy = dyn_cast<VectorType>(Ty))
623 return VTy->getElementType();
624 llvm_unreachable("Expected overload type to be a Vector Type");
625 }
626 case IITDescriptor::VecOfBitcastsToInt: {
627 Type *Ty = OverloadTys[D.getOverloadIndex()];
629 assert(VTy && "Expected overload type to be a Vector Type");
630 return VectorType::getInteger(VTy);
631 }
632 case IITDescriptor::VarArg:
633 // VarArg token should be consumed by `getIntrinsicInfoTableEntries`, so we
634 // should never see it here.
635 llvm_unreachable("IITDescriptor::VarArg not expected");
636 }
637 llvm_unreachable("unhandled");
638}
639
641 ArrayRef<Type *> OverloadTys) {
643 auto [TableRef, _, IsVarArg] = getIntrinsicInfoTableEntries(id, Table);
644
645 Type *ResultTy = DecodeFixedType(TableRef, OverloadTys, Context);
646
648 while (!TableRef.empty())
649 ArgTys.push_back(DecodeFixedType(TableRef, OverloadTys, Context));
650 return FunctionType::get(ResultTy, ArgTys, IsVarArg);
651}
652
654#define GET_INTRINSIC_OVERLOAD_TABLE
655#include "llvm/IR/IntrinsicImpl.inc"
656}
657
659#define GET_INTRINSIC_SCALARIZABLE_TABLE
660#include "llvm/IR/IntrinsicImpl.inc"
661}
662
664#define GET_INTRINSIC_PRETTY_PRINT_TABLE
665#include "llvm/IR/IntrinsicImpl.inc"
666}
667
668/// Table of per-target intrinsic name tables.
669#define GET_INTRINSIC_TARGET_DATA
670#include "llvm/IR/IntrinsicImpl.inc"
671
673 return IID > TargetInfos[0].Count;
674}
675
676/// Looks up Name in NameTable via binary search. NameTable must be sorted
677/// and all entries must start with "llvm.". If NameTable contains an exact
678/// match for Name or a prefix of Name followed by a dot, its index in
679/// NameTable is returned. Otherwise, -1 is returned.
681 StringRef Name, StringRef Target = "") {
682 assert(Name.starts_with("llvm.") && "Unexpected intrinsic prefix");
683 assert(Name.drop_front(5).starts_with(Target) && "Unexpected target");
684
685 // Do successive binary searches of the dotted name components. For
686 // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
687 // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
688 // "llvm.gc.experimental.statepoint", and then we will stop as the range is
689 // size 1. During the search, we can skip the prefix that we already know is
690 // identical. By using strncmp we consider names with differing suffixes to
691 // be part of the equal range.
692 size_t CmpEnd = 4; // Skip the "llvm" component.
693 if (!Target.empty())
694 CmpEnd += 1 + Target.size(); // skip the .target component.
695
696 const unsigned *Low = NameOffsetTable.begin();
697 const unsigned *High = NameOffsetTable.end();
698 const unsigned *LastLow = Low;
699 while (CmpEnd < Name.size() && High - Low > 0) {
700 size_t CmpStart = CmpEnd;
701 CmpEnd = Name.find('.', CmpStart + 1);
702 CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
703 auto Cmp = [CmpStart, CmpEnd](auto LHS, auto RHS) {
704 // `equal_range` requires the comparison to work with either side being an
705 // offset or the value. Detect which kind each side is to set up the
706 // compared strings.
707 const char *LHSStr;
708 if constexpr (std::is_integral_v<decltype(LHS)>)
709 LHSStr = IntrinsicNameTable.getCString(LHS);
710 else
711 LHSStr = LHS;
712
713 const char *RHSStr;
714 if constexpr (std::is_integral_v<decltype(RHS)>)
715 RHSStr = IntrinsicNameTable.getCString(RHS);
716 else
717 RHSStr = RHS;
718
719 return strncmp(LHSStr + CmpStart, RHSStr + CmpStart, CmpEnd - CmpStart) <
720 0;
721 };
722 LastLow = Low;
723 std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
724 }
725 if (High - Low > 0)
726 LastLow = Low;
727
728 if (LastLow == NameOffsetTable.end())
729 return -1;
730 StringRef NameFound = IntrinsicNameTable[*LastLow];
731 if (Name == NameFound ||
732 (Name.starts_with(NameFound) && Name[NameFound.size()] == '.'))
733 return LastLow - NameOffsetTable.begin();
734 return -1;
735}
736
737/// Find the segment of \c IntrinsicNameOffsetTable for intrinsics with the same
738/// target as \c Name, or the generic table if \c Name is not target specific.
739///
740/// Returns the relevant slice of \c IntrinsicNameOffsetTable and the target
741/// name.
742static std::pair<ArrayRef<unsigned>, StringRef>
744 assert(Name.starts_with("llvm."));
745
746 ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
747 // Drop "llvm." and take the first dotted component. That will be the target
748 // if this is target specific.
749 StringRef Target = Name.drop_front(5).split('.').first;
750 auto It = partition_point(
751 Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
752 // We've either found the target or just fall back to the generic set, which
753 // is always first.
754 const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
755 return {ArrayRef(&IntrinsicNameOffsetTable[1] + TI.Offset, TI.Count),
756 TI.Name};
757}
758
759/// This does the actual lookup of an intrinsic ID which matches the given
760/// function name.
762 auto [NameOffsetTable, Target] = findTargetSubtable(Name);
763 int Idx = lookupLLVMIntrinsicByName(NameOffsetTable, Name, Target);
764 if (Idx == -1)
766
767 // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
768 // an index into a sub-table.
769 int Adjust = NameOffsetTable.data() - IntrinsicNameOffsetTable;
770 Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
771
772 // If the intrinsic is not overloaded, require an exact match. If it is
773 // overloaded, require either exact or prefix match.
774 const auto MatchSize = IntrinsicNameTable[NameOffsetTable[Idx]].size();
775 assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
776 bool IsExactMatch = Name.size() == MatchSize;
777 return IsExactMatch || Intrinsic::isOverloaded(ID) ? ID
779}
780
781/// This defines the "Intrinsic::getAttributes(ID id)" method.
782#define GET_INTRINSIC_ATTRIBUTES
783#include "llvm/IR/IntrinsicImpl.inc"
784
785static Function *
787 ArrayRef<Type *> OverloadTys,
788 FunctionType *FT) {
789 std::string Name = OverloadTys.empty()
790 ? Intrinsic::getName(id).str()
791 : Intrinsic::getName(id, OverloadTys, M, FT);
792 Function *F = cast<Function>(M->getOrInsertFunction(Name, FT).getCallee());
793 if (F->getFunctionType() == FT)
794 return F;
795
796 // It's possible that a declaration for this intrinsic already exists with an
797 // incorrect signature, if the signature has changed, but this particular
798 // declaration has not been auto-upgraded yet. In that case, rename the
799 // invalid declaration and insert a new one with the correct signature. The
800 // invalid declaration will get upgraded later.
801 F->setName(F->getName() + ".invalid");
802 return cast<Function>(M->getOrInsertFunction(Name, FT).getCallee());
803}
804
806 ArrayRef<Type *> OverloadTys) {
807 // There can never be multiple globals with the same name of different types,
808 // because intrinsics must be a specific type.
809 FunctionType *FT = getType(M->getContext(), id, OverloadTys);
810 return getOrInsertIntrinsicDeclarationImpl(M, id, OverloadTys, FT);
811}
812
814 ArrayRef<Type *> ArgTys) {
815 // If the intrinsic is not overloaded, use the non-overloaded version.
817 return getOrInsertDeclaration(M, id);
818
819 // Get the intrinsic signature metadata.
821 auto [TableRef, NumArgs, IsVarArg] = getIntrinsicInfoTableEntries(id, Table);
822 FunctionType *FTy = FunctionType::get(RetTy, ArgTys, IsVarArg);
823
824 // Automatically determine the overloaded types.
825 SmallVector<Type *, 4> OverloadTys;
826 [[maybe_unused]] bool IsValid = ::isSignatureValid(
827 FTy, TableRef, NumArgs, IsVarArg, OverloadTys, nulls());
828 assert(IsValid && "intrinsic signature mismatch");
829 return getOrInsertIntrinsicDeclarationImpl(M, id, OverloadTys, FTy);
830}
831
833 return M->getFunction(getName(id));
834}
835
837 ArrayRef<Type *> OverloadTys,
838 FunctionType *FT) {
839 return M->getFunction(getName(id, OverloadTys, M, FT));
840}
841
842// This defines the "Intrinsic::getIntrinsicForClangBuiltin()" method.
843#define GET_LLVM_INTRINSIC_FOR_CLANG_BUILTIN
844#include "llvm/IR/IntrinsicImpl.inc"
845
846// This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
847#define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
848#include "llvm/IR/IntrinsicImpl.inc"
849
851 switch (QID) {
852#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
853 case Intrinsic::INTRINSIC:
854#include "llvm/IR/ConstrainedOps.def"
855#undef INSTRUCTION
856 return true;
857 default:
858 return false;
859 }
860}
861
863 switch (QID) {
864#define INSTRUCTION(NAME, NARG, ROUND_MODE, INTRINSIC) \
865 case Intrinsic::INTRINSIC: \
866 return ROUND_MODE == 1;
867#include "llvm/IR/ConstrainedOps.def"
868#undef INSTRUCTION
869 default:
870 return false;
871 }
872}
873
874// This class represents a position in the intrinsic's type signature and is
875// used to generate error messages in `matchIntrinsicType`. The printed position
876// can be of the following forms:
877//
878// return
879// return struct element 3
880// return vector element
881// return struct element 3 vector element
882// argument 3
883// argument 3 vector element
884//
885// To support deferred checks also being able to generate these error messages
886// we need to encode the position compactly so that it can be stashed into
887// DeferredIntrinsicMatchInfo below (without materializing it into a string).
888// The class below serves that purpose.
889//
890namespace {
891struct MatchPosition {
892 uint16_t IsRet : 1;
893 uint16_t Num : 15; // Argument number (when IsRet = false).
894 struct Index {
895 uint16_t IsStruct : 1; // If true, this is a struct element with element
896 // index `Num`, else its a vector element.
897 uint16_t Num : 15; // Struct element index.
898 };
899 // We expect this to be just 2 levels deep, since nested structs are not
900 // supported.
901 static constexpr unsigned INDEX_TABLE_SIZE = 2;
902 Index Indices[INDEX_TABLE_SIZE];
903 uint16_t NumIndices = 0;
904
905 void pop_index() {
906 assert(NumIndices > 0 && "cannot pop from empty indices");
907 --NumIndices;
908 }
909
910 void push_struct_element(unsigned ElementNum) {
911 assert(NumIndices < INDEX_TABLE_SIZE && "index table overflow");
912 assert(isInt<15>(ElementNum) && "Element index overflow");
913 Indices[NumIndices].IsStruct = true;
914 Indices[NumIndices++].Num = ElementNum;
915 }
916
917 void push_vector_element() {
918 assert(NumIndices < INDEX_TABLE_SIZE && "index table overflow");
919 Indices[NumIndices].IsStruct = false;
920 Indices[NumIndices++].Num = 0;
921 }
922};
923} // namespace
924
925static raw_ostream &operator<<(raw_ostream &OS, const MatchPosition &Pos) {
926 OS << "intrinsic ";
927
928 if (Pos.IsRet)
929 OS << "return";
930 else
931 OS << "argument " << Pos.Num;
932
933 for (const MatchPosition::Index &Idx :
934 ArrayRef(Pos.Indices).take_front(Pos.NumIndices)) {
935 if (Idx.IsStruct)
936 OS << " struct element " << Idx.Num;
937 else
938 OS << " vector element";
939 }
940 return OS;
941}
942
944 std::tuple<Type *, ArrayRef<Intrinsic::IITDescriptor>, MatchPosition>;
945
946/// Check whether \p Ty satisfies the given element constraint \p EC and return
947/// a description of the expected element kind for error messages.
948static std::pair<bool, StringRef>
950 Intrinsic::IITDescriptor::AnyKindElementConstraint EC) {
951 using namespace Intrinsic;
952
953 Type *EltTy = Ty->getScalarType();
954 switch (EC) {
955 case IITDescriptor::EC_None:
956 return {true, "value"};
957 case IITDescriptor::EC_Integer:
958 return {EltTy->isIntegerTy(), "integer"};
959 case IITDescriptor::EC_Float:
960 return {EltTy->isFloatingPointTy(), "fp"};
961 case IITDescriptor::EC_Pointer:
962 return {EltTy->isPointerTy(), "pointer"};
963 }
964 llvm_unreachable("invalid element constraint");
965}
966
967static bool
969 MatchPosition Position, SmallVectorImpl<Type *> &OverloadTys,
971 bool IsDeferredCheck, raw_ostream &OS) {
972 using namespace Intrinsic;
973
974 // If we ran out of descriptors, there are too many arguments or returns.
975 if (Infos.empty()) {
976 OS << Position << " too many "
977 << (Position.IsRet ? "returns" : "arguments");
978 return true;
979 }
980
981 // Do this before slicing off the 'front' part
982 auto InfosRef = Infos;
983 auto DeferCheck = [&DeferredChecks, &InfosRef, &Position](Type *T) {
984 DeferredChecks.emplace_back(T, InfosRef, Position);
985 return false;
986 };
987
988 IITDescriptor D = Infos.consume_front();
989
990 // Print error message when the (non-dependent) type for current position is
991 // invalid.
992 auto PrintMsg = [&OS, &Position,
993 Ty](bool IsValid, const Twine &Expected,
994 std::optional<unsigned> OIdx = std::nullopt) -> bool {
995 if (IsValid)
996 return false;
997 OS << Position << " type";
998 if (OIdx)
999 OS << " (overload type " << *OIdx << ")";
1000 OS << " expected " << Expected << ", but got " << *Ty;
1001 return true;
1002 };
1003
1004 // Print message when an overload type is invalid as a result of its use in
1005 // current dependent type. DependentQualifier describes the "function" applied
1006 // to the overload type to get the dependent type.
1007 auto PrintMsgInvalidOverloadTy =
1008 [&OS, &Position, &OverloadTys](const Twine &DependentQualifier,
1009 const Twine &Expected,
1010 unsigned OIdx) -> bool {
1011 OS << Position << " is " << DependentQualifier << " overload type " << OIdx
1012 << ", so overload type " << OIdx << " expected " << Expected
1013 << ", but got " << *OverloadTys[OIdx];
1014 return true;
1015 };
1016
1017 // Print message when a dependent type is invalid.
1018 auto PrintMsgInvalidDepType =
1019 [&OS, &Position, &OverloadTys,
1020 Ty](bool IsValid, const Twine &DependentQualifier, const Twine &Expected,
1021 unsigned OIdx) -> bool {
1022 if (IsValid)
1023 return false;
1024 bool IsMatching = DependentQualifier.isSingleStringRef() &&
1025 DependentQualifier.getSingleStringRef() == "matching";
1026 OS << Position << " type (" << DependentQualifier << " overload type "
1027 << OIdx << ") expected " << Expected;
1028 if (!IsMatching)
1029 OS << " (overload type " << OIdx << " is " << *OverloadTys[OIdx] << ")";
1030 OS << ", but got " << *Ty;
1031 return true;
1032 };
1033
1034 switch (D.Kind) {
1035 case IITDescriptor::Void:
1036 assert(Position.IsRet && Position.NumIndices == 0 &&
1037 "void descriptor expected only for return type");
1038 return PrintMsg(Ty->isVoidTy(), "void");
1039 case IITDescriptor::MMX: {
1041 return PrintMsg(VT && VT->getNumElements() == 1 &&
1042 VT->getElementType()->isIntegerTy(64),
1043 "x86_mmx (<1 x i64>)");
1044 }
1045 case IITDescriptor::AMX:
1046 return PrintMsg(Ty->isX86_AMXTy(), "x86_amx");
1047 case IITDescriptor::Token:
1048 return PrintMsg(Ty->isTokenTy(), "token");
1049 case IITDescriptor::Metadata:
1050 return PrintMsg(Ty->isMetadataTy(), "metadata");
1051 case IITDescriptor::Half:
1052 return PrintMsg(Ty->isHalfTy(), "half");
1053 case IITDescriptor::BFloat:
1054 return PrintMsg(Ty->isBFloatTy(), "bfloat");
1055 case IITDescriptor::Float:
1056 return PrintMsg(Ty->isFloatTy(), "float");
1057 case IITDescriptor::Double:
1058 return PrintMsg(Ty->isDoubleTy(), "double");
1059 case IITDescriptor::Quad:
1060 return PrintMsg(Ty->isFP128Ty(), "fp128");
1061 case IITDescriptor::PPCQuad:
1062 return PrintMsg(Ty->isPPC_FP128Ty(), "ppc_fp128");
1063 case IITDescriptor::Integer:
1064 return PrintMsg(Ty->isIntegerTy(D.IntegerWidth),
1065 "i" + Twine(D.IntegerWidth));
1066 case IITDescriptor::AArch64Svcount:
1067 return PrintMsg(isa<TargetExtType>(Ty) &&
1068 cast<TargetExtType>(Ty)->getName() == "aarch64.svcount",
1069 "aarch64.svcount");
1070 case IITDescriptor::WasmExternref:
1071 return PrintMsg(isa<TargetExtType>(Ty) &&
1072 cast<TargetExtType>(Ty)->getName() == "wasm.externref",
1073 "wasm.externref");
1074 case IITDescriptor::WasmFuncref:
1075 return PrintMsg(isa<TargetExtType>(Ty) &&
1076 cast<TargetExtType>(Ty)->getName() == "wasm.funcref",
1077 "wasm.funcref");
1078 case IITDescriptor::Vector: {
1080 StringRef Scalable = D.VectorWidth.isScalable() ? "vscale " : "";
1081 bool HasError =
1082 PrintMsg(VT && VT->getElementCount() == D.VectorWidth,
1083 Twine(Scalable) + "vector with " +
1084 Twine(D.VectorWidth.getKnownMinValue()) + " elements");
1085 if (HasError)
1086 return true;
1087 Position.push_vector_element();
1088 return matchIntrinsicType(VT->getElementType(), Infos, Position,
1089 OverloadTys, DeferredChecks, IsDeferredCheck, OS);
1090 }
1091 case IITDescriptor::Pointer: {
1093 unsigned AS = D.PointerAddressSpace;
1094 bool IsValid = PT && PT->getAddressSpace() == AS;
1095 if (AS == 0)
1096 return PrintMsg(IsValid, "ptr");
1097 return PrintMsg(IsValid, "ptr addrspace(" + Twine(AS) + ")");
1098 }
1099
1100 case IITDescriptor::Struct: {
1102 unsigned EC = D.StructNumElements;
1103 bool HasError = PrintMsg(
1104 ST && ST->isLiteral() && !ST->isPacked() && ST->getNumElements() == EC,
1105 "literal non-packed struct with " + Twine(EC) + " elements");
1106 if (HasError)
1107 return true;
1108
1109 for (const auto &[Idx, ETy] : llvm::enumerate(ST->elements())) {
1110 Position.push_struct_element(Idx);
1111 if (matchIntrinsicType(ETy, Infos, Position, OverloadTys, DeferredChecks,
1112 IsDeferredCheck, OS))
1113 return true;
1114 Position.pop_index();
1115 }
1116 return false;
1117 }
1118
1119 case IITDescriptor::Overloaded: {
1120 unsigned OIdx = D.getOverloadIndex();
1121 assert(OIdx == OverloadTys.size() && !IsDeferredCheck &&
1122 "Table consistency error");
1123 OverloadTys.push_back(Ty);
1124
1125 // Token has no mangling (see getMangledTypeStr), so it cannot be an
1126 // overload type; reject it with a signature error. Label is already
1127 // excluded from function signatures, so it never reaches here.
1128 if (Ty->isTokenTy())
1129 return PrintMsg(false, "any manglable type", OIdx);
1130
1131 IITDescriptor::AnyKindVectorConstraint VC;
1132 IITDescriptor::AnyKindElementConstraint EC;
1133 std::tie(VC, EC) = D.getOverloadConstraints();
1134
1135 bool IsValid = [&]() {
1136 switch (VC) {
1137 case IITDescriptor::VC_None:
1138 return true;
1139 case IITDescriptor::VC_Vector:
1140 return isa<VectorType>(Ty);
1141 case IITDescriptor::VC_Scalar:
1142 return !isa<VectorType>(Ty);
1143 }
1144 llvm_unreachable("invalid vector constraint");
1145 }();
1146
1147 auto [ElemValid, EK] = checkElementConstraint(Ty, EC);
1148 IsValid &= ElemValid;
1149
1150 if (IsValid)
1151 return false;
1152
1153 static constexpr StringLiteral VectorKinds[] = {
1154 "",
1155 "vector",
1156 "scalar",
1157 };
1158
1159 if (EC == IITDescriptor::EC_None) {
1160 // No constraint on element type.
1161 // Expected = any {vector | scalar} type.
1162 StringLiteral VK = ArrayRef(VectorKinds)[VC];
1163 return PrintMsg(false, formatv("any {} type", VK), OIdx);
1164 }
1165
1166 switch (VC) {
1167 case IITDescriptor::VC_None:
1168 // Expected = any EK or EK vector.
1169 return PrintMsg(false, formatv("any {0} or {0} vector", EK), OIdx);
1170 case IITDescriptor::VC_Vector:
1171 return PrintMsg(false, formatv("any {} vector", EK), OIdx);
1172 case IITDescriptor::VC_Scalar:
1173 return PrintMsg(false, formatv("any {} type", EK), OIdx);
1174 }
1175 llvm_unreachable("invalid vector constraint");
1176 }
1177
1178 case IITDescriptor::Match: {
1179 unsigned OIdx = D.getOverloadIndex();
1180 if (OIdx >= OverloadTys.size())
1181 return IsDeferredCheck || DeferCheck(Ty);
1182 return PrintMsgInvalidDepType(Ty == OverloadTys[OIdx], "matching",
1183 formatv("{}", *OverloadTys[OIdx]), OIdx);
1184 }
1185
1186 case IITDescriptor::Extend:
1187 case IITDescriptor::Trunc: {
1188 unsigned OIdx = D.getOverloadIndex();
1189 // If this is a forward reference, defer the check for later.
1190 if (OIdx >= OverloadTys.size())
1191 return IsDeferredCheck || DeferCheck(Ty);
1192
1193 Type *OTy = OverloadTys[OIdx];
1194 bool IsExtend = D.Kind == IITDescriptor::Extend;
1195 StringRef Qualifier = IsExtend ? "extended" : "truncated";
1196 if (!OTy->isIntOrIntVectorTy())
1197 return PrintMsgInvalidOverloadTy(Qualifier, "int or vector of int", OIdx);
1198
1199 Type *NewTy = IsExtend ? OTy->getExtendedType() : OTy->getTruncatedType();
1200 return PrintMsgInvalidDepType(Ty == NewTy, Qualifier, formatv("{}", *NewTy),
1201 OIdx);
1202 }
1203 case IITDescriptor::OneNthEltsVec: {
1204 unsigned OIdx = D.getOverloadIndex();
1205 unsigned Divisor = D.getVectorDivisor();
1206 // If this is a forward reference, defer the check for later.
1207 if (OIdx >= OverloadTys.size())
1208 return IsDeferredCheck || DeferCheck(Ty);
1209 Type *OTy = OverloadTys[OIdx];
1210 auto *OVecTy = dyn_cast<VectorType>(OTy);
1211 auto Qualifier = formatv("1/nth (n={}) elements vector of", Divisor);
1212 if (!OVecTy)
1213 return PrintMsgInvalidOverloadTy(Qualifier, "vector", OIdx);
1214 if (!OVecTy->getElementCount().isKnownMultipleOf(Divisor))
1215 return PrintMsgInvalidOverloadTy(
1216 Qualifier, formatv("vector with multiple of {} elements", Divisor),
1217 OIdx);
1219 return PrintMsgInvalidDepType(Expected == Ty, Qualifier,
1220 formatv("{}", *Expected), OIdx);
1221 }
1222 case IITDescriptor::SameVecWidth: {
1223 unsigned OIdx = D.getOverloadIndex();
1224 if (OIdx >= OverloadTys.size()) {
1225 // Defer check and subsequent check for the vector element type.
1226 Infos.consume_front();
1227 return IsDeferredCheck || DeferCheck(Ty);
1228 }
1229 auto *OVecTy = dyn_cast<VectorType>(OverloadTys[OIdx]);
1230 auto *ThisArgVecType = dyn_cast<VectorType>(Ty);
1231 // Both must be vectors of the same number of elements or neither.
1232 StringRef Qualifier = "same vector width of";
1233 if (OVecTy && !ThisArgVecType)
1234 return PrintMsgInvalidDepType(false, Qualifier, "vector", OIdx);
1235 if (!OVecTy && ThisArgVecType)
1236 return PrintMsgInvalidDepType(false, Qualifier, "scalar", OIdx);
1237 Type *EltTy = Ty;
1238 if (ThisArgVecType) {
1239 ElementCount Expected = OVecTy->getElementCount();
1240 if (Expected != ThisArgVecType->getElementCount())
1241 return PrintMsgInvalidDepType(
1242 false, Qualifier, formatv("vector with {} elements", Expected),
1243 OIdx);
1244 EltTy = ThisArgVecType->getElementType();
1245 Position.push_vector_element();
1246 }
1247 return matchIntrinsicType(EltTy, Infos, Position, OverloadTys,
1248 DeferredChecks, IsDeferredCheck, OS);
1249 }
1250 case IITDescriptor::AnySameVecWidth: {
1251 unsigned RefOverloadIndex = D.getRefOverloadIndex();
1252 if (RefOverloadIndex >= OverloadTys.size()) {
1253 if (IsDeferredCheck)
1254 return true;
1255 // If forward referencing, already add the type and defer the checks for
1256 // later.
1257 assert(D.getOverloadIndex() == OverloadTys.size() &&
1258 "Table consistency error");
1259 OverloadTys.push_back(Ty);
1260 return DeferCheck(Ty);
1261 }
1262
1263 if (!IsDeferredCheck) {
1264 assert(D.getOverloadIndex() == OverloadTys.size() &&
1265 "Table consistency error");
1266 OverloadTys.push_back(Ty);
1267 }
1268
1269 auto [ElemValid, Kind] =
1270 checkElementConstraint(Ty, D.getElementConstraint());
1271
1272 auto *ReferenceType = dyn_cast<VectorType>(OverloadTys[RefOverloadIndex]);
1273 auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1274 StringRef Qualifier = "same vector width of";
1275 if (ReferenceType) {
1276 auto ExpectedCount = ReferenceType->getElementCount();
1277 auto Expected =
1278 formatv("{0} vector with {1} elements", Kind, ExpectedCount);
1279 if (!ThisArgVecTy)
1280 return PrintMsgInvalidDepType(false, Qualifier, Expected,
1281 RefOverloadIndex);
1282 bool IsValid =
1283 ThisArgVecTy->getElementCount() == ExpectedCount && ElemValid;
1284 return PrintMsgInvalidDepType(IsValid, Qualifier, Expected,
1285 RefOverloadIndex);
1286 }
1287
1288 auto Expected = formatv("scalar {}", Kind);
1289 if (ThisArgVecTy)
1290 return PrintMsgInvalidDepType(false, Qualifier, Expected,
1291 RefOverloadIndex);
1292 return PrintMsgInvalidDepType(ElemValid, Qualifier, Expected,
1293 RefOverloadIndex);
1294 }
1295 case IITDescriptor::VecElement: {
1296 unsigned OIdx = D.getOverloadIndex();
1297 if (OIdx >= OverloadTys.size())
1298 return IsDeferredCheck || DeferCheck(Ty);
1299 StringRef Qualifier = "vector element of";
1300 auto *OVecTy = dyn_cast<VectorType>(OverloadTys[OIdx]);
1301 if (!OVecTy)
1302 return PrintMsgInvalidOverloadTy(Qualifier, "vector", OIdx);
1303 Type *Expected = OVecTy->getElementType();
1304 return PrintMsgInvalidDepType(Expected == Ty, Qualifier,
1305 formatv("{}", *Expected), OIdx);
1306 }
1307 case IITDescriptor::Subdivide2:
1308 case IITDescriptor::Subdivide4: {
1309 unsigned OIdx = D.getOverloadIndex();
1310 // If this is a forward reference, defer the check for later.
1311 if (OIdx >= OverloadTys.size())
1312 return IsDeferredCheck || DeferCheck(Ty);
1313
1314 int SubDivs = D.Kind == IITDescriptor::Subdivide2 ? 1 : 2;
1315 auto *OVecTy = dyn_cast<VectorType>(OverloadTys[OIdx]);
1316 auto Qualifier =
1317 formatv("subdivided by {} vector of", SubDivs == 1 ? 2 : 4);
1318 if (!OVecTy)
1319 return PrintMsgInvalidOverloadTy(Qualifier, "vector", OIdx);
1320
1321 // TODO: Verify that the element type of the overload type is subdivisible
1322 // by 2 or 4.
1324 return PrintMsgInvalidDepType(Expected == Ty, Qualifier,
1325 formatv("{}", *Expected), OIdx);
1326 }
1327 case IITDescriptor::VecOfBitcastsToInt: {
1328 unsigned OIdx = D.getOverloadIndex();
1329 if (OIdx >= OverloadTys.size())
1330 return IsDeferredCheck || DeferCheck(Ty);
1331 auto *OVecTy = dyn_cast<VectorType>(OverloadTys[OIdx]);
1332 StringRef Qualifier = "vector of bitcasts to int of";
1333 if (!OVecTy)
1334 return PrintMsgInvalidOverloadTy(Qualifier, "vector", OIdx);
1336 return PrintMsgInvalidDepType(Expected == Ty, Qualifier,
1337 formatv("{}", *Expected), OIdx);
1338 }
1339 case IITDescriptor::VarArg:
1340 // VarArg token should be consumed by `getIntrinsicInfoTableEntries`, so we
1341 // should never see it here.
1342 llvm_unreachable("IITDescriptor::VarArg not expected");
1343 }
1344 llvm_unreachable("unhandled");
1345}
1346
1347/// Return true if the function type \p FTy is a valid type signature for the
1348/// type constraints specified in the .td file, represented by \p Infos and
1349/// \p IsVarArg. The overloaded types for the intrinsic are pushed to the
1350/// \p OverloadTys vector.
1351///
1352/// If \p NumMissingTrailingParams is non-zero, \p FTy may omit exactly that
1353/// many trailing parameters. Omitted parameters must have concrete integer
1354/// types and therefore cannot contribute an unresolved overload type.
1355///
1356/// If the type is not valid, returns false and prints an error message to
1357/// \p OS.
1360 unsigned NumArgs, bool IsVarArg,
1361 SmallVectorImpl<Type *> &OverloadTys,
1362 raw_ostream &OS,
1363 unsigned NumMissingTrailingParams) {
1365
1366 assert(!Infos.empty() && "Table consistency error");
1367
1368 MatchPosition Pos;
1369 Pos.IsRet = true;
1370 Pos.Num = 0;
1371
1372 if (matchIntrinsicType(FTy->getReturnType(), Infos, Pos, OverloadTys,
1373 DeferredChecks, false, OS))
1374 return false;
1375
1376 unsigned ProvidedArgs = FTy->getNumParams();
1377 if (ProvidedArgs + NumMissingTrailingParams != NumArgs) {
1378 OS << "intrinsic has incorrect number of args. Expected " << NumArgs
1379 << ", but got " << ProvidedArgs;
1380 return false;
1381 }
1382
1383 Pos.IsRet = false;
1384 for (const auto &[Idx, Ty] : llvm::enumerate(FTy->params())) {
1385 Pos.Num = Idx;
1386 if (matchIntrinsicType(Ty, Infos, Pos, OverloadTys, DeferredChecks, false,
1387 OS))
1388 return false;
1389 }
1390
1391 for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
1392 auto &[DefTy, DefInfos, DefPosition] = DeferredChecks[I];
1393 if (matchIntrinsicType(DefTy, DefInfos, DefPosition, OverloadTys,
1394 DeferredChecks, true, OS))
1395 return false;
1396 }
1397
1398 // Default arguments are materialized as ConstantInt values, requiring one
1399 // concrete integer descriptor per omitted parameter.
1400 if (NumMissingTrailingParams != 0 &&
1401 (Infos.size() != NumMissingTrailingParams ||
1403 return D.Kind != Intrinsic::IITDescriptor::Integer;
1404 }))) {
1405 OS << "cannot omit trailing parameters that are overloaded or non-integer";
1406 return false;
1407 }
1408 Infos = Infos.drop_front(NumMissingTrailingParams);
1409
1410 if (!Infos.empty()) {
1411 OS << "intrinsic has too few arguments!";
1412 return false;
1413 }
1414
1415 if (FTy->isVarArg() != IsVarArg) {
1416 if (IsVarArg)
1417 OS << "intrinsic was not defined with variable arguments!";
1418 else
1419 OS << "intrinsic was defined with variable arguments!";
1420 return false;
1421 }
1422
1423 return true;
1424}
1425
1427 using namespace Intrinsic;
1430 return !Table.empty() && Table[0].Kind == IITDescriptor::Struct;
1431}
1432
1434 SmallVectorImpl<Type *> &OverloadTys,
1435 raw_ostream &OS) {
1436 return isSignatureValid(ID, FT, OverloadTys,
1437 /*NumMissingTrailingParams=*/0, OS);
1438}
1439
1441 SmallVectorImpl<Type *> &OverloadTys,
1442 unsigned NumMissingTrailingParams,
1443 raw_ostream &OS) {
1444 if (!ID)
1445 return false;
1446
1448 auto [TableRef, NumArgs, IsVarArg] = getIntrinsicInfoTableEntries(ID, Table);
1449
1450 return ::isSignatureValid(FT, TableRef, NumArgs, IsVarArg, OverloadTys, OS,
1451 NumMissingTrailingParams);
1452}
1453
1455 SmallVectorImpl<Type *> &OverloadTys,
1456 raw_ostream &OS) {
1457 return isSignatureValid(F->getIntrinsicID(), F->getFunctionType(),
1458 OverloadTys, OS);
1459}
1460
1462 SmallVector<Type *, 4> OverloadTys;
1463 if (!isSignatureValid(F, OverloadTys))
1464 return std::nullopt;
1465
1466 Intrinsic::ID ID = F->getIntrinsicID();
1467 StringRef Name = F->getName();
1468 std::string WantedName =
1469 Intrinsic::getName(ID, OverloadTys, F->getParent(), F->getFunctionType());
1470 if (Name == WantedName)
1471 return std::nullopt;
1472
1473 Function *NewDecl = [&] {
1474 if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {
1475 if (auto *ExistingF = dyn_cast<Function>(ExistingGV))
1476 if (ExistingF->getFunctionType() == F->getFunctionType())
1477 return ExistingF;
1478
1479 // The name already exists, but is not a function or has the wrong
1480 // prototype. Make place for the new one by renaming the old version.
1481 // Either this old version will be removed later on or the module is
1482 // invalid and we'll get an error.
1483 ExistingGV->setName(WantedName + ".renamed");
1484 }
1485 return Intrinsic::getOrInsertDeclaration(F->getParent(), ID, OverloadTys);
1486 }();
1487
1488 NewDecl->setCallingConv(F->getCallingConv());
1489 assert(NewDecl->getFunctionType() == F->getFunctionType() &&
1490 "Shouldn't change the signature");
1491 return NewDecl;
1492}
1493
1497
1499 {Intrinsic::vector_interleave2, Intrinsic::vector_deinterleave2},
1500 {Intrinsic::vector_interleave3, Intrinsic::vector_deinterleave3},
1501 {Intrinsic::vector_interleave4, Intrinsic::vector_deinterleave4},
1502 {Intrinsic::vector_interleave5, Intrinsic::vector_deinterleave5},
1503 {Intrinsic::vector_interleave6, Intrinsic::vector_deinterleave6},
1504 {Intrinsic::vector_interleave7, Intrinsic::vector_deinterleave7},
1505 {Intrinsic::vector_interleave8, Intrinsic::vector_deinterleave8},
1506};
1507
1509 assert(Factor >= 2 && Factor <= 8 && "Unexpected factor");
1510 return InterleaveIntrinsics[Factor - 2].Interleave;
1511}
1512
1514 assert(Factor >= 2 && Factor <= 8 && "Unexpected factor");
1515 return InterleaveIntrinsics[Factor - 2].Deinterleave;
1516}
1517
1519 const Constant *ImmArgVal) {
1520 uint64_t Val = cast<ConstantInt>(ImmArgVal)->getZExtValue();
1521 OS << static_cast<FPClassTest>(Val);
1522}
1523
1524#define GET_INTRINSIC_IMMARG_RANGE_SET_CHECKS
1525#include "llvm/IR/IntrinsicImpl.inc"
1526
1527#define GET_INTRINSIC_PRETTY_PRINT_ARGUMENTS
1528#include "llvm/IR/IntrinsicImpl.inc"
1529
1530// Emit the default-argument values table and lookup function
1531// (Intrinsic::getAllDefaultArgValues).
1532#define GET_INTRINSIC_DEFAULT_ARG_VALUES
1533#include "llvm/IR/IntrinsicImpl.inc"
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
ArrayRef< TableEntry > TableRef
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_ABI
Definition Compiler.h:211
#define _
Module.h This file contains the declarations for the Module class.
static bool matchIntrinsicType(Type *Ty, ArrayRef< Intrinsic::IITDescriptor > &Infos, MatchPosition Position, SmallVectorImpl< Type * > &OverloadTys, SmallVectorImpl< DeferredIntrinsicMatchInfo > &DeferredChecks, bool IsDeferredCheck, raw_ostream &OS)
static InterleaveIntrinsic InterleaveIntrinsics[]
static std::pair< bool, StringRef > checkElementConstraint(Type *Ty, Intrinsic::IITDescriptor::AnyKindElementConstraint EC)
Check whether Ty satisfies the given element constraint EC and return a description of the expected e...
std::tuple< Type *, ArrayRef< Intrinsic::IITDescriptor >, MatchPosition > DeferredIntrinsicMatchInfo
static std::pair< ArrayRef< unsigned >, StringRef > findTargetSubtable(StringRef Name)
Find the segment of IntrinsicNameOffsetTable for intrinsics with the same target as Name,...
static Function * getOrInsertIntrinsicDeclarationImpl(Module *M, Intrinsic::ID id, ArrayRef< Type * > OverloadTys, FunctionType *FT)
static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)
static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef< Type * > OverloadTys, Module *M, FunctionType *FT, bool EarlyModuleCheck)
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type * > OverloadTys, LLVMContext &Context)
static int lookupLLVMIntrinsicByName(ArrayRef< unsigned > NameOffsetTable, StringRef Name, StringRef Target="")
Looks up Name in NameTable via binary search.
static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType)
Returns a stable mangling for the type specified for use in the name mangling scheme used by 'any' ty...
static bool isSignatureValid(FunctionType *FTy, ArrayRef< Intrinsic::IITDescriptor > &Infos, unsigned NumArgs, bool IsVarArg, SmallVectorImpl< Type * > &OverloadTys, raw_ostream &OS, unsigned NumMissingTrailingParams=0)
Return true if the function type FTy is a valid type signature for the type constraints specified in ...
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
#define T
uint64_t High
This file contains the definitions of the enumerations and flags associated with NVVM Intrinsics,...
static StringRef getName(Value *V)
This file contains some functions that are useful when dealing with strings.
static SymbolRef::Type getType(const Symbol *Sym)
Definition TapiFile.cpp:39
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Value * RHS
Value * LHS
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition ArrayRef.h:194
iterator end() const
Definition ArrayRef.h:130
size_t size() const
Get the array size.
Definition ArrayRef.h:141
iterator begin() const
Definition ArrayRef.h:129
bool empty() const
Check if the array is empty.
Definition ArrayRef.h:136
const T & consume_front()
consume_front() - Returns the first element and drops it from ArrayRef.
Definition ArrayRef.h:156
This is an important base class in LLVM.
Definition Constant.h:44
Tagged union holding either a T or a Error.
Definition Error.h:485
Class to represent fixed width SIMD vectors.
unsigned getNumElements() const
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
Definition Type.cpp:838
Class to represent function types.
static LLVM_ABI FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition Function.h:212
const Function & getFunction() const
Definition Function.h:167
void setCallingConv(CallingConv::ID CC)
Definition Function.h:277
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition Type.cpp:333
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:76
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
static LLVM_ABI PointerType * get(LLVMContext &C, unsigned AddressSpace)
This constructs an opaque pointer to an object in a numbered address space.
Definition Type.cpp:882
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition StringRef.h:888
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
static constexpr size_t npos
Definition StringRef.h:58
std::string str() const
Get the contents as an std::string.
Definition StringRef.h:222
constexpr size_t size() const
Get the string size.
Definition StringRef.h:144
Class to represent struct types.
static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition Type.cpp:462
Class to represent target extensions types, which are generally unintrospectable from target-independ...
static LLVM_ABI TargetExtType * get(LLVMContext &Context, StringRef Name, ArrayRef< Type * > Types={}, ArrayRef< unsigned > Ints={})
Return a target extension type having the specified name and optional type and integer parameters.
Definition Type.cpp:931
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:46
static LLVM_ABI Type * getX86_AMXTy(LLVMContext &C)
Definition Type.cpp:278
LLVM_ABI Type * getTruncatedType() const
Given scalar/vector integer type, returns a type with elements half as wide as in the original type.
static LLVM_ABI Type * getMetadataTy(LLVMContext &C)
Definition Type.cpp:273
static LLVM_ABI Type * getTokenTy(LLVMContext &C)
Definition Type.cpp:274
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition Type.h:258
bool isPointerTy() const
True if this is an instance of PointerType.
Definition Type.h:277
static LLVM_ABI Type * getPPC_FP128Ty(LLVMContext &C)
Definition Type.cpp:277
static LLVM_ABI Type * getFP128Ty(LLVMContext &C)
Definition Type.cpp:276
@ X86_AMXTyID
AMX vectors (8192 bits, X86 specific)
Definition Type.h:67
@ HalfTyID
16-bit floating point type
Definition Type.h:57
@ VoidTyID
type with no size
Definition Type.h:64
@ FloatTyID
32-bit floating point type
Definition Type.h:59
@ IntegerTyID
Arbitrary bit width integers.
Definition Type.h:71
@ BFloatTyID
16-bit floating point type (7-bit significand)
Definition Type.h:58
@ DoubleTyID
64-bit floating point type
Definition Type.h:60
@ X86_FP80TyID
80-bit floating point type (X87)
Definition Type.h:61
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
Definition Type.h:63
@ MetadataTyID
Metadata.
Definition Type.h:66
@ ByteTyID
Arbitrary bit width bytes.
Definition Type.h:72
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition Type.h:62
static LLVM_ABI Type * getVoidTy(LLVMContext &C)
Definition Type.cpp:267
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
Definition Type.h:370
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition Type.h:186
LLVM_ABI Type * getExtendedType() const
Given scalar/vector integer type, returns a type with elements twice as wide as in the original type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition Type.h:252
static LLVM_ABI Type * getDoubleTy(LLVMContext &C)
Definition Type.cpp:272
static LLVM_ABI Type * getFloatTy(LLVMContext &C)
Definition Type.cpp:271
static LLVM_ABI Type * getBFloatTy(LLVMContext &C)
Definition Type.cpp:270
static LLVM_ABI Type * getHalfTy(LLVMContext &C)
Definition Type.cpp:269
static VectorType * getOneNthElementsVectorType(VectorType *VTy, unsigned Denominator)
static VectorType * getSubdividedVectorType(VectorType *VTy, int NumSubdivs)
static VectorType * getInteger(VectorType *VTy)
This static method gets a VectorType with the same number of elements as the input type,...
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Type * getElementType() const
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.
LLVM_ABI Intrinsic::ID getDeinterleaveIntrinsicID(unsigned Factor)
Returns the corresponding llvm.vector.deinterleaveN intrinsic for factor N.
LLVM_ABI void printFPClassMask(raw_ostream &OS, const Constant *ImmArgVal)
LLVM_ABI Function * getDeclarationIfExists(const Module *M, ID id)
Look up the Function declaration of the intrinsic id in the Module M and return it if it exists.
LLVM_ABI std::optional< Function * > remangleIntrinsicFunction(Function *F)
LLVM_ABI bool hasConstrainedFPRoundingModeOperand(ID QID)
Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics" that take r...
LLVM_ABI StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > OverloadTys={})
Look up the Function declaration of the intrinsic id in the Module M.
LLVM_ABI bool isConstrainedFPIntrinsic(ID QID)
Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics".
LLVM_ABI ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
LLVM_ABI bool hasPrettyPrintedArgs(ID id)
Returns true if the intrinsic has pretty printed immediate arguments.
LLVM_ABI std::tuple< ArrayRef< IITDescriptor >, unsigned, bool > getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Fill the IIT table descriptor for the intrinsic id into an array of IITDescriptors.
LLVM_ABI StringRef getBaseName(ID id)
Return the LLVM name for an intrinsic, without encoded types for overloading, such as "llvm....
LLVM_ABI Intrinsic::ID getInterleaveIntrinsicID(unsigned Factor)
Returns the corresponding llvm.vector.interleaveN intrinsic for factor N.
LLVM_ABI bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
LLVM_ABI FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > OverloadTys={})
Return the function type for an intrinsic.
LLVM_ABI bool isSignatureValid(Intrinsic::ID ID, FunctionType *FT, SmallVectorImpl< Type * > &OverloadTys, raw_ostream &OS=nulls())
Returns true if FT is a valid function type for intrinsic ID.
LLVM_ABI bool hasStructReturnType(ID id)
Returns true if id has a struct return type.
LLVM_ABI bool isTriviallyScalarizable(ID id)
Returns true if the intrinsic is trivially scalarizable.
LLVM_ABI bool isTargetIntrinsic(ID IID)
isTargetIntrinsic - Returns true if IID is an intrinsic specific to a certain target.
LLVM_ABI StringRef getRequiredTargetFeatures(ID id)
LLVM_ABI std::string getNameNoUnnamedTypes(ID Id, ArrayRef< Type * > OverloadTys)
Return the LLVM name for an intrinsic.
This is an optimization pass for GlobalISel generic memory operations.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
Definition Threading.h:280
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
Definition MathExtras.h:166
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are tuples (A, B,...
Definition STLExtras.h:2570
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
auto partition_point(R &&Range, Predicate P)
Binary search for the first iterator in a range where a predicate is false.
Definition STLExtras.h:2145
std::string utostr(uint64_t X, bool isNeg=false)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1762
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
LLVM_ABI raw_ostream & nulls()
This returns a reference to a raw_ostream which simply discards output.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
ArrayRef(const T &OneElt) -> ArrayRef< T >
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
constexpr detail::IsaCheckPredicate< Types... > IsaPred
Function object wrapper for the llvm::isa type check.
Definition Casting.h:866
#define N
Intrinsic::ID Interleave
Intrinsic::ID Deinterleave
This is a type descriptor which explains the type requirements of an intrinsic.
Definition Intrinsics.h:174