LLVM  10.0.0svn
Function.cpp
Go to the documentation of this file.
1 //===- Function.cpp - Implement the Global object classes -----------------===//
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 the Function class for the IR library.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/IR/Function.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/None.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/IR/Argument.h"
24 #include "llvm/IR/Attributes.h"
25 #include "llvm/IR/BasicBlock.h"
26 #include "llvm/IR/Constant.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/GlobalValue.h"
30 #include "llvm/IR/InstIterator.h"
31 #include "llvm/IR/Instruction.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/IntrinsicInst.h"
34 #include "llvm/IR/Intrinsics.h"
35 #include "llvm/IR/LLVMContext.h"
36 #include "llvm/IR/MDBuilder.h"
37 #include "llvm/IR/Metadata.h"
38 #include "llvm/IR/Module.h"
40 #include "llvm/IR/Type.h"
41 #include "llvm/IR/Use.h"
42 #include "llvm/IR/User.h"
43 #include "llvm/IR/Value.h"
45 #include "llvm/Support/Casting.h"
46 #include "llvm/Support/Compiler.h"
48 #include <algorithm>
49 #include <cassert>
50 #include <cstddef>
51 #include <cstdint>
52 #include <cstring>
53 #include <string>
54 
55 using namespace llvm;
57 
58 // Explicit instantiations of SymbolTableListTraits since some of the methods
59 // are not in the public header file...
61 
62 //===----------------------------------------------------------------------===//
63 // Argument Implementation
64 //===----------------------------------------------------------------------===//
65 
66 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
67  : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
68  setName(Name);
69 }
70 
71 void Argument::setParent(Function *parent) {
72  Parent = parent;
73 }
74 
76  if (!getType()->isPointerTy()) return false;
77  if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull))
78  return true;
79  else if (getDereferenceableBytes() > 0 &&
81  getType()->getPointerAddressSpace()))
82  return true;
83  return false;
84 }
85 
86 bool Argument::hasByValAttr() const {
87  if (!getType()->isPointerTy()) return false;
88  return hasAttribute(Attribute::ByVal);
89 }
90 
92  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
93 }
94 
96  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
97 }
98 
100  if (!getType()->isPointerTy()) return false;
101  return hasAttribute(Attribute::InAlloca);
102 }
103 
105  if (!getType()->isPointerTy()) return false;
107  return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
108  Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca);
109 }
110 
111 unsigned Argument::getParamAlignment() const {
112  assert(getType()->isPointerTy() && "Only pointers have alignments");
113  return getParent()->getParamAlignment(getArgNo());
114 }
115 
117  assert(getType()->isPointerTy() && "Only pointers have byval types");
118  return getParent()->getParamByValType(getArgNo());
119 }
120 
122  assert(getType()->isPointerTy() &&
123  "Only pointers have dereferenceable bytes");
125 }
126 
128  assert(getType()->isPointerTy() &&
129  "Only pointers have dereferenceable bytes");
131 }
132 
133 bool Argument::hasNestAttr() const {
134  if (!getType()->isPointerTy()) return false;
135  return hasAttribute(Attribute::Nest);
136 }
137 
139  if (!getType()->isPointerTy()) return false;
141 }
142 
144  if (!getType()->isPointerTy()) return false;
145  return hasAttribute(Attribute::NoCapture);
146 }
147 
149  if (!getType()->isPointerTy()) return false;
150  return hasAttribute(Attribute::StructRet);
151 }
152 
154  return hasAttribute(Attribute::InReg);
155 }
156 
158  return hasAttribute(Attribute::Returned);
159 }
160 
161 bool Argument::hasZExtAttr() const {
162  return hasAttribute(Attribute::ZExt);
163 }
164 
165 bool Argument::hasSExtAttr() const {
166  return hasAttribute(Attribute::SExt);
167 }
168 
171  return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) ||
172  Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone);
173 }
174 
177  AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
178  getParent()->setAttributes(AL);
179 }
180 
182  getParent()->addParamAttr(getArgNo(), Kind);
183 }
184 
186  getParent()->addParamAttr(getArgNo(), Attr);
187 }
188 
190  getParent()->removeParamAttr(getArgNo(), Kind);
191 }
192 
194  return getParent()->hasParamAttribute(getArgNo(), Kind);
195 }
196 
198  return getParent()->getParamAttribute(getArgNo(), Kind);
199 }
200 
201 //===----------------------------------------------------------------------===//
202 // Helper Methods in Function
203 //===----------------------------------------------------------------------===//
204 
206  return getType()->getContext();
207 }
208 
210  unsigned NumInstrs = 0;
211  for (const BasicBlock &BB : BasicBlocks)
212  NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
213  BB.instructionsWithoutDebug().end());
214  return NumInstrs;
215 }
216 
218  const Twine &N, Module &M) {
219  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
220 }
221 
223  getParent()->getFunctionList().remove(getIterator());
224 }
225 
227  getParent()->getFunctionList().erase(getIterator());
228 }
229 
230 //===----------------------------------------------------------------------===//
231 // Function Implementation
232 //===----------------------------------------------------------------------===//
233 
234 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
235  // If AS == -1 and we are passed a valid module pointer we place the function
236  // in the program address space. Otherwise we default to AS0.
237  if (AddrSpace == static_cast<unsigned>(-1))
238  return M ? M->getDataLayout().getProgramAddressSpace() : 0;
239  return AddrSpace;
240 }
241 
242 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
243  const Twine &name, Module *ParentModule)
244  : GlobalObject(Ty, Value::FunctionVal,
246  computeAddrSpace(AddrSpace, ParentModule)),
247  NumArgs(Ty->getNumParams()) {
248  assert(FunctionType::isValidReturnType(getReturnType()) &&
249  "invalid return type");
250  setGlobalObjectSubClassData(0);
251 
252  // We only need a symbol table for a function if the context keeps value names
253  if (!getContext().shouldDiscardValueNames())
254  SymTab = std::make_unique<ValueSymbolTable>();
255 
256  // If the function has arguments, mark them as lazily built.
257  if (Ty->getNumParams())
258  setValueSubclassData(1); // Set the "has lazy arguments" bit.
259 
260  if (ParentModule)
261  ParentModule->getFunctionList().push_back(this);
262 
263  HasLLVMReservedName = getName().startswith("llvm.");
264  // Ensure intrinsics have the right parameter attributes.
265  // Note, the IntID field will have been set in Value::setName if this function
266  // name is a valid intrinsic ID.
267  if (IntID)
268  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
269 }
270 
272  dropAllReferences(); // After this it is safe to delete instructions.
273 
274  // Delete all of the method arguments and unlink from symbol table...
275  if (Arguments)
276  clearArguments();
277 
278  // Remove the function from the on-the-side GC table.
279  clearGC();
280 }
281 
282 void Function::BuildLazyArguments() const {
283  // Create the arguments vector, all arguments start out unnamed.
284  auto *FT = getFunctionType();
285  if (NumArgs > 0) {
286  Arguments = std::allocator<Argument>().allocate(NumArgs);
287  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
288  Type *ArgTy = FT->getParamType(i);
289  assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
290  new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
291  }
292  }
293 
294  // Clear the lazy arguments bit.
295  unsigned SDC = getSubclassDataFromValue();
296  SDC &= ~(1 << 0);
297  const_cast<Function*>(this)->setValueSubclassData(SDC);
298  assert(!hasLazyArguments());
299 }
300 
302  return MutableArrayRef<Argument>(Args, Count);
303 }
304 
305 void Function::clearArguments() {
306  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
307  A.setName("");
308  A.~Argument();
309  }
310  std::allocator<Argument>().deallocate(Arguments, NumArgs);
311  Arguments = nullptr;
312 }
313 
315  assert(isDeclaration() && "Expected no references to current arguments");
316 
317  // Drop the current arguments, if any, and set the lazy argument bit.
318  if (!hasLazyArguments()) {
320  [](const Argument &A) { return A.use_empty(); }) &&
321  "Expected arguments to be unused in declaration");
322  clearArguments();
324  }
325 
326  // Nothing to steal if Src has lazy arguments.
327  if (Src.hasLazyArguments())
328  return;
329 
330  // Steal arguments from Src, and fix the lazy argument bits.
331  assert(arg_size() == Src.arg_size());
332  Arguments = Src.Arguments;
333  Src.Arguments = nullptr;
334  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
335  // FIXME: This does the work of transferNodesFromList inefficiently.
337  if (A.hasName())
338  Name = A.getName();
339  if (!Name.empty())
340  A.setName("");
341  A.setParent(this);
342  if (!Name.empty())
343  A.setName(Name);
344  }
345 
347  assert(!hasLazyArguments());
348  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
349 }
350 
351 // dropAllReferences() - This function causes all the subinstructions to "let
352 // go" of all references that they are maintaining. This allows one to
353 // 'delete' a whole class at a time, even though there may be circular
354 // references... first all references are dropped, and all use counts go to
355 // zero. Then everything is deleted for real. Note that no operations are
356 // valid on an object that has "dropped all references", except operator
357 // delete.
358 //
360  setIsMaterializable(false);
361 
362  for (BasicBlock &BB : *this)
363  BB.dropAllReferences();
364 
365  // Delete all basic blocks. They are now unused, except possibly by
366  // blockaddresses, but BasicBlock's destructor takes care of those.
367  while (!BasicBlocks.empty())
368  BasicBlocks.begin()->eraseFromParent();
369 
370  // Drop uses of any optional data (real or placeholder).
371  if (getNumOperands()) {
373  setNumHungOffUseOperands(0);
375  }
376 
377  // Metadata is stored in a side-table.
378  clearMetadata();
379 }
380 
383  PAL = PAL.addAttribute(getContext(), i, Kind);
384  setAttributes(PAL);
385 }
386 
387 void Function::addAttribute(unsigned i, Attribute Attr) {
389  PAL = PAL.addAttribute(getContext(), i, Attr);
390  setAttributes(PAL);
391 }
392 
393 void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) {
395  PAL = PAL.addAttributes(getContext(), i, Attrs);
396  setAttributes(PAL);
397 }
398 
401  PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
402  setAttributes(PAL);
403 }
404 
405 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
407  PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
408  setAttributes(PAL);
409 }
410 
411 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
413  PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs);
414  setAttributes(PAL);
415 }
416 
419  PAL = PAL.removeAttribute(getContext(), i, Kind);
420  setAttributes(PAL);
421 }
422 
425  PAL = PAL.removeAttribute(getContext(), i, Kind);
426  setAttributes(PAL);
427 }
428 
429 void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) {
431  PAL = PAL.removeAttributes(getContext(), i, Attrs);
432  setAttributes(PAL);
433 }
434 
437  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
438  setAttributes(PAL);
439 }
440 
441 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
443  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
444  setAttributes(PAL);
445 }
446 
447 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
449  PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
450  setAttributes(PAL);
451 }
452 
453 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
455  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
456  setAttributes(PAL);
457 }
458 
459 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
461  PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
462  setAttributes(PAL);
463 }
464 
465 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
467  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
468  setAttributes(PAL);
469 }
470 
472  uint64_t Bytes) {
474  PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes);
475  setAttributes(PAL);
476 }
477 
478 const std::string &Function::getGC() const {
479  assert(hasGC() && "Function has no collector");
480  return getContext().getGC(*this);
481 }
482 
483 void Function::setGC(std::string Str) {
484  setValueSubclassDataBit(14, !Str.empty());
485  getContext().setGC(*this, std::move(Str));
486 }
487 
489  if (!hasGC())
490  return;
491  getContext().deleteGC(*this);
492  setValueSubclassDataBit(14, false);
493 }
494 
495 /// Copy all additional attributes (those not needed to create a Function) from
496 /// the Function Src to this one.
499  setCallingConv(Src->getCallingConv());
500  setAttributes(Src->getAttributes());
501  if (Src->hasGC())
502  setGC(Src->getGC());
503  else
504  clearGC();
505  if (Src->hasPersonalityFn())
506  setPersonalityFn(Src->getPersonalityFn());
507  if (Src->hasPrefixData())
508  setPrefixData(Src->getPrefixData());
509  if (Src->hasPrologueData())
510  setPrologueData(Src->getPrologueData());
511 }
512 
513 /// Table of string intrinsic names indexed by enum value.
514 static const char * const IntrinsicNameTable[] = {
515  "not_intrinsic",
516 #define GET_INTRINSIC_NAME_TABLE
517 #include "llvm/IR/IntrinsicImpl.inc"
518 #undef GET_INTRINSIC_NAME_TABLE
519 };
520 
521 /// Table of per-target intrinsic name tables.
522 #define GET_INTRINSIC_TARGET_DATA
523 #include "llvm/IR/IntrinsicImpl.inc"
524 #undef GET_INTRINSIC_TARGET_DATA
525 
526 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
527 /// target as \c Name, or the generic table if \c Name is not target specific.
528 ///
529 /// Returns the relevant slice of \c IntrinsicNameTable
531  assert(Name.startswith("llvm."));
532 
533  ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
534  // Drop "llvm." and take the first dotted component. That will be the target
535  // if this is target specific.
536  StringRef Target = Name.drop_front(5).split('.').first;
537  auto It = partition_point(
538  Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
539  // We've either found the target or just fall back to the generic set, which
540  // is always first.
541  const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
542  return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
543 }
544 
545 /// This does the actual lookup of an intrinsic ID which
546 /// matches the given function name.
548  ArrayRef<const char *> NameTable = findTargetSubtable(Name);
549  int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
550  if (Idx == -1)
552 
553  // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
554  // an index into a sub-table.
555  int Adjust = NameTable.data() - IntrinsicNameTable;
556  Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
557 
558  // If the intrinsic is not overloaded, require an exact match. If it is
559  // overloaded, require either exact or prefix match.
560  const auto MatchSize = strlen(NameTable[Idx]);
561  assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
562  bool IsExactMatch = Name.size() == MatchSize;
563  return IsExactMatch || isOverloaded(ID) ? ID : Intrinsic::not_intrinsic;
564 }
565 
567  StringRef Name = getName();
568  if (!Name.startswith("llvm.")) {
569  HasLLVMReservedName = false;
570  IntID = Intrinsic::not_intrinsic;
571  return;
572  }
573  HasLLVMReservedName = true;
574  IntID = lookupIntrinsicID(Name);
575 }
576 
577 /// Returns a stable mangling for the type specified for use in the name
578 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
579 /// of named types is simply their name. Manglings for unnamed types consist
580 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
581 /// combined with the mangling of their component types. A vararg function
582 /// type will have a suffix of 'vararg'. Since function types can contain
583 /// other function types, we close a function type mangling with suffix 'f'
584 /// which can't be confused with it's prefix. This ensures we don't have
585 /// collisions between two unrelated function types. Otherwise, you might
586 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
587 ///
588 static std::string getMangledTypeStr(Type* Ty) {
589  std::string Result;
590  if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
591  Result += "p" + utostr(PTyp->getAddressSpace()) +
592  getMangledTypeStr(PTyp->getElementType());
593  } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
594  Result += "a" + utostr(ATyp->getNumElements()) +
595  getMangledTypeStr(ATyp->getElementType());
596  } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
597  if (!STyp->isLiteral()) {
598  Result += "s_";
599  Result += STyp->getName();
600  } else {
601  Result += "sl_";
602  for (auto Elem : STyp->elements())
603  Result += getMangledTypeStr(Elem);
604  }
605  // Ensure nested structs are distinguishable.
606  Result += "s";
607  } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
608  Result += "f_" + getMangledTypeStr(FT->getReturnType());
609  for (size_t i = 0; i < FT->getNumParams(); i++)
610  Result += getMangledTypeStr(FT->getParamType(i));
611  if (FT->isVarArg())
612  Result += "vararg";
613  // Ensure nested function types are distinguishable.
614  Result += "f";
615  } else if (VectorType* VTy = dyn_cast<VectorType>(Ty)) {
616  if (VTy->isScalable())
617  Result += "nx";
618  Result += "v" + utostr(VTy->getVectorNumElements()) +
619  getMangledTypeStr(VTy->getVectorElementType());
620  } else if (Ty) {
621  switch (Ty->getTypeID()) {
622  default: llvm_unreachable("Unhandled type");
623  case Type::VoidTyID: Result += "isVoid"; break;
624  case Type::MetadataTyID: Result += "Metadata"; break;
625  case Type::HalfTyID: Result += "f16"; break;
626  case Type::FloatTyID: Result += "f32"; break;
627  case Type::DoubleTyID: Result += "f64"; break;
628  case Type::X86_FP80TyID: Result += "f80"; break;
629  case Type::FP128TyID: Result += "f128"; break;
630  case Type::PPC_FP128TyID: Result += "ppcf128"; break;
631  case Type::X86_MMXTyID: Result += "x86mmx"; break;
632  case Type::IntegerTyID:
633  Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
634  break;
635  }
636  }
637  return Result;
638 }
639 
641  assert(id < num_intrinsics && "Invalid intrinsic ID!");
642  assert(!isOverloaded(id) &&
643  "This version of getName does not support overloading");
644  return IntrinsicNameTable[id];
645 }
646 
647 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
648  assert(id < num_intrinsics && "Invalid intrinsic ID!");
649  std::string Result(IntrinsicNameTable[id]);
650  for (Type *Ty : Tys) {
651  Result += "." + getMangledTypeStr(Ty);
652  }
653  return Result;
654 }
655 
656 /// IIT_Info - These are enumerators that describe the entries returned by the
657 /// getIntrinsicInfoTableEntries function.
658 ///
659 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
660 enum IIT_Info {
661  // Common values should be encoded with 0-15.
662  IIT_Done = 0,
663  IIT_I1 = 1,
664  IIT_I8 = 2,
665  IIT_I16 = 3,
666  IIT_I32 = 4,
667  IIT_I64 = 5,
668  IIT_F16 = 6,
669  IIT_F32 = 7,
670  IIT_F64 = 8,
671  IIT_V2 = 9,
672  IIT_V4 = 10,
673  IIT_V8 = 11,
674  IIT_V16 = 12,
675  IIT_V32 = 13,
676  IIT_PTR = 14,
677  IIT_ARG = 15,
678 
679  // Values from 16+ are only encodable with the inefficient encoding.
680  IIT_V64 = 16,
681  IIT_MMX = 17,
682  IIT_TOKEN = 18,
692  IIT_V1 = 28,
699  IIT_I128 = 35,
700  IIT_V512 = 36,
701  IIT_V1024 = 37,
705  IIT_F128 = 41,
711 };
712 
713 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
715  using namespace Intrinsic;
716 
717  IIT_Info Info = IIT_Info(Infos[NextElt++]);
718  unsigned StructElts = 2;
719 
720  switch (Info) {
721  case IIT_Done:
722  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
723  return;
724  case IIT_VARARG:
725  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
726  return;
727  case IIT_MMX:
728  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
729  return;
730  case IIT_TOKEN:
731  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
732  return;
733  case IIT_METADATA:
734  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
735  return;
736  case IIT_F16:
737  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
738  return;
739  case IIT_F32:
740  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
741  return;
742  case IIT_F64:
743  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
744  return;
745  case IIT_F128:
746  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
747  return;
748  case IIT_I1:
749  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
750  return;
751  case IIT_I8:
752  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
753  return;
754  case IIT_I16:
755  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
756  return;
757  case IIT_I32:
758  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
759  return;
760  case IIT_I64:
761  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
762  return;
763  case IIT_I128:
764  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
765  return;
766  case IIT_V1:
767  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
768  DecodeIITType(NextElt, Infos, OutputTable);
769  return;
770  case IIT_V2:
771  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
772  DecodeIITType(NextElt, Infos, OutputTable);
773  return;
774  case IIT_V4:
775  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
776  DecodeIITType(NextElt, Infos, OutputTable);
777  return;
778  case IIT_V8:
779  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
780  DecodeIITType(NextElt, Infos, OutputTable);
781  return;
782  case IIT_V16:
783  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
784  DecodeIITType(NextElt, Infos, OutputTable);
785  return;
786  case IIT_V32:
787  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
788  DecodeIITType(NextElt, Infos, OutputTable);
789  return;
790  case IIT_V64:
791  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64));
792  DecodeIITType(NextElt, Infos, OutputTable);
793  return;
794  case IIT_V512:
795  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512));
796  DecodeIITType(NextElt, Infos, OutputTable);
797  return;
798  case IIT_V1024:
799  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024));
800  DecodeIITType(NextElt, Infos, OutputTable);
801  return;
802  case IIT_PTR:
803  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
804  DecodeIITType(NextElt, Infos, OutputTable);
805  return;
806  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
807  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
808  Infos[NextElt++]));
809  DecodeIITType(NextElt, Infos, OutputTable);
810  return;
811  }
812  case IIT_ARG: {
813  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
814  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
815  return;
816  }
817  case IIT_EXTEND_ARG: {
818  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
819  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
820  ArgInfo));
821  return;
822  }
823  case IIT_TRUNC_ARG: {
824  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
825  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
826  ArgInfo));
827  return;
828  }
829  case IIT_HALF_VEC_ARG: {
830  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
831  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
832  ArgInfo));
833  return;
834  }
835  case IIT_SAME_VEC_WIDTH_ARG: {
836  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
837  OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
838  ArgInfo));
839  return;
840  }
841  case IIT_PTR_TO_ARG: {
842  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
843  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
844  ArgInfo));
845  return;
846  }
847  case IIT_PTR_TO_ELT: {
848  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
849  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
850  return;
851  }
853  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
854  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
855  OutputTable.push_back(
856  IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));
857  return;
858  }
859  case IIT_EMPTYSTRUCT:
860  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
861  return;
862  case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
863  case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
864  case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
865  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
866  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
867  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
868  case IIT_STRUCT2: {
869  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
870 
871  for (unsigned i = 0; i != StructElts; ++i)
872  DecodeIITType(NextElt, Infos, OutputTable);
873  return;
874  }
875  case IIT_SUBDIVIDE2_ARG: {
876  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
877  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide2Argument,
878  ArgInfo));
879  return;
880  }
881  case IIT_SUBDIVIDE4_ARG: {
882  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
883  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Subdivide4Argument,
884  ArgInfo));
885  return;
886  }
887  case IIT_VEC_ELEMENT: {
888  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
889  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecElementArgument,
890  ArgInfo));
891  return;
892  }
893  case IIT_SCALABLE_VEC: {
894  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ScalableVecArgument,
895  0));
896  DecodeIITType(NextElt, Infos, OutputTable);
897  return;
898  }
900  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
901  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfBitcastsToInt,
902  ArgInfo));
903  return;
904  }
905  }
906  llvm_unreachable("unhandled");
907 }
908 
909 #define GET_INTRINSIC_GENERATOR_GLOBAL
910 #include "llvm/IR/IntrinsicImpl.inc"
911 #undef GET_INTRINSIC_GENERATOR_GLOBAL
912 
915  // Check to see if the intrinsic's type was expressible by the table.
916  unsigned TableVal = IIT_Table[id-1];
917 
918  // Decode the TableVal into an array of IITValues.
920  ArrayRef<unsigned char> IITEntries;
921  unsigned NextElt = 0;
922  if ((TableVal >> 31) != 0) {
923  // This is an offset into the IIT_LongEncodingTable.
924  IITEntries = IIT_LongEncodingTable;
925 
926  // Strip sentinel bit.
927  NextElt = (TableVal << 1) >> 1;
928  } else {
929  // Decode the TableVal into an array of IITValues. If the entry was encoded
930  // into a single word in the table itself, decode it now.
931  do {
932  IITValues.push_back(TableVal & 0xF);
933  TableVal >>= 4;
934  } while (TableVal);
935 
936  IITEntries = IITValues;
937  NextElt = 0;
938  }
939 
940  // Okay, decode the table into the output vector of IITDescriptors.
941  DecodeIITType(NextElt, IITEntries, T);
942  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
943  DecodeIITType(NextElt, IITEntries, T);
944 }
945 
948  using namespace Intrinsic;
949 
950  IITDescriptor D = Infos.front();
951  Infos = Infos.slice(1);
952 
953  switch (D.Kind) {
954  case IITDescriptor::Void: return Type::getVoidTy(Context);
955  case IITDescriptor::VarArg: return Type::getVoidTy(Context);
956  case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
957  case IITDescriptor::Token: return Type::getTokenTy(Context);
958  case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
959  case IITDescriptor::Half: return Type::getHalfTy(Context);
960  case IITDescriptor::Float: return Type::getFloatTy(Context);
961  case IITDescriptor::Double: return Type::getDoubleTy(Context);
962  case IITDescriptor::Quad: return Type::getFP128Ty(Context);
963 
965  return IntegerType::get(Context, D.Integer_Width);
967  return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
968  case IITDescriptor::Pointer:
969  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
970  D.Pointer_AddressSpace);
971  case IITDescriptor::Struct: {
973  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
974  Elts.push_back(DecodeFixedType(Infos, Tys, Context));
975  return StructType::get(Context, Elts);
976  }
977  case IITDescriptor::Argument:
978  return Tys[D.getArgumentNumber()];
979  case IITDescriptor::ExtendArgument: {
980  Type *Ty = Tys[D.getArgumentNumber()];
981  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
983 
984  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
985  }
986  case IITDescriptor::TruncArgument: {
987  Type *Ty = Tys[D.getArgumentNumber()];
988  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
990 
991  IntegerType *ITy = cast<IntegerType>(Ty);
992  assert(ITy->getBitWidth() % 2 == 0);
993  return IntegerType::get(Context, ITy->getBitWidth() / 2);
994  }
995  case IITDescriptor::Subdivide2Argument:
996  case IITDescriptor::Subdivide4Argument: {
997  Type *Ty = Tys[D.getArgumentNumber()];
998  VectorType *VTy = dyn_cast<VectorType>(Ty);
999  assert(VTy && "Expected an argument of Vector Type");
1000  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1001  return VectorType::getSubdividedVectorType(VTy, SubDivs);
1002  }
1003  case IITDescriptor::HalfVecArgument:
1004  return VectorType::getHalfElementsVectorType(cast<VectorType>(
1005  Tys[D.getArgumentNumber()]));
1006  case IITDescriptor::SameVecWidthArgument: {
1007  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
1008  Type *Ty = Tys[D.getArgumentNumber()];
1009  if (auto *VTy = dyn_cast<VectorType>(Ty))
1010  return VectorType::get(EltTy, VTy->getElementCount());
1011  return EltTy;
1012  }
1013  case IITDescriptor::PtrToArgument: {
1014  Type *Ty = Tys[D.getArgumentNumber()];
1015  return PointerType::getUnqual(Ty);
1016  }
1017  case IITDescriptor::PtrToElt: {
1018  Type *Ty = Tys[D.getArgumentNumber()];
1019  VectorType *VTy = dyn_cast<VectorType>(Ty);
1020  if (!VTy)
1021  llvm_unreachable("Expected an argument of Vector Type");
1022  Type *EltTy = VTy->getVectorElementType();
1023  return PointerType::getUnqual(EltTy);
1024  }
1025  case IITDescriptor::VecElementArgument: {
1026  Type *Ty = Tys[D.getArgumentNumber()];
1027  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
1028  return VTy->getElementType();
1029  llvm_unreachable("Expected an argument of Vector Type");
1030  }
1031  case IITDescriptor::VecOfBitcastsToInt: {
1032  Type *Ty = Tys[D.getArgumentNumber()];
1033  VectorType *VTy = dyn_cast<VectorType>(Ty);
1034  assert(VTy && "Expected an argument of Vector Type");
1035  return VectorType::getInteger(VTy);
1036  }
1037  case IITDescriptor::VecOfAnyPtrsToElt:
1038  // Return the overloaded type (which determines the pointers address space)
1039  return Tys[D.getOverloadArgNumber()];
1040  case IITDescriptor::ScalableVecArgument: {
1041  Type *Ty = DecodeFixedType(Infos, Tys, Context);
1043  { Ty->getVectorNumElements(), true });
1044  }
1045  }
1046  llvm_unreachable("unhandled");
1047 }
1048 
1050  ID id, ArrayRef<Type*> Tys) {
1052  getIntrinsicInfoTableEntries(id, Table);
1053 
1055  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
1056 
1057  SmallVector<Type*, 8> ArgTys;
1058  while (!TableRef.empty())
1059  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
1060 
1061  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
1062  // If we see void type as the type of the last argument, it is vararg intrinsic
1063  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
1064  ArgTys.pop_back();
1065  return FunctionType::get(ResultTy, ArgTys, true);
1066  }
1067  return FunctionType::get(ResultTy, ArgTys, false);
1068 }
1069 
1071 #define GET_INTRINSIC_OVERLOAD_TABLE
1072 #include "llvm/IR/IntrinsicImpl.inc"
1073 #undef GET_INTRINSIC_OVERLOAD_TABLE
1074 }
1075 
1077  switch (id) {
1078  default:
1079  return true;
1080 
1081  case Intrinsic::experimental_gc_statepoint:
1082  case Intrinsic::experimental_patchpoint_void:
1083  case Intrinsic::experimental_patchpoint_i64:
1084  return false;
1085  }
1086 }
1087 
1088 /// This defines the "Intrinsic::getAttributes(ID id)" method.
1089 #define GET_INTRINSIC_ATTRIBUTES
1090 #include "llvm/IR/IntrinsicImpl.inc"
1091 #undef GET_INTRINSIC_ATTRIBUTES
1092 
1094  // There can never be multiple globals with the same name of different types,
1095  // because intrinsics must be a specific type.
1096  return cast<Function>(
1097  M->getOrInsertFunction(getName(id, Tys),
1098  getType(M->getContext(), id, Tys))
1099  .getCallee());
1100 }
1101 
1102 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1103 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1104 #include "llvm/IR/IntrinsicImpl.inc"
1105 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1106 
1107 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1108 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1109 #include "llvm/IR/IntrinsicImpl.inc"
1110 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1111 
1113  std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;
1114 
1117  SmallVectorImpl<Type *> &ArgTys,
1119  bool IsDeferredCheck) {
1120  using namespace Intrinsic;
1121 
1122  // If we ran out of descriptors, there are too many arguments.
1123  if (Infos.empty()) return true;
1124 
1125  // Do this before slicing off the 'front' part
1126  auto InfosRef = Infos;
1127  auto DeferCheck = [&DeferredChecks, &InfosRef](Type *T) {
1128  DeferredChecks.emplace_back(T, InfosRef);
1129  return false;
1130  };
1131 
1132  IITDescriptor D = Infos.front();
1133  Infos = Infos.slice(1);
1134 
1135  switch (D.Kind) {
1136  case IITDescriptor::Void: return !Ty->isVoidTy();
1137  case IITDescriptor::VarArg: return true;
1138  case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1139  case IITDescriptor::Token: return !Ty->isTokenTy();
1140  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1141  case IITDescriptor::Half: return !Ty->isHalfTy();
1142  case IITDescriptor::Float: return !Ty->isFloatTy();
1143  case IITDescriptor::Double: return !Ty->isDoubleTy();
1144  case IITDescriptor::Quad: return !Ty->isFP128Ty();
1145  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1146  case IITDescriptor::Vector: {
1147  VectorType *VT = dyn_cast<VectorType>(Ty);
1148  return !VT || VT->getNumElements() != D.Vector_Width ||
1149  matchIntrinsicType(VT->getElementType(), Infos, ArgTys,
1150  DeferredChecks, IsDeferredCheck);
1151  }
1152  case IITDescriptor::Pointer: {
1153  PointerType *PT = dyn_cast<PointerType>(Ty);
1154  return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
1155  matchIntrinsicType(PT->getElementType(), Infos, ArgTys,
1156  DeferredChecks, IsDeferredCheck);
1157  }
1158 
1159  case IITDescriptor::Struct: {
1160  StructType *ST = dyn_cast<StructType>(Ty);
1161  if (!ST || ST->getNumElements() != D.Struct_NumElements)
1162  return true;
1163 
1164  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1165  if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys,
1166  DeferredChecks, IsDeferredCheck))
1167  return true;
1168  return false;
1169  }
1170 
1171  case IITDescriptor::Argument:
1172  // If this is the second occurrence of an argument,
1173  // verify that the later instance matches the previous instance.
1174  if (D.getArgumentNumber() < ArgTys.size())
1175  return Ty != ArgTys[D.getArgumentNumber()];
1176 
1177  if (D.getArgumentNumber() > ArgTys.size() ||
1178  D.getArgumentKind() == IITDescriptor::AK_MatchType)
1179  return IsDeferredCheck || DeferCheck(Ty);
1180 
1181  assert(D.getArgumentNumber() == ArgTys.size() && !IsDeferredCheck &&
1182  "Table consistency error");
1183  ArgTys.push_back(Ty);
1184 
1185  switch (D.getArgumentKind()) {
1186  case IITDescriptor::AK_Any: return false; // Success
1187  case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
1188  case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1189  case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1190  case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1191  default: break;
1192  }
1193  llvm_unreachable("all argument kinds not covered");
1194 
1195  case IITDescriptor::ExtendArgument: {
1196  // If this is a forward reference, defer the check for later.
1197  if (D.getArgumentNumber() >= ArgTys.size())
1198  return IsDeferredCheck || DeferCheck(Ty);
1199 
1200  Type *NewTy = ArgTys[D.getArgumentNumber()];
1201  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1203  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1204  NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1205  else
1206  return true;
1207 
1208  return Ty != NewTy;
1209  }
1210  case IITDescriptor::TruncArgument: {
1211  // If this is a forward reference, defer the check for later.
1212  if (D.getArgumentNumber() >= ArgTys.size())
1213  return IsDeferredCheck || DeferCheck(Ty);
1214 
1215  Type *NewTy = ArgTys[D.getArgumentNumber()];
1216  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1218  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1219  NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1220  else
1221  return true;
1222 
1223  return Ty != NewTy;
1224  }
1225  case IITDescriptor::HalfVecArgument:
1226  // If this is a forward reference, defer the check for later.
1227  if (D.getArgumentNumber() >= ArgTys.size())
1228  return IsDeferredCheck || DeferCheck(Ty);
1229  return !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1231  cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1232  case IITDescriptor::SameVecWidthArgument: {
1233  if (D.getArgumentNumber() >= ArgTys.size()) {
1234  // Defer check and subsequent check for the vector element type.
1235  Infos = Infos.slice(1);
1236  return IsDeferredCheck || DeferCheck(Ty);
1237  }
1238  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1239  auto *ThisArgType = dyn_cast<VectorType>(Ty);
1240  // Both must be vectors of the same number of elements or neither.
1241  if ((ReferenceType != nullptr) != (ThisArgType != nullptr))
1242  return true;
1243  Type *EltTy = Ty;
1244  if (ThisArgType) {
1245  if (ReferenceType->getElementCount() !=
1246  ThisArgType->getElementCount())
1247  return true;
1248  EltTy = ThisArgType->getVectorElementType();
1249  }
1250  return matchIntrinsicType(EltTy, Infos, ArgTys, DeferredChecks,
1251  IsDeferredCheck);
1252  }
1253  case IITDescriptor::PtrToArgument: {
1254  if (D.getArgumentNumber() >= ArgTys.size())
1255  return IsDeferredCheck || DeferCheck(Ty);
1256  Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1257  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1258  return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
1259  }
1260  case IITDescriptor::PtrToElt: {
1261  if (D.getArgumentNumber() >= ArgTys.size())
1262  return IsDeferredCheck || DeferCheck(Ty);
1264  dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1265  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1266 
1267  return (!ThisArgType || !ReferenceType ||
1268  ThisArgType->getElementType() != ReferenceType->getElementType());
1269  }
1270  case IITDescriptor::VecOfAnyPtrsToElt: {
1271  unsigned RefArgNumber = D.getRefArgNumber();
1272  if (RefArgNumber >= ArgTys.size()) {
1273  if (IsDeferredCheck)
1274  return true;
1275  // If forward referencing, already add the pointer-vector type and
1276  // defer the checks for later.
1277  ArgTys.push_back(Ty);
1278  return DeferCheck(Ty);
1279  }
1280 
1281  if (!IsDeferredCheck){
1282  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1283  "Table consistency error");
1284  ArgTys.push_back(Ty);
1285  }
1286 
1287  // Verify the overloaded type "matches" the Ref type.
1288  // i.e. Ty is a vector with the same width as Ref.
1289  // Composed of pointers to the same element type as Ref.
1290  VectorType *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1291  VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1292  if (!ThisArgVecTy || !ReferenceType ||
1293  (ReferenceType->getVectorNumElements() !=
1294  ThisArgVecTy->getVectorNumElements()))
1295  return true;
1296  PointerType *ThisArgEltTy =
1297  dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());
1298  if (!ThisArgEltTy)
1299  return true;
1300  return ThisArgEltTy->getElementType() !=
1301  ReferenceType->getVectorElementType();
1302  }
1303  case IITDescriptor::VecElementArgument: {
1304  if (D.getArgumentNumber() >= ArgTys.size())
1305  return IsDeferredCheck ? true : DeferCheck(Ty);
1306  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1307  return !ReferenceType || Ty != ReferenceType->getElementType();
1308  }
1309  case IITDescriptor::Subdivide2Argument:
1310  case IITDescriptor::Subdivide4Argument: {
1311  // If this is a forward reference, defer the check for later.
1312  if (D.getArgumentNumber() >= ArgTys.size())
1313  return IsDeferredCheck || DeferCheck(Ty);
1314 
1315  Type *NewTy = ArgTys[D.getArgumentNumber()];
1316  if (auto *VTy = dyn_cast<VectorType>(NewTy)) {
1317  int SubDivs = D.Kind == IITDescriptor::Subdivide2Argument ? 1 : 2;
1318  NewTy = VectorType::getSubdividedVectorType(VTy, SubDivs);
1319  return Ty != NewTy;
1320  }
1321  return true;
1322  }
1323  case IITDescriptor::ScalableVecArgument: {
1324  VectorType *VTy = dyn_cast<VectorType>(Ty);
1325  if (!VTy || !VTy->isScalable())
1326  return true;
1327  return matchIntrinsicType(VTy, Infos, ArgTys, DeferredChecks,
1328  IsDeferredCheck);
1329  }
1330  case IITDescriptor::VecOfBitcastsToInt: {
1331  if (D.getArgumentNumber() >= ArgTys.size())
1332  return IsDeferredCheck || DeferCheck(Ty);
1333  auto *ReferenceType = dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1334  auto *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1335  if (!ThisArgVecTy || !ReferenceType)
1336  return true;
1337  return ThisArgVecTy != VectorType::getInteger(ReferenceType);
1338  }
1339  }
1340  llvm_unreachable("unhandled");
1341 }
1342 
1346  SmallVectorImpl<Type *> &ArgTys) {
1348  if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
1349  false))
1351 
1352  unsigned NumDeferredReturnChecks = DeferredChecks.size();
1353 
1354  for (auto Ty : FTy->params())
1355  if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
1357 
1358  for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
1359  DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
1360  if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
1361  true))
1362  return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
1364  }
1365 
1367 }
1368 
1369 bool
1372  // If there are no descriptors left, then it can't be a vararg.
1373  if (Infos.empty())
1374  return isVarArg;
1375 
1376  // There should be only one descriptor remaining at this point.
1377  if (Infos.size() != 1)
1378  return true;
1379 
1380  // Check and verify the descriptor.
1381  IITDescriptor D = Infos.front();
1382  Infos = Infos.slice(1);
1383  if (D.Kind == IITDescriptor::VarArg)
1384  return !isVarArg;
1385 
1386  return true;
1387 }
1388 
1391  if (!ID)
1392  return None;
1393 
1394  FunctionType *FTy = F->getFunctionType();
1395  // Accumulate an array of overloaded types for the given intrinsic
1396  SmallVector<Type *, 4> ArgTys;
1397  {
1399  getIntrinsicInfoTableEntries(ID, Table);
1401 
1402  if (Intrinsic::matchIntrinsicSignature(FTy, TableRef, ArgTys))
1403  return None;
1404  if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef))
1405  return None;
1406  }
1407 
1408  StringRef Name = F->getName();
1409  if (Name == Intrinsic::getName(ID, ArgTys))
1410  return None;
1411 
1412  auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1413  NewDecl->setCallingConv(F->getCallingConv());
1414  assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature");
1415  return NewDecl;
1416 }
1417 
1418 /// hasAddressTaken - returns true if there are any uses of this function
1419 /// other than direct calls or invokes to it.
1420 bool Function::hasAddressTaken(const User* *PutOffender) const {
1421  for (const Use &U : uses()) {
1422  const User *FU = U.getUser();
1423  if (isa<BlockAddress>(FU))
1424  continue;
1425  const auto *Call = dyn_cast<CallBase>(FU);
1426  if (!Call) {
1427  if (PutOffender)
1428  *PutOffender = FU;
1429  return true;
1430  }
1431  if (!Call->isCallee(&U)) {
1432  if (PutOffender)
1433  *PutOffender = FU;
1434  return true;
1435  }
1436  }
1437  return false;
1438 }
1439 
1441  // Check the linkage
1442  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1443  !hasAvailableExternallyLinkage())
1444  return false;
1445 
1446  // Check if the function is used by anything other than a blockaddress.
1447  for (const User *U : users())
1448  if (!isa<BlockAddress>(U))
1449  return false;
1450 
1451  return true;
1452 }
1453 
1454 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1455 /// setjmp or other function that gcc recognizes as "returning twice".
1457  for (const Instruction &I : instructions(this))
1458  if (const auto *Call = dyn_cast<CallBase>(&I))
1459  if (Call->hasFnAttr(Attribute::ReturnsTwice))
1460  return true;
1461 
1462  return false;
1463 }
1464 
1466  assert(hasPersonalityFn() && getNumOperands());
1467  return cast<Constant>(Op<0>());
1468 }
1469 
1471  setHungoffOperand<0>(Fn);
1472  setValueSubclassDataBit(3, Fn != nullptr);
1473 }
1474 
1476  assert(hasPrefixData() && getNumOperands());
1477  return cast<Constant>(Op<1>());
1478 }
1479 
1481  setHungoffOperand<1>(PrefixData);
1482  setValueSubclassDataBit(1, PrefixData != nullptr);
1483 }
1484 
1486  assert(hasPrologueData() && getNumOperands());
1487  return cast<Constant>(Op<2>());
1488 }
1489 
1491  setHungoffOperand<2>(PrologueData);
1492  setValueSubclassDataBit(2, PrologueData != nullptr);
1493 }
1494 
1495 void Function::allocHungoffUselist() {
1496  // If we've already allocated a uselist, stop here.
1497  if (getNumOperands())
1498  return;
1499 
1500  allocHungoffUses(3, /*IsPhi=*/ false);
1501  setNumHungOffUseOperands(3);
1502 
1503  // Initialize the uselist with placeholder operands to allow traversal.
1505  Op<0>().set(CPN);
1506  Op<1>().set(CPN);
1507  Op<2>().set(CPN);
1508 }
1509 
1510 template <int Idx>
1511 void Function::setHungoffOperand(Constant *C) {
1512  if (C) {
1513  allocHungoffUselist();
1514  Op<Idx>().set(C);
1515  } else if (getNumOperands()) {
1516  Op<Idx>().set(
1518  }
1519 }
1520 
1521 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1522  assert(Bit < 16 && "SubclassData contains only 16 bits");
1523  if (On)
1525  else
1527 }
1528 
1530  const DenseSet<GlobalValue::GUID> *S) {
1531  assert(Count.hasValue());
1532 #if !defined(NDEBUG)
1533  auto PrevCount = getEntryCount();
1534  assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType());
1535 #endif
1536  MDBuilder MDB(getContext());
1537  setMetadata(
1538  LLVMContext::MD_prof,
1539  MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1540 }
1541 
1543  const DenseSet<GlobalValue::GUID> *Imports) {
1544  setEntryCount(ProfileCount(Count, Type), Imports);
1545 }
1546 
1547 ProfileCount Function::getEntryCount(bool AllowSynthetic) const {
1548  MDNode *MD = getMetadata(LLVMContext::MD_prof);
1549  if (MD && MD->getOperand(0))
1550  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
1551  if (MDS->getString().equals("function_entry_count")) {
1552  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1553  uint64_t Count = CI->getValue().getZExtValue();
1554  // A value of -1 is used for SamplePGO when there were no samples.
1555  // Treat this the same as unknown.
1556  if (Count == (uint64_t)-1)
1557  return ProfileCount::getInvalid();
1558  return ProfileCount(Count, PCT_Real);
1559  } else if (AllowSynthetic &&
1560  MDS->getString().equals("synthetic_function_entry_count")) {
1561  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1562  uint64_t Count = CI->getValue().getZExtValue();
1563  return ProfileCount(Count, PCT_Synthetic);
1564  }
1565  }
1566  return ProfileCount::getInvalid();
1567 }
1568 
1571  if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1572  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1573  if (MDS->getString().equals("function_entry_count"))
1574  for (unsigned i = 2; i < MD->getNumOperands(); i++)
1575  R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
1576  ->getValue()
1577  .getZExtValue());
1578  return R;
1579 }
1580 
1582  MDBuilder MDB(getContext());
1583  setMetadata(LLVMContext::MD_section_prefix,
1584  MDB.createFunctionSectionPrefix(Prefix));
1585 }
1586 
1588  if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
1589  assert(cast<MDString>(MD->getOperand(0))
1590  ->getString()
1591  .equals("function_section_prefix") &&
1592  "Metadata not match");
1593  return cast<MDString>(MD->getOperand(1))->getString();
1594  }
1595  return None;
1596 }
1597 
1599  return getFnAttribute("null-pointer-is-valid")
1600  .getValueAsString()
1601  .equals("true");
1602 }
1603 
1604 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
1605  if (F && F->nullPointerIsDefined())
1606  return true;
1607 
1608  if (AS != 0)
1609  return true;
1610 
1611  return false;
1612 }
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:151
bool hasNestAttr() const
Return true if this argument has the nest attribute.
Definition: Function.cpp:133
static bool Check(DecodeStatus &Out, DecodeStatus In)
Type * getVectorElementType() const
Definition: Type.h:375
uint64_t CallInst * C
unsigned short getSubclassDataFromValue() const
Definition: Value.h:714
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:641
iterator_range< use_iterator > uses()
Definition: Value.h:375
bool hasAttribute(Attribute::AttrKind Kind) const
Check if an argument has a given attribute.
Definition: Function.cpp:193
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:435
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:169
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1571
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
LLVMContext & Context
uint64_t getDereferenceableOrNullBytes() const
If this argument has the dereferenceable_or_null attribute, return the number of bytes known to be de...
Definition: Function.cpp:127
void dropAllReferences()
Drop all references to operands.
Definition: User.h:294
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:454
bool isMetadataTy() const
Return true if this is &#39;metadata&#39;.
Definition: Type.h:191
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:351
void removeAttr(Attribute::AttrKind Kind)
Remove attributes from an argument.
Definition: Function.cpp:189
Argument(Type *Ty, const Twine &Name="", Function *F=nullptr, unsigned ArgNo=0)
Argument constructor.
Definition: Function.cpp:66
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:399
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
2: 32-bit floating point type
Definition: Type.h:59
const std::string & getGC(const Function &Fn)
Return the GC for a function.
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
Definition: Function.cpp:453
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in this function.
Definition: Function.cpp:209
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:270
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:350
void clearGC()
Definition: Function.cpp:488
unsigned getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:435
bool hasByValOrInAllocaAttr() const
Return true if this argument has the byval attribute or inalloca attribute.
Definition: Function.cpp:104
bool isFP128Ty() const
Return true if this is &#39;fp128&#39;.
Definition: Type.h:156
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
void setGC(std::string Str)
Definition: Function.cpp:483
This file contains the declarations for metadata subclasses.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:637
The two locations do not alias at all.
Definition: AliasAnalysis.h:84
void addAttrs(AttrBuilder &B)
Add attributes to an argument.
Definition: Function.cpp:175
bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
Definition: Function.cpp:1070
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:743
static MutableArrayRef< Argument > makeArgArray(Argument *Args, size_t Count)
Definition: Function.cpp:301
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:750
void setSectionPrefix(StringRef Prefix)
Set the section prefix for this function.
Definition: Function.cpp:1581
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1165
Metadata node.
Definition: Metadata.h:863
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1100
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:61
This is a type descriptor which explains the type requirements of an intrinsic.
Definition: Intrinsics.h:97
static bool isValidReturnType(Type *RetTy)
Return true if the specified type is valid as a return type.
Definition: Type.cpp:331
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
1: 16-bit floating point type
Definition: Type.h:58
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:170
This defines the Use class.
static VectorType * getTruncatedElementVectorType(VectorType *VTy)
Definition: DerivedTypes.h:486
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:175
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:86
LLVM_NODISCARD AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given arg index.
Definition: Attributes.h:497
void removeFromParent()
removeFromParent - This method unlinks &#39;this&#39; from the containing module, but does not delete it...
Definition: Function.cpp:222
DenseSet< GlobalValue::GUID > getImportGUIDs() const
Returns the set of GUIDs that needs to be imported to the function for sample PGO, to enable the same inlines as the profiled optimized binary.
Definition: Function.cpp:1569
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1485
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
Type * getParamByValType() const
If this is a byval argument, return its type.
Definition: Function.cpp:116
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:741
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:171
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:640
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
void setEntryCount(ProfileCount Count, const DenseSet< GlobalValue::GUID > *Imports=nullptr)
Set the entry count for this function.
Definition: Function.cpp:1529
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:168
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:634
Class to represent struct types.
Definition: DerivedTypes.h:238
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
void deleteGC(const Function &Fn)
Remove the GC for a function.
LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &AttrsToRemove) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:477
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:197
This file contains the simple types necessary to represent the attributes associated with functions a...
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
check if an attributes is in the list of attributes.
Definition: Function.h:400
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:285
uint64_t getNumElements() const
For scalable vectors, this will return the minimum number of elements in the vector.
Definition: DerivedTypes.h:398
static 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:346
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1475
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1389
auto partition_point(R &&Range, Predicate P) -> decltype(adl_begin(Range))
Binary search for the first iterator in a range where a predicate is false.
Definition: STLExtras.h:1302
Class to represent function types.
Definition: DerivedTypes.h:108
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
Definition: Function.cpp:660
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:246
LLVM_NODISCARD AttributeList removeAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &AttrsToRemove) const
Remove the specified attributes at the specified index from this attribute list.
bool onlyReadsMemory() const
Return true if this argument has the readonly or readnone attribute.
Definition: Function.cpp:169
Class to represent array types.
Definition: DerivedTypes.h:408
bool isVarArg() const
Definition: DerivedTypes.h:128
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:137
const std::string & getGC() const
Definition: Function.cpp:478
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
Definition: Function.cpp:465
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:223
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:732
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:203
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type *> Tys, LLVMContext &Context)
Definition: Function.cpp:946
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:71
std::pair< Type *, ArrayRef< Intrinsic::IITDescriptor > > DeferredIntrinsicMatchPair
Definition: Function.cpp:1113
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:468
Function * getDeclaration(Module *M, ID id, ArrayRef< Type *> Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1093
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
Class to represent pointers.
Definition: DerivedTypes.h:575
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
Definition: Function.cpp:138
11: Arbitrary bit width integers
Definition: Type.h:71
static std::string getMangledTypeStr(Type *Ty)
Returns a stable mangling for the type specified for use in the name mangling scheme used by &#39;any&#39; ty...
Definition: Function.cpp:588
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:141
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:147
0: type with no size
Definition: Type.h:57
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:216
void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
adds the attributes to the list of attributes for the given arg.
Definition: Function.cpp:411
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:135
void addAttr(Attribute::AttrKind Kind)
Definition: Function.cpp:181
static VectorType * getHalfElementsVectorType(VectorType *VTy)
This static method returns a VectorType with half as many elements as the input type and the same ele...
Definition: DerivedTypes.h:521
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:314
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
LLVM_NODISCARD AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given index.
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1432
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:290
bool isLeaf(ID id)
Returns true if the intrinsic is a leaf, i.e.
Definition: Function.cpp:1076
static Intrinsic::ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
Definition: Function.cpp:547
uint64_t getCount() const
Definition: Function.h:271
const FunctionListType & getFunctionList() const
Get the Module&#39;s list of functions (constant).
Definition: Module.h:533
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:413
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
bool hasNonNullAttr() const
Return true if this argument has the nonnull attribute.
Definition: Function.cpp:75
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
bool hasStructRetAttr() const
Return true if this argument has the sret attribute.
Definition: Function.cpp:148
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:497
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool hasSExtAttr() const
Return true if this argument has the sext attribute.
Definition: Function.cpp:165
void removeAttribute(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:417
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:144
AMDGPU Lower Kernel Arguments
ProfileCount getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1547
LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
Definition: Attributes.h:434
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:135
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: Function.cpp:381
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:165
static VectorType * getInteger(VectorType *VTy)
This static method gets a VectorType with the same number of elements as the input type...
Definition: DerivedTypes.h:468
bool isHalfTy() const
Return true if this is &#39;half&#39;, a 16-bit IEEE fp type.
Definition: Type.h:144
constexpr double e
Definition: MathExtras.h:57
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:63
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:301
bool hasReturnedAttr() const
Return true if this argument has the returned attribute.
Definition: Function.cpp:157
size_t arg_size() const
Definition: Function.h:728
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:603
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics.h.
Definition: Function.cpp:566
Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
gets the specified attribute from the list of attributes.
Definition: Function.h:405
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:182
Optional< StringRef > getSectionPrefix() const
Get the section prefix for this function.
Definition: Function.cpp:1587
Class to represent integer types.
Definition: DerivedTypes.h:40
void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
removes the attribute from the list of attributes.
Definition: Function.cpp:447
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:205
bool hasInAllocaAttr() const
Return true if this argument has the inalloca attribute.
Definition: Function.cpp:99
Class to represent profile counts.
Definition: Function.h:260
size_t size() const
Definition: SmallVector.h:52
static ArrayRef< const char * > findTargetSubtable(StringRef Name)
Find the segment of IntrinsicNameTable for intrinsics with the same target as Name, or the generic table if Name is not target specific.
Definition: Function.cpp:530
C setMetadata(LLVMContext::MD_range, MDNode::get(Context, LowAndHigh))
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const T * data() const
Definition: ArrayRef.h:145
static Type * getFP128Ty(LLVMContext &C)
Definition: Type.cpp:173
LLVM_NODISCARD AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:462
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:167
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:244
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const
Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
static PointerType * getInt1PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1370
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the generic address space (address sp...
Definition: DerivedTypes.h:590
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
bool isScalable() const
Returns whether or not this is a scalable vector (meaning the total element count is a multiple of th...
Definition: DerivedTypes.h:550
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:913
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:212
unsigned getParamAlignment() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:111
Module.h This file contains the declarations for the Module class.
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type *> Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1049
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:710
bool hasSwiftSelfAttr() const
Return true if this argument has the swiftself attribute.
Definition: Function.cpp:91
MatchIntrinsicTypesResult matchIntrinsicSignature(FunctionType *FTy, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type *> &ArgTys)
Match the specified function type with the type constraints specified by the .td file.
Definition: Function.cpp:1344
Type * getReturnType() const
Definition: DerivedTypes.h:129
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:359
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:287
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static ProfileCount getInvalid()
Definition: Function.h:281
FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:223
bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
Definition: Function.cpp:1604
void setValueSubclassData(unsigned short D)
Definition: Value.h:715
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:226
static VectorType * getExtendedElementVectorType(VectorType *VTy)
This static method is like getInteger except that the element types are twice as wide as the elements...
Definition: DerivedTypes.h:477
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:193
8: Metadata
Definition: Type.h:65
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:566
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:163
Class to represent vector types.
Definition: DerivedTypes.h:432
Target - Wrapper for Target specific information.
void push_back(pointer val)
Definition: ilist.h:311
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Argument.h:47
iterator_range< user_iterator > users()
Definition: Value.h:420
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:178
static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)
Definition: Function.cpp:713
static unsigned computeAddrSpace(unsigned AddrSpace, Module *M)
Definition: Function.cpp:234
Function::ProfileCount ProfileCount
Definition: Function.cpp:56
void removeAttributes(unsigned i, const AttrBuilder &Attrs)
removes the attributes from the list of attributes.
Definition: Function.cpp:429
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a parameter.
Definition: Function.h:440
LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:351
bool hasInRegAttr() const
Return true if this argument has the inreg attribute.
Definition: Function.cpp:153
const Function * getParent() const
Definition: Argument.h:41
LLVM_NODISCARD AttributeList addDereferenceableAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:614
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
bool hasSwiftErrorAttr() const
Return true if this argument has the swifterror attribute.
Definition: Function.cpp:95
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1490
static VectorType * getSubdividedVectorType(VectorType *VTy, int NumSubdivs)
Definition: DerivedTypes.h:511
Compile-time customization of User operands.
Definition: User.h:42
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:226
LLVM_NODISCARD AttributeList addAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &B) const
Add attributes to the attribute set at the given index.
LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given arg index.
Definition: Attributes.h:510
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:1456
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:185
3: 64-bit floating point type
Definition: Type.h:60
bool hasAddressTaken(const User **=nullptr) const
hasAddressTaken - returns true if there are any uses of this function other than direct calls or invo...
Definition: Function.cpp:1420
void addAttributes(unsigned i, const AttrBuilder &Attrs)
adds the attributes to the list of attributes.
Definition: Function.cpp:393
void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes for the given arg...
Definition: Function.cpp:471
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool matchIntrinsicType(Type *Ty, ArrayRef< Intrinsic::IITDescriptor > &Infos, SmallVectorImpl< Type *> &ArgTys, SmallVectorImpl< DeferredIntrinsicMatchPair > &DeferredChecks, bool IsDeferredCheck)
Definition: Function.cpp:1115
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:74
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1465
static const char * name
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:273
ProfileCountType getType() const
Definition: Function.h:272
bool hasZExtAttr() const
Return true if this argument has the zext attribute.
Definition: Function.cpp:161
static const char *const IntrinsicNameTable[]
Table of string intrinsic names indexed by enum value.
Definition: Function.cpp:514
Type * getElementType() const
Definition: DerivedTypes.h:399
MDNode * createFunctionSectionPrefix(StringRef Prefix)
Return metadata containing the section prefix for a function.
Definition: MDBuilder.cpp:78
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
inst_range instructions(Function *F)
Definition: InstIterator.h:133
A single uniqued string.
Definition: Metadata.h:603
int lookupLLVMIntrinsicByName(ArrayRef< const char *> NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1470
bool nullPointerIsDefined() const
Check if null pointer dereferencing is considered undefined behavior for the function.
Definition: Function.cpp:1598
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:66
bool hasNoCaptureAttr() const
Return true if this argument has the nocapture attribute.
Definition: Function.cpp:143
void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes for the given arg.
Definition: Function.cpp:459
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:130
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:150
bool use_empty() const
Definition: Value.h:343
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1440
Attribute getAttribute(Attribute::AttrKind Kind) const
Definition: Function.cpp:197
uint64_t getDereferenceableBytes() const
If this argument has the dereferenceable attribute, return the number of bytes known to be dereferenc...
Definition: Function.cpp:121
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
bool hasLazyArguments() const
hasLazyArguments/CheckLazyArguments - The argument list of a function is built on demand...
Definition: Function.h:104
Type * getElementType() const
Definition: DerivedTypes.h:594
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:233
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:143
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:62
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1480