LLVM  9.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() &&
118  "Only pointers have dereferenceable bytes");
120 }
121 
123  assert(getType()->isPointerTy() &&
124  "Only pointers have dereferenceable bytes");
126 }
127 
128 bool Argument::hasNestAttr() const {
129  if (!getType()->isPointerTy()) return false;
130  return hasAttribute(Attribute::Nest);
131 }
132 
134  if (!getType()->isPointerTy()) return false;
136 }
137 
139  if (!getType()->isPointerTy()) return false;
140  return hasAttribute(Attribute::NoCapture);
141 }
142 
144  if (!getType()->isPointerTy()) return false;
145  return hasAttribute(Attribute::StructRet);
146 }
147 
149  return hasAttribute(Attribute::Returned);
150 }
151 
152 bool Argument::hasZExtAttr() const {
153  return hasAttribute(Attribute::ZExt);
154 }
155 
156 bool Argument::hasSExtAttr() const {
157  return hasAttribute(Attribute::SExt);
158 }
159 
162  return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) ||
163  Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone);
164 }
165 
168  AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
169  getParent()->setAttributes(AL);
170 }
171 
173  getParent()->addParamAttr(getArgNo(), Kind);
174 }
175 
177  getParent()->addParamAttr(getArgNo(), Attr);
178 }
179 
181  getParent()->removeParamAttr(getArgNo(), Kind);
182 }
183 
185  return getParent()->hasParamAttribute(getArgNo(), Kind);
186 }
187 
188 //===----------------------------------------------------------------------===//
189 // Helper Methods in Function
190 //===----------------------------------------------------------------------===//
191 
193  return getType()->getContext();
194 }
195 
197  unsigned NumInstrs = 0;
198  for (const BasicBlock &BB : BasicBlocks)
199  NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
200  BB.instructionsWithoutDebug().end());
201  return NumInstrs;
202 }
203 
205  const Twine &N, Module &M) {
206  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
207 }
208 
210  getParent()->getFunctionList().remove(getIterator());
211 }
212 
214  getParent()->getFunctionList().erase(getIterator());
215 }
216 
217 //===----------------------------------------------------------------------===//
218 // Function Implementation
219 //===----------------------------------------------------------------------===//
220 
221 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
222  // If AS == -1 and we are passed a valid module pointer we place the function
223  // in the program address space. Otherwise we default to AS0.
224  if (AddrSpace == static_cast<unsigned>(-1))
225  return M ? M->getDataLayout().getProgramAddressSpace() : 0;
226  return AddrSpace;
227 }
228 
229 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
230  const Twine &name, Module *ParentModule)
231  : GlobalObject(Ty, Value::FunctionVal,
232  OperandTraits<Function>::op_begin(this), 0, Linkage, name,
233  computeAddrSpace(AddrSpace, ParentModule)),
234  NumArgs(Ty->getNumParams()) {
235  assert(FunctionType::isValidReturnType(getReturnType()) &&
236  "invalid return type");
237  setGlobalObjectSubClassData(0);
238 
239  // We only need a symbol table for a function if the context keeps value names
240  if (!getContext().shouldDiscardValueNames())
241  SymTab = make_unique<ValueSymbolTable>();
242 
243  // If the function has arguments, mark them as lazily built.
244  if (Ty->getNumParams())
245  setValueSubclassData(1); // Set the "has lazy arguments" bit.
246 
247  if (ParentModule)
248  ParentModule->getFunctionList().push_back(this);
249 
250  HasLLVMReservedName = getName().startswith("llvm.");
251  // Ensure intrinsics have the right parameter attributes.
252  // Note, the IntID field will have been set in Value::setName if this function
253  // name is a valid intrinsic ID.
254  if (IntID)
255  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
256 }
257 
259  dropAllReferences(); // After this it is safe to delete instructions.
260 
261  // Delete all of the method arguments and unlink from symbol table...
262  if (Arguments)
263  clearArguments();
264 
265  // Remove the function from the on-the-side GC table.
266  clearGC();
267 }
268 
269 void Function::BuildLazyArguments() const {
270  // Create the arguments vector, all arguments start out unnamed.
271  auto *FT = getFunctionType();
272  if (NumArgs > 0) {
273  Arguments = std::allocator<Argument>().allocate(NumArgs);
274  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
275  Type *ArgTy = FT->getParamType(i);
276  assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
277  new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
278  }
279  }
280 
281  // Clear the lazy arguments bit.
282  unsigned SDC = getSubclassDataFromValue();
283  const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0));
284  assert(!hasLazyArguments());
285 }
286 
288  return MutableArrayRef<Argument>(Args, Count);
289 }
290 
291 void Function::clearArguments() {
292  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
293  A.setName("");
294  A.~Argument();
295  }
296  std::allocator<Argument>().deallocate(Arguments, NumArgs);
297  Arguments = nullptr;
298 }
299 
301  assert(isDeclaration() && "Expected no references to current arguments");
302 
303  // Drop the current arguments, if any, and set the lazy argument bit.
304  if (!hasLazyArguments()) {
306  [](const Argument &A) { return A.use_empty(); }) &&
307  "Expected arguments to be unused in declaration");
308  clearArguments();
310  }
311 
312  // Nothing to steal if Src has lazy arguments.
313  if (Src.hasLazyArguments())
314  return;
315 
316  // Steal arguments from Src, and fix the lazy argument bits.
317  assert(arg_size() == Src.arg_size());
318  Arguments = Src.Arguments;
319  Src.Arguments = nullptr;
320  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
321  // FIXME: This does the work of transferNodesFromList inefficiently.
323  if (A.hasName())
324  Name = A.getName();
325  if (!Name.empty())
326  A.setName("");
327  A.setParent(this);
328  if (!Name.empty())
329  A.setName(Name);
330  }
331 
333  assert(!hasLazyArguments());
334  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
335 }
336 
337 // dropAllReferences() - This function causes all the subinstructions to "let
338 // go" of all references that they are maintaining. This allows one to
339 // 'delete' a whole class at a time, even though there may be circular
340 // references... first all references are dropped, and all use counts go to
341 // zero. Then everything is deleted for real. Note that no operations are
342 // valid on an object that has "dropped all references", except operator
343 // delete.
344 //
346  setIsMaterializable(false);
347 
348  for (BasicBlock &BB : *this)
349  BB.dropAllReferences();
350 
351  // Delete all basic blocks. They are now unused, except possibly by
352  // blockaddresses, but BasicBlock's destructor takes care of those.
353  while (!BasicBlocks.empty())
354  BasicBlocks.begin()->eraseFromParent();
355 
356  // Drop uses of any optional data (real or placeholder).
357  if (getNumOperands()) {
359  setNumHungOffUseOperands(0);
361  }
362 
363  // Metadata is stored in a side-table.
364  clearMetadata();
365 }
366 
369  PAL = PAL.addAttribute(getContext(), i, Kind);
370  setAttributes(PAL);
371 }
372 
373 void Function::addAttribute(unsigned i, Attribute Attr) {
375  PAL = PAL.addAttribute(getContext(), i, Attr);
376  setAttributes(PAL);
377 }
378 
379 void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) {
381  PAL = PAL.addAttributes(getContext(), i, Attrs);
382  setAttributes(PAL);
383 }
384 
387  PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
388  setAttributes(PAL);
389 }
390 
391 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
393  PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
394  setAttributes(PAL);
395 }
396 
397 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
399  PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs);
400  setAttributes(PAL);
401 }
402 
405  PAL = PAL.removeAttribute(getContext(), i, Kind);
406  setAttributes(PAL);
407 }
408 
411  PAL = PAL.removeAttribute(getContext(), i, Kind);
412  setAttributes(PAL);
413 }
414 
415 void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) {
417  PAL = PAL.removeAttributes(getContext(), i, Attrs);
418  setAttributes(PAL);
419 }
420 
423  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
424  setAttributes(PAL);
425 }
426 
427 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
429  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
430  setAttributes(PAL);
431 }
432 
433 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
435  PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
436  setAttributes(PAL);
437 }
438 
439 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
441  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
442  setAttributes(PAL);
443 }
444 
445 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
447  PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
448  setAttributes(PAL);
449 }
450 
451 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
453  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
454  setAttributes(PAL);
455 }
456 
458  uint64_t Bytes) {
460  PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes);
461  setAttributes(PAL);
462 }
463 
464 const std::string &Function::getGC() const {
465  assert(hasGC() && "Function has no collector");
466  return getContext().getGC(*this);
467 }
468 
469 void Function::setGC(std::string Str) {
470  setValueSubclassDataBit(14, !Str.empty());
471  getContext().setGC(*this, std::move(Str));
472 }
473 
475  if (!hasGC())
476  return;
477  getContext().deleteGC(*this);
478  setValueSubclassDataBit(14, false);
479 }
480 
481 /// Copy all additional attributes (those not needed to create a Function) from
482 /// the Function Src to this one.
485  setCallingConv(Src->getCallingConv());
486  setAttributes(Src->getAttributes());
487  if (Src->hasGC())
488  setGC(Src->getGC());
489  else
490  clearGC();
491  if (Src->hasPersonalityFn())
492  setPersonalityFn(Src->getPersonalityFn());
493  if (Src->hasPrefixData())
494  setPrefixData(Src->getPrefixData());
495  if (Src->hasPrologueData())
496  setPrologueData(Src->getPrologueData());
497 }
498 
499 /// Table of string intrinsic names indexed by enum value.
500 static const char * const IntrinsicNameTable[] = {
501  "not_intrinsic",
502 #define GET_INTRINSIC_NAME_TABLE
503 #include "llvm/IR/IntrinsicImpl.inc"
504 #undef GET_INTRINSIC_NAME_TABLE
505 };
506 
507 /// Table of per-target intrinsic name tables.
508 #define GET_INTRINSIC_TARGET_DATA
509 #include "llvm/IR/IntrinsicImpl.inc"
510 #undef GET_INTRINSIC_TARGET_DATA
511 
512 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
513 /// target as \c Name, or the generic table if \c Name is not target specific.
514 ///
515 /// Returns the relevant slice of \c IntrinsicNameTable
517  assert(Name.startswith("llvm."));
518 
519  ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
520  // Drop "llvm." and take the first dotted component. That will be the target
521  // if this is target specific.
522  StringRef Target = Name.drop_front(5).split('.').first;
523  auto It = std::lower_bound(Targets.begin(), Targets.end(), Target,
524  [](const IntrinsicTargetInfo &TI,
525  StringRef Target) { return TI.Name < Target; });
526  // We've either found the target or just fall back to the generic set, which
527  // is always first.
528  const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
529  return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
530 }
531 
532 /// This does the actual lookup of an intrinsic ID which
533 /// matches the given function name.
535  ArrayRef<const char *> NameTable = findTargetSubtable(Name);
536  int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
537  if (Idx == -1)
539 
540  // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
541  // an index into a sub-table.
542  int Adjust = NameTable.data() - IntrinsicNameTable;
543  Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
544 
545  // If the intrinsic is not overloaded, require an exact match. If it is
546  // overloaded, require either exact or prefix match.
547  const auto MatchSize = strlen(NameTable[Idx]);
548  assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
549  bool IsExactMatch = Name.size() == MatchSize;
550  return IsExactMatch || isOverloaded(ID) ? ID : Intrinsic::not_intrinsic;
551 }
552 
554  StringRef Name = getName();
555  if (!Name.startswith("llvm.")) {
556  HasLLVMReservedName = false;
557  IntID = Intrinsic::not_intrinsic;
558  return;
559  }
560  HasLLVMReservedName = true;
561  IntID = lookupIntrinsicID(Name);
562 }
563 
564 /// Returns a stable mangling for the type specified for use in the name
565 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
566 /// of named types is simply their name. Manglings for unnamed types consist
567 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
568 /// combined with the mangling of their component types. A vararg function
569 /// type will have a suffix of 'vararg'. Since function types can contain
570 /// other function types, we close a function type mangling with suffix 'f'
571 /// which can't be confused with it's prefix. This ensures we don't have
572 /// collisions between two unrelated function types. Otherwise, you might
573 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
574 ///
575 static std::string getMangledTypeStr(Type* Ty) {
576  std::string Result;
577  if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
578  Result += "p" + utostr(PTyp->getAddressSpace()) +
579  getMangledTypeStr(PTyp->getElementType());
580  } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
581  Result += "a" + utostr(ATyp->getNumElements()) +
582  getMangledTypeStr(ATyp->getElementType());
583  } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
584  if (!STyp->isLiteral()) {
585  Result += "s_";
586  Result += STyp->getName();
587  } else {
588  Result += "sl_";
589  for (auto Elem : STyp->elements())
590  Result += getMangledTypeStr(Elem);
591  }
592  // Ensure nested structs are distinguishable.
593  Result += "s";
594  } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
595  Result += "f_" + getMangledTypeStr(FT->getReturnType());
596  for (size_t i = 0; i < FT->getNumParams(); i++)
597  Result += getMangledTypeStr(FT->getParamType(i));
598  if (FT->isVarArg())
599  Result += "vararg";
600  // Ensure nested function types are distinguishable.
601  Result += "f";
602  } else if (isa<VectorType>(Ty)) {
603  Result += "v" + utostr(Ty->getVectorNumElements()) +
605  } else if (Ty) {
606  switch (Ty->getTypeID()) {
607  default: llvm_unreachable("Unhandled type");
608  case Type::VoidTyID: Result += "isVoid"; break;
609  case Type::MetadataTyID: Result += "Metadata"; break;
610  case Type::HalfTyID: Result += "f16"; break;
611  case Type::FloatTyID: Result += "f32"; break;
612  case Type::DoubleTyID: Result += "f64"; break;
613  case Type::X86_FP80TyID: Result += "f80"; break;
614  case Type::FP128TyID: Result += "f128"; break;
615  case Type::PPC_FP128TyID: Result += "ppcf128"; break;
616  case Type::X86_MMXTyID: Result += "x86mmx"; break;
617  case Type::IntegerTyID:
618  Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
619  break;
620  }
621  }
622  return Result;
623 }
624 
626  assert(id < num_intrinsics && "Invalid intrinsic ID!");
627  assert(!isOverloaded(id) &&
628  "This version of getName does not support overloading");
629  return IntrinsicNameTable[id];
630 }
631 
632 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
633  assert(id < num_intrinsics && "Invalid intrinsic ID!");
634  std::string Result(IntrinsicNameTable[id]);
635  for (Type *Ty : Tys) {
636  Result += "." + getMangledTypeStr(Ty);
637  }
638  return Result;
639 }
640 
641 /// IIT_Info - These are enumerators that describe the entries returned by the
642 /// getIntrinsicInfoTableEntries function.
643 ///
644 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
645 enum IIT_Info {
646  // Common values should be encoded with 0-15.
647  IIT_Done = 0,
648  IIT_I1 = 1,
649  IIT_I8 = 2,
650  IIT_I16 = 3,
651  IIT_I32 = 4,
652  IIT_I64 = 5,
653  IIT_F16 = 6,
654  IIT_F32 = 7,
655  IIT_F64 = 8,
656  IIT_V2 = 9,
657  IIT_V4 = 10,
658  IIT_V8 = 11,
659  IIT_V16 = 12,
660  IIT_V32 = 13,
661  IIT_PTR = 14,
662  IIT_ARG = 15,
663 
664  // Values from 16+ are only encodable with the inefficient encoding.
665  IIT_V64 = 16,
666  IIT_MMX = 17,
667  IIT_TOKEN = 18,
677  IIT_V1 = 28,
684  IIT_I128 = 35,
685  IIT_V512 = 36,
686  IIT_V1024 = 37,
690  IIT_F128 = 41
691 };
692 
693 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
695  using namespace Intrinsic;
696 
697  IIT_Info Info = IIT_Info(Infos[NextElt++]);
698  unsigned StructElts = 2;
699 
700  switch (Info) {
701  case IIT_Done:
702  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
703  return;
704  case IIT_VARARG:
705  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
706  return;
707  case IIT_MMX:
708  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
709  return;
710  case IIT_TOKEN:
711  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
712  return;
713  case IIT_METADATA:
714  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
715  return;
716  case IIT_F16:
717  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
718  return;
719  case IIT_F32:
720  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
721  return;
722  case IIT_F64:
723  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
724  return;
725  case IIT_F128:
726  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Quad, 0));
727  return;
728  case IIT_I1:
729  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
730  return;
731  case IIT_I8:
732  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
733  return;
734  case IIT_I16:
735  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
736  return;
737  case IIT_I32:
738  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
739  return;
740  case IIT_I64:
741  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
742  return;
743  case IIT_I128:
744  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
745  return;
746  case IIT_V1:
747  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
748  DecodeIITType(NextElt, Infos, OutputTable);
749  return;
750  case IIT_V2:
751  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
752  DecodeIITType(NextElt, Infos, OutputTable);
753  return;
754  case IIT_V4:
755  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
756  DecodeIITType(NextElt, Infos, OutputTable);
757  return;
758  case IIT_V8:
759  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
760  DecodeIITType(NextElt, Infos, OutputTable);
761  return;
762  case IIT_V16:
763  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
764  DecodeIITType(NextElt, Infos, OutputTable);
765  return;
766  case IIT_V32:
767  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
768  DecodeIITType(NextElt, Infos, OutputTable);
769  return;
770  case IIT_V64:
771  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64));
772  DecodeIITType(NextElt, Infos, OutputTable);
773  return;
774  case IIT_V512:
775  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512));
776  DecodeIITType(NextElt, Infos, OutputTable);
777  return;
778  case IIT_V1024:
779  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024));
780  DecodeIITType(NextElt, Infos, OutputTable);
781  return;
782  case IIT_PTR:
783  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
784  DecodeIITType(NextElt, Infos, OutputTable);
785  return;
786  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
787  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
788  Infos[NextElt++]));
789  DecodeIITType(NextElt, Infos, OutputTable);
790  return;
791  }
792  case IIT_ARG: {
793  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
794  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
795  return;
796  }
797  case IIT_EXTEND_ARG: {
798  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
799  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
800  ArgInfo));
801  return;
802  }
803  case IIT_TRUNC_ARG: {
804  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
805  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
806  ArgInfo));
807  return;
808  }
809  case IIT_HALF_VEC_ARG: {
810  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
811  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
812  ArgInfo));
813  return;
814  }
815  case IIT_SAME_VEC_WIDTH_ARG: {
816  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
817  OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
818  ArgInfo));
819  return;
820  }
821  case IIT_PTR_TO_ARG: {
822  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
823  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
824  ArgInfo));
825  return;
826  }
827  case IIT_PTR_TO_ELT: {
828  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
829  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
830  return;
831  }
833  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
834  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
835  OutputTable.push_back(
836  IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));
837  return;
838  }
839  case IIT_EMPTYSTRUCT:
840  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
841  return;
842  case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
843  case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
844  case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
845  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
846  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
847  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
848  case IIT_STRUCT2: {
849  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
850 
851  for (unsigned i = 0; i != StructElts; ++i)
852  DecodeIITType(NextElt, Infos, OutputTable);
853  return;
854  }
855  }
856  llvm_unreachable("unhandled");
857 }
858 
859 #define GET_INTRINSIC_GENERATOR_GLOBAL
860 #include "llvm/IR/IntrinsicImpl.inc"
861 #undef GET_INTRINSIC_GENERATOR_GLOBAL
862 
865  // Check to see if the intrinsic's type was expressible by the table.
866  unsigned TableVal = IIT_Table[id-1];
867 
868  // Decode the TableVal into an array of IITValues.
870  ArrayRef<unsigned char> IITEntries;
871  unsigned NextElt = 0;
872  if ((TableVal >> 31) != 0) {
873  // This is an offset into the IIT_LongEncodingTable.
874  IITEntries = IIT_LongEncodingTable;
875 
876  // Strip sentinel bit.
877  NextElt = (TableVal << 1) >> 1;
878  } else {
879  // Decode the TableVal into an array of IITValues. If the entry was encoded
880  // into a single word in the table itself, decode it now.
881  do {
882  IITValues.push_back(TableVal & 0xF);
883  TableVal >>= 4;
884  } while (TableVal);
885 
886  IITEntries = IITValues;
887  NextElt = 0;
888  }
889 
890  // Okay, decode the table into the output vector of IITDescriptors.
891  DecodeIITType(NextElt, IITEntries, T);
892  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
893  DecodeIITType(NextElt, IITEntries, T);
894 }
895 
898  using namespace Intrinsic;
899 
900  IITDescriptor D = Infos.front();
901  Infos = Infos.slice(1);
902 
903  switch (D.Kind) {
904  case IITDescriptor::Void: return Type::getVoidTy(Context);
905  case IITDescriptor::VarArg: return Type::getVoidTy(Context);
906  case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
907  case IITDescriptor::Token: return Type::getTokenTy(Context);
908  case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
909  case IITDescriptor::Half: return Type::getHalfTy(Context);
910  case IITDescriptor::Float: return Type::getFloatTy(Context);
911  case IITDescriptor::Double: return Type::getDoubleTy(Context);
912  case IITDescriptor::Quad: return Type::getFP128Ty(Context);
913 
915  return IntegerType::get(Context, D.Integer_Width);
916  case IITDescriptor::Vector:
917  return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
918  case IITDescriptor::Pointer:
919  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
920  D.Pointer_AddressSpace);
921  case IITDescriptor::Struct: {
923  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
924  Elts.push_back(DecodeFixedType(Infos, Tys, Context));
925  return StructType::get(Context, Elts);
926  }
927  case IITDescriptor::Argument:
928  return Tys[D.getArgumentNumber()];
929  case IITDescriptor::ExtendArgument: {
930  Type *Ty = Tys[D.getArgumentNumber()];
931  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
933 
934  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
935  }
936  case IITDescriptor::TruncArgument: {
937  Type *Ty = Tys[D.getArgumentNumber()];
938  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
940 
941  IntegerType *ITy = cast<IntegerType>(Ty);
942  assert(ITy->getBitWidth() % 2 == 0);
943  return IntegerType::get(Context, ITy->getBitWidth() / 2);
944  }
945  case IITDescriptor::HalfVecArgument:
946  return VectorType::getHalfElementsVectorType(cast<VectorType>(
947  Tys[D.getArgumentNumber()]));
948  case IITDescriptor::SameVecWidthArgument: {
949  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
950  Type *Ty = Tys[D.getArgumentNumber()];
951  if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
952  return VectorType::get(EltTy, VTy->getNumElements());
953  }
954  llvm_unreachable("unhandled");
955  }
956  case IITDescriptor::PtrToArgument: {
957  Type *Ty = Tys[D.getArgumentNumber()];
958  return PointerType::getUnqual(Ty);
959  }
960  case IITDescriptor::PtrToElt: {
961  Type *Ty = Tys[D.getArgumentNumber()];
962  VectorType *VTy = dyn_cast<VectorType>(Ty);
963  if (!VTy)
964  llvm_unreachable("Expected an argument of Vector Type");
965  Type *EltTy = VTy->getVectorElementType();
966  return PointerType::getUnqual(EltTy);
967  }
968  case IITDescriptor::VecOfAnyPtrsToElt:
969  // Return the overloaded type (which determines the pointers address space)
970  return Tys[D.getOverloadArgNumber()];
971  }
972  llvm_unreachable("unhandled");
973 }
974 
976  ID id, ArrayRef<Type*> Tys) {
978  getIntrinsicInfoTableEntries(id, Table);
979 
981  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
982 
983  SmallVector<Type*, 8> ArgTys;
984  while (!TableRef.empty())
985  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
986 
987  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
988  // If we see void type as the type of the last argument, it is vararg intrinsic
989  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
990  ArgTys.pop_back();
991  return FunctionType::get(ResultTy, ArgTys, true);
992  }
993  return FunctionType::get(ResultTy, ArgTys, false);
994 }
995 
997 #define GET_INTRINSIC_OVERLOAD_TABLE
998 #include "llvm/IR/IntrinsicImpl.inc"
999 #undef GET_INTRINSIC_OVERLOAD_TABLE
1000 }
1001 
1003  switch (id) {
1004  default:
1005  return true;
1006 
1007  case Intrinsic::experimental_gc_statepoint:
1008  case Intrinsic::experimental_patchpoint_void:
1009  case Intrinsic::experimental_patchpoint_i64:
1010  return false;
1011  }
1012 }
1013 
1014 /// This defines the "Intrinsic::getAttributes(ID id)" method.
1015 #define GET_INTRINSIC_ATTRIBUTES
1016 #include "llvm/IR/IntrinsicImpl.inc"
1017 #undef GET_INTRINSIC_ATTRIBUTES
1018 
1020  // There can never be multiple globals with the same name of different types,
1021  // because intrinsics must be a specific type.
1022  return
1023  cast<Function>(M->getOrInsertFunction(getName(id, Tys),
1024  getType(M->getContext(), id, Tys)));
1025 }
1026 
1027 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
1028 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1029 #include "llvm/IR/IntrinsicImpl.inc"
1030 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
1031 
1032 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
1033 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1034 #include "llvm/IR/IntrinsicImpl.inc"
1035 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
1036 
1038  SmallVectorImpl<Type*> &ArgTys) {
1039  using namespace Intrinsic;
1040 
1041  // If we ran out of descriptors, there are too many arguments.
1042  if (Infos.empty()) return true;
1043  IITDescriptor D = Infos.front();
1044  Infos = Infos.slice(1);
1045 
1046  switch (D.Kind) {
1047  case IITDescriptor::Void: return !Ty->isVoidTy();
1048  case IITDescriptor::VarArg: return true;
1049  case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1050  case IITDescriptor::Token: return !Ty->isTokenTy();
1051  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1052  case IITDescriptor::Half: return !Ty->isHalfTy();
1053  case IITDescriptor::Float: return !Ty->isFloatTy();
1054  case IITDescriptor::Double: return !Ty->isDoubleTy();
1055  case IITDescriptor::Quad: return !Ty->isFP128Ty();
1056  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1057  case IITDescriptor::Vector: {
1058  VectorType *VT = dyn_cast<VectorType>(Ty);
1059  return !VT || VT->getNumElements() != D.Vector_Width ||
1060  matchIntrinsicType(VT->getElementType(), Infos, ArgTys);
1061  }
1062  case IITDescriptor::Pointer: {
1063  PointerType *PT = dyn_cast<PointerType>(Ty);
1064  return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
1065  matchIntrinsicType(PT->getElementType(), Infos, ArgTys);
1066  }
1067 
1068  case IITDescriptor::Struct: {
1069  StructType *ST = dyn_cast<StructType>(Ty);
1070  if (!ST || ST->getNumElements() != D.Struct_NumElements)
1071  return true;
1072 
1073  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1074  if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys))
1075  return true;
1076  return false;
1077  }
1078 
1079  case IITDescriptor::Argument:
1080  // Two cases here - If this is the second occurrence of an argument, verify
1081  // that the later instance matches the previous instance.
1082  if (D.getArgumentNumber() < ArgTys.size())
1083  return Ty != ArgTys[D.getArgumentNumber()];
1084 
1085  // Otherwise, if this is the first instance of an argument, record it and
1086  // verify the "Any" kind.
1087  assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error");
1088  ArgTys.push_back(Ty);
1089 
1090  switch (D.getArgumentKind()) {
1091  case IITDescriptor::AK_Any: return false; // Success
1092  case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
1093  case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1094  case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1095  case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1096  }
1097  llvm_unreachable("all argument kinds not covered");
1098 
1099  case IITDescriptor::ExtendArgument: {
1100  // This may only be used when referring to a previous vector argument.
1101  if (D.getArgumentNumber() >= ArgTys.size())
1102  return true;
1103 
1104  Type *NewTy = ArgTys[D.getArgumentNumber()];
1105  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1107  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1108  NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1109  else
1110  return true;
1111 
1112  return Ty != NewTy;
1113  }
1114  case IITDescriptor::TruncArgument: {
1115  // This may only be used when referring to a previous vector argument.
1116  if (D.getArgumentNumber() >= ArgTys.size())
1117  return true;
1118 
1119  Type *NewTy = ArgTys[D.getArgumentNumber()];
1120  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1122  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1123  NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1124  else
1125  return true;
1126 
1127  return Ty != NewTy;
1128  }
1129  case IITDescriptor::HalfVecArgument:
1130  // This may only be used when referring to a previous vector argument.
1131  return D.getArgumentNumber() >= ArgTys.size() ||
1132  !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1134  cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1135  case IITDescriptor::SameVecWidthArgument: {
1136  if (D.getArgumentNumber() >= ArgTys.size())
1137  return true;
1139  dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1140  VectorType *ThisArgType = dyn_cast<VectorType>(Ty);
1141  if (!ThisArgType || !ReferenceType ||
1142  (ReferenceType->getVectorNumElements() !=
1143  ThisArgType->getVectorNumElements()))
1144  return true;
1145  return matchIntrinsicType(ThisArgType->getVectorElementType(),
1146  Infos, ArgTys);
1147  }
1148  case IITDescriptor::PtrToArgument: {
1149  if (D.getArgumentNumber() >= ArgTys.size())
1150  return true;
1151  Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1152  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1153  return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
1154  }
1155  case IITDescriptor::PtrToElt: {
1156  if (D.getArgumentNumber() >= ArgTys.size())
1157  return true;
1159  dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1160  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1161 
1162  return (!ThisArgType || !ReferenceType ||
1163  ThisArgType->getElementType() != ReferenceType->getElementType());
1164  }
1165  case IITDescriptor::VecOfAnyPtrsToElt: {
1166  unsigned RefArgNumber = D.getRefArgNumber();
1167 
1168  // This may only be used when referring to a previous argument.
1169  if (RefArgNumber >= ArgTys.size())
1170  return true;
1171 
1172  // Record the overloaded type
1173  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1174  "Table consistency error");
1175  ArgTys.push_back(Ty);
1176 
1177  // Verify the overloaded type "matches" the Ref type.
1178  // i.e. Ty is a vector with the same width as Ref.
1179  // Composed of pointers to the same element type as Ref.
1180  VectorType *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1181  VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1182  if (!ThisArgVecTy || !ReferenceType ||
1183  (ReferenceType->getVectorNumElements() !=
1184  ThisArgVecTy->getVectorNumElements()))
1185  return true;
1186  PointerType *ThisArgEltTy =
1187  dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());
1188  if (!ThisArgEltTy)
1189  return true;
1190  return ThisArgEltTy->getElementType() !=
1191  ReferenceType->getVectorElementType();
1192  }
1193  }
1194  llvm_unreachable("unhandled");
1195 }
1196 
1197 bool
1200  // If there are no descriptors left, then it can't be a vararg.
1201  if (Infos.empty())
1202  return isVarArg;
1203 
1204  // There should be only one descriptor remaining at this point.
1205  if (Infos.size() != 1)
1206  return true;
1207 
1208  // Check and verify the descriptor.
1209  IITDescriptor D = Infos.front();
1210  Infos = Infos.slice(1);
1211  if (D.Kind == IITDescriptor::VarArg)
1212  return !isVarArg;
1213 
1214  return true;
1215 }
1216 
1219  if (!ID)
1220  return None;
1221 
1222  FunctionType *FTy = F->getFunctionType();
1223  // Accumulate an array of overloaded types for the given intrinsic
1224  SmallVector<Type *, 4> ArgTys;
1225  {
1227  getIntrinsicInfoTableEntries(ID, Table);
1229 
1230  // If we encounter any problems matching the signature with the descriptor
1231  // just give up remangling. It's up to verifier to report the discrepancy.
1232  if (Intrinsic::matchIntrinsicType(FTy->getReturnType(), TableRef, ArgTys))
1233  return None;
1234  for (auto Ty : FTy->params())
1235  if (Intrinsic::matchIntrinsicType(Ty, TableRef, ArgTys))
1236  return None;
1237  if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef))
1238  return None;
1239  }
1240 
1241  StringRef Name = F->getName();
1242  if (Name == Intrinsic::getName(ID, ArgTys))
1243  return None;
1244 
1245  auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1246  NewDecl->setCallingConv(F->getCallingConv());
1247  assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature");
1248  return NewDecl;
1249 }
1250 
1251 /// hasAddressTaken - returns true if there are any uses of this function
1252 /// other than direct calls or invokes to it.
1253 bool Function::hasAddressTaken(const User* *PutOffender) const {
1254  for (const Use &U : uses()) {
1255  const User *FU = U.getUser();
1256  if (isa<BlockAddress>(FU))
1257  continue;
1258  const auto *Call = dyn_cast<CallBase>(FU);
1259  if (!Call) {
1260  if (PutOffender)
1261  *PutOffender = FU;
1262  return true;
1263  }
1264  if (!Call->isCallee(&U)) {
1265  if (PutOffender)
1266  *PutOffender = FU;
1267  return true;
1268  }
1269  }
1270  return false;
1271 }
1272 
1274  // Check the linkage
1275  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1276  !hasAvailableExternallyLinkage())
1277  return false;
1278 
1279  // Check if the function is used by anything other than a blockaddress.
1280  for (const User *U : users())
1281  if (!isa<BlockAddress>(U))
1282  return false;
1283 
1284  return true;
1285 }
1286 
1287 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1288 /// setjmp or other function that gcc recognizes as "returning twice".
1290  for (const Instruction &I : instructions(this))
1291  if (const auto *Call = dyn_cast<CallBase>(&I))
1292  if (Call->hasFnAttr(Attribute::ReturnsTwice))
1293  return true;
1294 
1295  return false;
1296 }
1297 
1299  assert(hasPersonalityFn() && getNumOperands());
1300  return cast<Constant>(Op<0>());
1301 }
1302 
1304  setHungoffOperand<0>(Fn);
1305  setValueSubclassDataBit(3, Fn != nullptr);
1306 }
1307 
1309  assert(hasPrefixData() && getNumOperands());
1310  return cast<Constant>(Op<1>());
1311 }
1312 
1314  setHungoffOperand<1>(PrefixData);
1315  setValueSubclassDataBit(1, PrefixData != nullptr);
1316 }
1317 
1319  assert(hasPrologueData() && getNumOperands());
1320  return cast<Constant>(Op<2>());
1321 }
1322 
1324  setHungoffOperand<2>(PrologueData);
1325  setValueSubclassDataBit(2, PrologueData != nullptr);
1326 }
1327 
1328 void Function::allocHungoffUselist() {
1329  // If we've already allocated a uselist, stop here.
1330  if (getNumOperands())
1331  return;
1332 
1333  allocHungoffUses(3, /*IsPhi=*/ false);
1334  setNumHungOffUseOperands(3);
1335 
1336  // Initialize the uselist with placeholder operands to allow traversal.
1338  Op<0>().set(CPN);
1339  Op<1>().set(CPN);
1340  Op<2>().set(CPN);
1341 }
1342 
1343 template <int Idx>
1344 void Function::setHungoffOperand(Constant *C) {
1345  if (C) {
1346  allocHungoffUselist();
1347  Op<Idx>().set(C);
1348  } else if (getNumOperands()) {
1349  Op<Idx>().set(
1351  }
1352 }
1353 
1354 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1355  assert(Bit < 16 && "SubclassData contains only 16 bits");
1356  if (On)
1358  else
1360 }
1361 
1363  const DenseSet<GlobalValue::GUID> *S) {
1364  assert(Count.hasValue());
1365 #if !defined(NDEBUG)
1366  auto PrevCount = getEntryCount();
1367  assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType());
1368 #endif
1369  MDBuilder MDB(getContext());
1370  setMetadata(
1372  MDB.createFunctionEntryCount(Count.getCount(), Count.isSynthetic(), S));
1373 }
1374 
1376  const DenseSet<GlobalValue::GUID> *Imports) {
1377  setEntryCount(ProfileCount(Count, Type), Imports);
1378 }
1379 
1381  MDNode *MD = getMetadata(LLVMContext::MD_prof);
1382  if (MD && MD->getOperand(0))
1383  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0))) {
1384  if (MDS->getString().equals("function_entry_count")) {
1385  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1386  uint64_t Count = CI->getValue().getZExtValue();
1387  // A value of -1 is used for SamplePGO when there were no samples.
1388  // Treat this the same as unknown.
1389  if (Count == (uint64_t)-1)
1390  return ProfileCount::getInvalid();
1391  return ProfileCount(Count, PCT_Real);
1392  } else if (MDS->getString().equals("synthetic_function_entry_count")) {
1393  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1394  uint64_t Count = CI->getValue().getZExtValue();
1395  return ProfileCount(Count, PCT_Synthetic);
1396  }
1397  }
1398  return ProfileCount::getInvalid();
1399 }
1400 
1403  if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1404  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1405  if (MDS->getString().equals("function_entry_count"))
1406  for (unsigned i = 2; i < MD->getNumOperands(); i++)
1407  R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
1408  ->getValue()
1409  .getZExtValue());
1410  return R;
1411 }
1412 
1414  MDBuilder MDB(getContext());
1416  MDB.createFunctionSectionPrefix(Prefix));
1417 }
1418 
1420  if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
1421  assert(cast<MDString>(MD->getOperand(0))
1422  ->getString()
1423  .equals("function_section_prefix") &&
1424  "Metadata not match");
1425  return cast<MDString>(MD->getOperand(1))->getString();
1426  }
1427  return None;
1428 }
1429 
1431  return getFnAttribute("null-pointer-is-valid")
1432  .getValueAsString()
1433  .equals("true");
1434 }
1435 
1436 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
1437  if (F && F->nullPointerIsDefined())
1438  return true;
1439 
1440  if (AS != 0)
1441  return true;
1442 
1443  return false;
1444 }
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:128
Type * getVectorElementType() const
Definition: Type.h:370
uint64_t CallInst * C
unsigned short getSubclassDataFromValue() const
Definition: Value.h:654
iterator_range< use_iterator > uses()
Definition: Value.h:354
bool hasAttribute(Attribute::AttrKind Kind) const
Check if an argument has a given attribute.
Definition: Function.cpp:184
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:421
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:164
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1562
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:122
ArgKind getArgumentKind() const
Definition: Intrinsics.h:129
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:440
bool isMetadataTy() const
Return true if this is &#39;metadata&#39;.
Definition: Type.h:190
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:313
void removeAttr(Attribute::AttrKind Kind)
Remove attributes from an argument.
Definition: Function.cpp:180
Argument(Type *Ty, const Twine &Name="", Function *F=nullptr, unsigned ArgNo=0)
Argument constructor.
Definition: Function.cpp:66
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:385
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
2: 32-bit floating point type
Definition: Type.h:58
const std::string & getGC(const Function &Fn)
Return the GC for a function.
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
Definition: Function.cpp:439
unsigned getInstructionCount() const
Returns the number of non-debug IR instructions in this function.
Definition: Function.cpp:196
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:312
void clearGC()
Definition: Function.cpp:474
unsigned getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:427
bool hasByValOrInAllocaAttr() const
Return true if this argument has the byval attribute or inalloca attribute.
Definition: Function.cpp:104
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:137
bool isFP128Ty() const
Return true if this is &#39;fp128&#39;.
Definition: Type.h:155
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
void setGC(std::string Str)
Definition: Function.cpp:469
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:629
The two locations do not alias at all.
Definition: AliasAnalysis.h:83
void addAttrs(AttrBuilder &B)
Add attributes to an argument.
Definition: Function.cpp:166
bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
Definition: Function.cpp:996
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:704
static MutableArrayRef< Argument > makeArgArray(Argument *Args, size_t Count)
Definition: Function.cpp:287
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:719
void setSectionPrefix(StringRef Prefix)
Set the section prefix for this function.
Definition: Function.cpp:1413
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:1185
Metadata node.
Definition: Metadata.h:863
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1013
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:60
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:326
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
1: 16-bit floating point type
Definition: Type.h:57
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:165
This defines the Use class.
static VectorType * getTruncatedElementVectorType(VectorType *VTy)
This static method is like getInteger except that the element types are half as wide as the elements ...
Definition: DerivedTypes.h:422
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:170
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:486
void removeFromParent()
removeFromParent - This method unlinks &#39;this&#39; from the containing module, but does not delete it...
Definition: Function.cpp:209
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:1401
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1318
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:129
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:710
amdgpu Simplify well known AMD library false Value Value const Twine & Name
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:166
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:625
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:370
ProfileCount getEntryCount() const
Get the entry count for this function.
Definition: Function.cpp:1380
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:1362
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:163
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:137
Class to represent struct types.
Definition: DerivedTypes.h:200
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
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:466
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:196
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:397
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:284
uint64_t getNumElements() const
Definition: DerivedTypes.h:358
unsigned getArgumentNumber() const
Definition: Intrinsics.h:122
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:341
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1308
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:266
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1217
Class to represent function types.
Definition: DerivedTypes.h:102
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
Definition: Function.cpp:645
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
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:160
Class to represent array types.
Definition: DerivedTypes.h:368
bool isVarArg() const
Definition: DerivedTypes.h:122
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:137
auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1281
const std::string & getGC() const
Definition: Function.cpp:464
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
Definition: Function.cpp:451
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:701
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:202
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type *> Tys, LLVMContext &Context)
Definition: Function.cpp:896
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:65
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:454
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:1019
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
Class to represent pointers.
Definition: DerivedTypes.h:466
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
Definition: Function.cpp:133
11: Arbitrary bit width integers
Definition: Type.h:70
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:575
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:140
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:146
0: type with no size
Definition: Type.h:56
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:397
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:172
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:432
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:300
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:1400
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:1002
static Intrinsic::ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
Definition: Function.cpp:534
uint64_t getCount() const
Definition: Function.h:271
const FunctionListType & getFunctionList() const
Get the Module&#39;s list of functions (constant).
Definition: Module.h:529
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:402
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
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
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:143
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:483
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:156
void removeAttribute(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:403
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:138
AMDGPU Lower Kernel Arguments
LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
Definition: Attributes.h:423
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:129
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: Function.cpp:367
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:160
bool isHalfTy() const
Return true if this is &#39;half&#39;, a 16-bit IEEE fp type.
Definition: Type.h:143
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:62
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:296
bool hasReturnedAttr() const
Return true if this argument has the returned attribute.
Definition: Function.cpp:148
size_t arg_size() const
Definition: Function.h:697
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:494
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics.h.
Definition: Function.cpp:553
bool isX86_MMXTy() const
Return true if this is X86 MMX.
Definition: Type.h:181
Optional< StringRef > getSectionPrefix() const
Get the section prefix for this function.
Definition: Function.cpp:1419
Class to represent integer types.
Definition: DerivedTypes.h:39
void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
removes the attribute from the list of attributes.
Definition: Function.cpp:433
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:192
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:516
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:168
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE 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:644
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:451
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:162
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:239
unsigned getOverloadArgNumber() const
Definition: Intrinsics.h:138
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:215
enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1198
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:481
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:863
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:975
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:726
bool hasSwiftSelfAttr() const
Return true if this argument has the swiftself attribute.
Definition: Function.cpp:91
Type * getReturnType() const
Definition: DerivedTypes.h:123
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:345
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:259
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static ProfileCount getInvalid()
Definition: Function.h:281
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:1436
void setValueSubclassData(unsigned short D)
Definition: Value.h:655
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:414
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:64
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:461
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:163
Class to represent vector types.
Definition: DerivedTypes.h:392
Target - Wrapper for Target specific information.
void push_back(pointer val)
Definition: ilist.h:312
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:399
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:693
static unsigned computeAddrSpace(unsigned AddrSpace, Module *M)
Definition: Function.cpp:221
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:415
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:348
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.
unsigned getRefArgNumber() const
Definition: Intrinsics.h:142
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:55
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:193
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:213
LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
bool matchIntrinsicType(Type *Ty, ArrayRef< IITDescriptor > &Infos, SmallVectorImpl< Type *> &ArgTys)
Match the specified type (which comes from an intrinsic argument or return value) with the type const...
Definition: Function.cpp:1037
#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:1323
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:322
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:213
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:499
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:1289
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:184
const unsigned Kind
3: 64-bit floating point type
Definition: Type.h:59
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:1253
void addAttributes(unsigned i, const AttrBuilder &Attrs)
adds the attributes to the list of attributes.
Definition: Function.cpp:379
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:457
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:72
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1298
static const char * name
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:605
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:250
ProfileCountType getType() const
Definition: Function.h:272
bool hasZExtAttr() const
Return true if this argument has the zext attribute.
Definition: Function.cpp:152
static const char *const IntrinsicNameTable[]
Table of string intrinsic names indexed by enum value.
Definition: Function.cpp:500
Type * getElementType() const
Definition: DerivedTypes.h:359
MDNode * createFunctionSectionPrefix(StringRef Prefix)
Return metadata containing the section prefix for a function.
Definition: MDBuilder.cpp:80
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:1303
bool nullPointerIsDefined() const
Check if null pointer dereferencing is considered undefined behavior for the function.
Definition: Function.cpp:1430
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:65
bool hasNoCaptureAttr() const
Return true if this argument has the nocapture attribute.
Definition: Function.cpp:138
void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes for the given arg.
Definition: Function.cpp:445
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:125
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:149
bool use_empty() const
Definition: Value.h:322
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1273
uint64_t getDereferenceableBytes() const
If this argument has the dereferenceable attribute, return the number of bytes known to be dereferenc...
Definition: Function.cpp:116
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:485
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:226
std::vector< uint32_t > Metadata
PAL metadata represented as a vector.
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:69
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:61
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1313