LLVM  6.0.0svn
Function.cpp
Go to the documentation of this file.
1 //===- Function.cpp - Implement the Global object classes -----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Function class for the IR library.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/IR/Function.h"
15 #include "LLVMContextImpl.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/ADT/StringRef.h"
26 #include "llvm/IR/Argument.h"
27 #include "llvm/IR/Attributes.h"
28 #include "llvm/IR/BasicBlock.h"
29 #include "llvm/IR/CallSite.h"
30 #include "llvm/IR/Constant.h"
31 #include "llvm/IR/Constants.h"
32 #include "llvm/IR/DerivedTypes.h"
33 #include "llvm/IR/GlobalValue.h"
34 #include "llvm/IR/InstIterator.h"
35 #include "llvm/IR/Instruction.h"
36 #include "llvm/IR/Instructions.h"
37 #include "llvm/IR/IntrinsicInst.h"
38 #include "llvm/IR/Intrinsics.h"
39 #include "llvm/IR/LLVMContext.h"
40 #include "llvm/IR/MDBuilder.h"
41 #include "llvm/IR/Metadata.h"
42 #include "llvm/IR/Module.h"
44 #include "llvm/IR/Type.h"
45 #include "llvm/IR/Use.h"
46 #include "llvm/IR/User.h"
47 #include "llvm/IR/Value.h"
49 #include "llvm/Support/Casting.h"
50 #include "llvm/Support/Compiler.h"
52 #include <algorithm>
53 #include <cassert>
54 #include <cstddef>
55 #include <cstdint>
56 #include <cstring>
57 #include <string>
58 
59 using namespace llvm;
60 
61 // Explicit instantiations of SymbolTableListTraits since some of the methods
62 // are not in the public header file...
64 
65 //===----------------------------------------------------------------------===//
66 // Argument Implementation
67 //===----------------------------------------------------------------------===//
68 
69 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
70  : Value(Ty, Value::ArgumentVal), Parent(Par), ArgNo(ArgNo) {
71  setName(Name);
72 }
73 
74 void Argument::setParent(Function *parent) {
75  Parent = parent;
76 }
77 
79  if (!getType()->isPointerTy()) return false;
80  if (getParent()->hasParamAttribute(getArgNo(), Attribute::NonNull))
81  return true;
82  else if (getDereferenceableBytes() > 0 &&
83  getType()->getPointerAddressSpace() == 0)
84  return true;
85  return false;
86 }
87 
88 bool Argument::hasByValAttr() const {
89  if (!getType()->isPointerTy()) return false;
90  return hasAttribute(Attribute::ByVal);
91 }
92 
94  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftSelf);
95 }
96 
98  return getParent()->hasParamAttribute(getArgNo(), Attribute::SwiftError);
99 }
100 
102  if (!getType()->isPointerTy()) return false;
103  return hasAttribute(Attribute::InAlloca);
104 }
105 
107  if (!getType()->isPointerTy()) return false;
109  return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
110  Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca);
111 }
112 
113 unsigned Argument::getParamAlignment() const {
114  assert(getType()->isPointerTy() && "Only pointers have alignments");
115  return getParent()->getParamAlignment(getArgNo());
116 }
117 
119  assert(getType()->isPointerTy() &&
120  "Only pointers have dereferenceable bytes");
122 }
123 
125  assert(getType()->isPointerTy() &&
126  "Only pointers have dereferenceable bytes");
128 }
129 
130 bool Argument::hasNestAttr() const {
131  if (!getType()->isPointerTy()) return false;
132  return hasAttribute(Attribute::Nest);
133 }
134 
136  if (!getType()->isPointerTy()) return false;
138 }
139 
141  if (!getType()->isPointerTy()) return false;
142  return hasAttribute(Attribute::NoCapture);
143 }
144 
146  if (!getType()->isPointerTy()) return false;
147  return hasAttribute(Attribute::StructRet);
148 }
149 
151  return hasAttribute(Attribute::Returned);
152 }
153 
154 bool Argument::hasZExtAttr() const {
155  return hasAttribute(Attribute::ZExt);
156 }
157 
158 bool Argument::hasSExtAttr() const {
159  return hasAttribute(Attribute::SExt);
160 }
161 
164  return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) ||
165  Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone);
166 }
167 
170  AL = AL.addParamAttributes(Parent->getContext(), getArgNo(), B);
171  getParent()->setAttributes(AL);
172 }
173 
175  getParent()->addParamAttr(getArgNo(), Kind);
176 }
177 
179  getParent()->addParamAttr(getArgNo(), Attr);
180 }
181 
183  getParent()->removeParamAttr(getArgNo(), Kind);
184 }
185 
187  return getParent()->hasParamAttribute(getArgNo(), Kind);
188 }
189 
190 //===----------------------------------------------------------------------===//
191 // Helper Methods in Function
192 //===----------------------------------------------------------------------===//
193 
195  return getType()->getContext();
196 }
197 
199  getParent()->getFunctionList().remove(getIterator());
200 }
201 
203  getParent()->getFunctionList().erase(getIterator());
204 }
205 
206 //===----------------------------------------------------------------------===//
207 // Function Implementation
208 //===----------------------------------------------------------------------===//
209 
210 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name,
211  Module *ParentModule)
212  : GlobalObject(Ty, Value::FunctionVal,
213  OperandTraits<Function>::op_begin(this), 0, Linkage, name),
214  NumArgs(Ty->getNumParams()) {
215  assert(FunctionType::isValidReturnType(getReturnType()) &&
216  "invalid return type");
217  setGlobalObjectSubClassData(0);
218 
219  // We only need a symbol table for a function if the context keeps value names
220  if (!getContext().shouldDiscardValueNames())
221  SymTab = make_unique<ValueSymbolTable>();
222 
223  // If the function has arguments, mark them as lazily built.
224  if (Ty->getNumParams())
225  setValueSubclassData(1); // Set the "has lazy arguments" bit.
226 
227  if (ParentModule)
228  ParentModule->getFunctionList().push_back(this);
229 
230  HasLLVMReservedName = getName().startswith("llvm.");
231  // Ensure intrinsics have the right parameter attributes.
232  // Note, the IntID field will have been set in Value::setName if this function
233  // name is a valid intrinsic ID.
234  if (IntID)
235  setAttributes(Intrinsic::getAttributes(getContext(), IntID));
236 }
237 
239  dropAllReferences(); // After this it is safe to delete instructions.
240 
241  // Delete all of the method arguments and unlink from symbol table...
242  if (Arguments)
243  clearArguments();
244 
245  // Remove the function from the on-the-side GC table.
246  clearGC();
247 }
248 
249 void Function::BuildLazyArguments() const {
250  // Create the arguments vector, all arguments start out unnamed.
251  auto *FT = getFunctionType();
252  if (NumArgs > 0) {
253  Arguments = std::allocator<Argument>().allocate(NumArgs);
254  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
255  Type *ArgTy = FT->getParamType(i);
256  assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
257  new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
258  }
259  }
260 
261  // Clear the lazy arguments bit.
262  unsigned SDC = getSubclassDataFromValue();
263  const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0));
264  assert(!hasLazyArguments());
265 }
266 
268  return MutableArrayRef<Argument>(Args, Count);
269 }
270 
271 void Function::clearArguments() {
272  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
273  A.setName("");
274  A.~Argument();
275  }
276  std::allocator<Argument>().deallocate(Arguments, NumArgs);
277  Arguments = nullptr;
278 }
279 
281  assert(isDeclaration() && "Expected no references to current arguments");
282 
283  // Drop the current arguments, if any, and set the lazy argument bit.
284  if (!hasLazyArguments()) {
286  [](const Argument &A) { return A.use_empty(); }) &&
287  "Expected arguments to be unused in declaration");
288  clearArguments();
290  }
291 
292  // Nothing to steal if Src has lazy arguments.
293  if (Src.hasLazyArguments())
294  return;
295 
296  // Steal arguments from Src, and fix the lazy argument bits.
297  assert(arg_size() == Src.arg_size());
298  Arguments = Src.Arguments;
299  Src.Arguments = nullptr;
300  for (Argument &A : makeArgArray(Arguments, NumArgs)) {
301  // FIXME: This does the work of transferNodesFromList inefficiently.
303  if (A.hasName())
304  Name = A.getName();
305  if (!Name.empty())
306  A.setName("");
307  A.setParent(this);
308  if (!Name.empty())
309  A.setName(Name);
310  }
311 
313  assert(!hasLazyArguments());
314  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
315 }
316 
317 // dropAllReferences() - This function causes all the subinstructions to "let
318 // go" of all references that they are maintaining. This allows one to
319 // 'delete' a whole class at a time, even though there may be circular
320 // references... first all references are dropped, and all use counts go to
321 // zero. Then everything is deleted for real. Note that no operations are
322 // valid on an object that has "dropped all references", except operator
323 // delete.
324 //
326  setIsMaterializable(false);
327 
328  for (BasicBlock &BB : *this)
329  BB.dropAllReferences();
330 
331  // Delete all basic blocks. They are now unused, except possibly by
332  // blockaddresses, but BasicBlock's destructor takes care of those.
333  while (!BasicBlocks.empty())
334  BasicBlocks.begin()->eraseFromParent();
335 
336  // Drop uses of any optional data (real or placeholder).
337  if (getNumOperands()) {
339  setNumHungOffUseOperands(0);
341  }
342 
343  // Metadata is stored in a side-table.
344  clearMetadata();
345 }
346 
349  PAL = PAL.addAttribute(getContext(), i, Kind);
350  setAttributes(PAL);
351 }
352 
353 void Function::addAttribute(unsigned i, Attribute Attr) {
355  PAL = PAL.addAttribute(getContext(), i, Attr);
356  setAttributes(PAL);
357 }
358 
359 void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) {
361  PAL = PAL.addAttributes(getContext(), i, Attrs);
362  setAttributes(PAL);
363 }
364 
367  PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
368  setAttributes(PAL);
369 }
370 
371 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
373  PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
374  setAttributes(PAL);
375 }
376 
377 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
379  PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs);
380  setAttributes(PAL);
381 }
382 
385  PAL = PAL.removeAttribute(getContext(), i, Kind);
386  setAttributes(PAL);
387 }
388 
391  PAL = PAL.removeAttribute(getContext(), i, Kind);
392  setAttributes(PAL);
393 }
394 
395 void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) {
397  PAL = PAL.removeAttributes(getContext(), i, Attrs);
398  setAttributes(PAL);
399 }
400 
403  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
404  setAttributes(PAL);
405 }
406 
407 void Function::removeParamAttr(unsigned ArgNo, StringRef Kind) {
409  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
410  setAttributes(PAL);
411 }
412 
413 void Function::removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
415  PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
416  setAttributes(PAL);
417 }
418 
419 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
421  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
422  setAttributes(PAL);
423 }
424 
425 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
427  PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
428  setAttributes(PAL);
429 }
430 
431 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
433  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
434  setAttributes(PAL);
435 }
436 
438  uint64_t Bytes) {
440  PAL = PAL.addDereferenceableOrNullParamAttr(getContext(), ArgNo, Bytes);
441  setAttributes(PAL);
442 }
443 
444 const std::string &Function::getGC() const {
445  assert(hasGC() && "Function has no collector");
446  return getContext().getGC(*this);
447 }
448 
449 void Function::setGC(std::string Str) {
450  setValueSubclassDataBit(14, !Str.empty());
451  getContext().setGC(*this, std::move(Str));
452 }
453 
455  if (!hasGC())
456  return;
457  getContext().deleteGC(*this);
458  setValueSubclassDataBit(14, false);
459 }
460 
461 /// Copy all additional attributes (those not needed to create a Function) from
462 /// the Function Src to this one.
465  setCallingConv(Src->getCallingConv());
466  setAttributes(Src->getAttributes());
467  if (Src->hasGC())
468  setGC(Src->getGC());
469  else
470  clearGC();
471  if (Src->hasPersonalityFn())
472  setPersonalityFn(Src->getPersonalityFn());
473  if (Src->hasPrefixData())
474  setPrefixData(Src->getPrefixData());
475  if (Src->hasPrologueData())
476  setPrologueData(Src->getPrologueData());
477 }
478 
479 /// Table of string intrinsic names indexed by enum value.
480 static const char * const IntrinsicNameTable[] = {
481  "not_intrinsic",
482 #define GET_INTRINSIC_NAME_TABLE
483 #include "llvm/IR/Intrinsics.gen"
484 #undef GET_INTRINSIC_NAME_TABLE
485 };
486 
487 /// Table of per-target intrinsic name tables.
488 #define GET_INTRINSIC_TARGET_DATA
489 #include "llvm/IR/Intrinsics.gen"
490 #undef GET_INTRINSIC_TARGET_DATA
491 
492 /// Find the segment of \c IntrinsicNameTable for intrinsics with the same
493 /// target as \c Name, or the generic table if \c Name is not target specific.
494 ///
495 /// Returns the relevant slice of \c IntrinsicNameTable
497  assert(Name.startswith("llvm."));
498 
499  ArrayRef<IntrinsicTargetInfo> Targets(TargetInfos);
500  // Drop "llvm." and take the first dotted component. That will be the target
501  // if this is target specific.
502  StringRef Target = Name.drop_front(5).split('.').first;
503  auto It = std::lower_bound(Targets.begin(), Targets.end(), Target,
504  [](const IntrinsicTargetInfo &TI,
505  StringRef Target) { return TI.Name < Target; });
506  // We've either found the target or just fall back to the generic set, which
507  // is always first.
508  const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
509  return makeArrayRef(&IntrinsicNameTable[1] + TI.Offset, TI.Count);
510 }
511 
512 /// \brief This does the actual lookup of an intrinsic ID which
513 /// matches the given function name.
515  ArrayRef<const char *> NameTable = findTargetSubtable(Name);
516  int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
517  if (Idx == -1)
519 
520  // Intrinsic IDs correspond to the location in IntrinsicNameTable, but we have
521  // an index into a sub-table.
522  int Adjust = NameTable.data() - IntrinsicNameTable;
523  Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + Adjust);
524 
525  // If the intrinsic is not overloaded, require an exact match. If it is
526  // overloaded, require a prefix match.
527  bool IsPrefixMatch = Name.size() > strlen(NameTable[Idx]);
528  return IsPrefixMatch == isOverloaded(ID) ? ID : Intrinsic::not_intrinsic;
529 }
530 
532  StringRef Name = getName();
533  if (!Name.startswith("llvm.")) {
534  HasLLVMReservedName = false;
535  IntID = Intrinsic::not_intrinsic;
536  return;
537  }
538  HasLLVMReservedName = true;
539  IntID = lookupIntrinsicID(Name);
540 }
541 
542 /// Returns a stable mangling for the type specified for use in the name
543 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
544 /// of named types is simply their name. Manglings for unnamed types consist
545 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
546 /// combined with the mangling of their component types. A vararg function
547 /// type will have a suffix of 'vararg'. Since function types can contain
548 /// other function types, we close a function type mangling with suffix 'f'
549 /// which can't be confused with it's prefix. This ensures we don't have
550 /// collisions between two unrelated function types. Otherwise, you might
551 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
552 /// Manglings of integers, floats, and vectors ('i', 'f', and 'v' prefix in most
553 /// cases) fall back to the MVT codepath, where they could be mangled to
554 /// 'x86mmx', for example; matching on derived types is not sufficient to mangle
555 /// everything.
556 static std::string getMangledTypeStr(Type* Ty) {
557  std::string Result;
558  if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
559  Result += "p" + utostr(PTyp->getAddressSpace()) +
560  getMangledTypeStr(PTyp->getElementType());
561  } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
562  Result += "a" + utostr(ATyp->getNumElements()) +
563  getMangledTypeStr(ATyp->getElementType());
564  } else if (StructType *STyp = dyn_cast<StructType>(Ty)) {
565  if (!STyp->isLiteral()) {
566  Result += "s_";
567  Result += STyp->getName();
568  } else {
569  Result += "sl_";
570  for (auto Elem : STyp->elements())
571  Result += getMangledTypeStr(Elem);
572  }
573  // Ensure nested structs are distinguishable.
574  Result += "s";
575  } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
576  Result += "f_" + getMangledTypeStr(FT->getReturnType());
577  for (size_t i = 0; i < FT->getNumParams(); i++)
578  Result += getMangledTypeStr(FT->getParamType(i));
579  if (FT->isVarArg())
580  Result += "vararg";
581  // Ensure nested function types are distinguishable.
582  Result += "f";
583  } else if (isa<VectorType>(Ty))
584  Result += "v" + utostr(Ty->getVectorNumElements()) +
586  else if (Ty)
587  Result += EVT::getEVT(Ty).getEVTString();
588  return Result;
589 }
590 
592  assert(id < num_intrinsics && "Invalid intrinsic ID!");
593  assert(!isOverloaded(id) &&
594  "This version of getName does not support overloading");
595  return IntrinsicNameTable[id];
596 }
597 
598 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
599  assert(id < num_intrinsics && "Invalid intrinsic ID!");
600  std::string Result(IntrinsicNameTable[id]);
601  for (Type *Ty : Tys) {
602  Result += "." + getMangledTypeStr(Ty);
603  }
604  return Result;
605 }
606 
607 /// IIT_Info - These are enumerators that describe the entries returned by the
608 /// getIntrinsicInfoTableEntries function.
609 ///
610 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
611 enum IIT_Info {
612  // Common values should be encoded with 0-15.
613  IIT_Done = 0,
614  IIT_I1 = 1,
615  IIT_I8 = 2,
616  IIT_I16 = 3,
617  IIT_I32 = 4,
618  IIT_I64 = 5,
619  IIT_F16 = 6,
620  IIT_F32 = 7,
621  IIT_F64 = 8,
622  IIT_V2 = 9,
623  IIT_V4 = 10,
624  IIT_V8 = 11,
625  IIT_V16 = 12,
626  IIT_V32 = 13,
627  IIT_PTR = 14,
628  IIT_ARG = 15,
629 
630  // Values from 16+ are only encodable with the inefficient encoding.
631  IIT_V64 = 16,
632  IIT_MMX = 17,
633  IIT_TOKEN = 18,
643  IIT_V1 = 28,
650  IIT_I128 = 35,
651  IIT_V512 = 36,
652  IIT_V1024 = 37,
656 };
657 
658 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
660  using namespace Intrinsic;
661 
662  IIT_Info Info = IIT_Info(Infos[NextElt++]);
663  unsigned StructElts = 2;
664 
665  switch (Info) {
666  case IIT_Done:
667  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
668  return;
669  case IIT_VARARG:
670  OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
671  return;
672  case IIT_MMX:
673  OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
674  return;
675  case IIT_TOKEN:
676  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
677  return;
678  case IIT_METADATA:
679  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
680  return;
681  case IIT_F16:
682  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
683  return;
684  case IIT_F32:
685  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
686  return;
687  case IIT_F64:
688  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
689  return;
690  case IIT_I1:
691  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
692  return;
693  case IIT_I8:
694  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
695  return;
696  case IIT_I16:
697  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
698  return;
699  case IIT_I32:
700  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
701  return;
702  case IIT_I64:
703  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
704  return;
705  case IIT_I128:
706  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
707  return;
708  case IIT_V1:
709  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
710  DecodeIITType(NextElt, Infos, OutputTable);
711  return;
712  case IIT_V2:
713  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
714  DecodeIITType(NextElt, Infos, OutputTable);
715  return;
716  case IIT_V4:
717  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
718  DecodeIITType(NextElt, Infos, OutputTable);
719  return;
720  case IIT_V8:
721  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
722  DecodeIITType(NextElt, Infos, OutputTable);
723  return;
724  case IIT_V16:
725  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
726  DecodeIITType(NextElt, Infos, OutputTable);
727  return;
728  case IIT_V32:
729  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
730  DecodeIITType(NextElt, Infos, OutputTable);
731  return;
732  case IIT_V64:
733  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64));
734  DecodeIITType(NextElt, Infos, OutputTable);
735  return;
736  case IIT_V512:
737  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512));
738  DecodeIITType(NextElt, Infos, OutputTable);
739  return;
740  case IIT_V1024:
741  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024));
742  DecodeIITType(NextElt, Infos, OutputTable);
743  return;
744  case IIT_PTR:
745  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
746  DecodeIITType(NextElt, Infos, OutputTable);
747  return;
748  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
749  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
750  Infos[NextElt++]));
751  DecodeIITType(NextElt, Infos, OutputTable);
752  return;
753  }
754  case IIT_ARG: {
755  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
756  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
757  return;
758  }
759  case IIT_EXTEND_ARG: {
760  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
761  OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
762  ArgInfo));
763  return;
764  }
765  case IIT_TRUNC_ARG: {
766  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
767  OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
768  ArgInfo));
769  return;
770  }
771  case IIT_HALF_VEC_ARG: {
772  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
773  OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
774  ArgInfo));
775  return;
776  }
777  case IIT_SAME_VEC_WIDTH_ARG: {
778  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
779  OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
780  ArgInfo));
781  return;
782  }
783  case IIT_PTR_TO_ARG: {
784  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
785  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
786  ArgInfo));
787  return;
788  }
789  case IIT_PTR_TO_ELT: {
790  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
791  OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToElt, ArgInfo));
792  return;
793  }
795  unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
796  unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
797  OutputTable.push_back(
798  IITDescriptor::get(IITDescriptor::VecOfAnyPtrsToElt, ArgNo, RefNo));
799  return;
800  }
801  case IIT_EMPTYSTRUCT:
802  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
803  return;
804  case IIT_STRUCT8: ++StructElts; LLVM_FALLTHROUGH;
805  case IIT_STRUCT7: ++StructElts; LLVM_FALLTHROUGH;
806  case IIT_STRUCT6: ++StructElts; LLVM_FALLTHROUGH;
807  case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
808  case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
809  case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
810  case IIT_STRUCT2: {
811  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
812 
813  for (unsigned i = 0; i != StructElts; ++i)
814  DecodeIITType(NextElt, Infos, OutputTable);
815  return;
816  }
817  }
818  llvm_unreachable("unhandled");
819 }
820 
821 #define GET_INTRINSIC_GENERATOR_GLOBAL
822 #include "llvm/IR/Intrinsics.gen"
823 #undef GET_INTRINSIC_GENERATOR_GLOBAL
824 
827  // Check to see if the intrinsic's type was expressible by the table.
828  unsigned TableVal = IIT_Table[id-1];
829 
830  // Decode the TableVal into an array of IITValues.
832  ArrayRef<unsigned char> IITEntries;
833  unsigned NextElt = 0;
834  if ((TableVal >> 31) != 0) {
835  // This is an offset into the IIT_LongEncodingTable.
836  IITEntries = IIT_LongEncodingTable;
837 
838  // Strip sentinel bit.
839  NextElt = (TableVal << 1) >> 1;
840  } else {
841  // Decode the TableVal into an array of IITValues. If the entry was encoded
842  // into a single word in the table itself, decode it now.
843  do {
844  IITValues.push_back(TableVal & 0xF);
845  TableVal >>= 4;
846  } while (TableVal);
847 
848  IITEntries = IITValues;
849  NextElt = 0;
850  }
851 
852  // Okay, decode the table into the output vector of IITDescriptors.
853  DecodeIITType(NextElt, IITEntries, T);
854  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
855  DecodeIITType(NextElt, IITEntries, T);
856 }
857 
860  using namespace Intrinsic;
861 
862  IITDescriptor D = Infos.front();
863  Infos = Infos.slice(1);
864 
865  switch (D.Kind) {
866  case IITDescriptor::Void: return Type::getVoidTy(Context);
867  case IITDescriptor::VarArg: return Type::getVoidTy(Context);
868  case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
869  case IITDescriptor::Token: return Type::getTokenTy(Context);
870  case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
871  case IITDescriptor::Half: return Type::getHalfTy(Context);
872  case IITDescriptor::Float: return Type::getFloatTy(Context);
873  case IITDescriptor::Double: return Type::getDoubleTy(Context);
874 
876  return IntegerType::get(Context, D.Integer_Width);
877  case IITDescriptor::Vector:
878  return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
879  case IITDescriptor::Pointer:
880  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
881  D.Pointer_AddressSpace);
882  case IITDescriptor::Struct: {
884  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
885  Elts.push_back(DecodeFixedType(Infos, Tys, Context));
886  return StructType::get(Context, Elts);
887  }
888  case IITDescriptor::Argument:
889  return Tys[D.getArgumentNumber()];
890  case IITDescriptor::ExtendArgument: {
891  Type *Ty = Tys[D.getArgumentNumber()];
892  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
894 
895  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
896  }
897  case IITDescriptor::TruncArgument: {
898  Type *Ty = Tys[D.getArgumentNumber()];
899  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
901 
902  IntegerType *ITy = cast<IntegerType>(Ty);
903  assert(ITy->getBitWidth() % 2 == 0);
904  return IntegerType::get(Context, ITy->getBitWidth() / 2);
905  }
906  case IITDescriptor::HalfVecArgument:
907  return VectorType::getHalfElementsVectorType(cast<VectorType>(
908  Tys[D.getArgumentNumber()]));
909  case IITDescriptor::SameVecWidthArgument: {
910  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
911  Type *Ty = Tys[D.getArgumentNumber()];
912  if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
913  return VectorType::get(EltTy, VTy->getNumElements());
914  }
915  llvm_unreachable("unhandled");
916  }
917  case IITDescriptor::PtrToArgument: {
918  Type *Ty = Tys[D.getArgumentNumber()];
919  return PointerType::getUnqual(Ty);
920  }
921  case IITDescriptor::PtrToElt: {
922  Type *Ty = Tys[D.getArgumentNumber()];
923  VectorType *VTy = dyn_cast<VectorType>(Ty);
924  if (!VTy)
925  llvm_unreachable("Expected an argument of Vector Type");
926  Type *EltTy = VTy->getVectorElementType();
927  return PointerType::getUnqual(EltTy);
928  }
929  case IITDescriptor::VecOfAnyPtrsToElt:
930  // Return the overloaded type (which determines the pointers address space)
931  return Tys[D.getOverloadArgNumber()];
932  }
933  llvm_unreachable("unhandled");
934 }
935 
937  ID id, ArrayRef<Type*> Tys) {
939  getIntrinsicInfoTableEntries(id, Table);
940 
942  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
943 
944  SmallVector<Type*, 8> ArgTys;
945  while (!TableRef.empty())
946  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
947 
948  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
949  // If we see void type as the type of the last argument, it is vararg intrinsic
950  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
951  ArgTys.pop_back();
952  return FunctionType::get(ResultTy, ArgTys, true);
953  }
954  return FunctionType::get(ResultTy, ArgTys, false);
955 }
956 
958 #define GET_INTRINSIC_OVERLOAD_TABLE
959 #include "llvm/IR/Intrinsics.gen"
960 #undef GET_INTRINSIC_OVERLOAD_TABLE
961 }
962 
964  switch (id) {
965  default:
966  return true;
967 
968  case Intrinsic::experimental_gc_statepoint:
969  case Intrinsic::experimental_patchpoint_void:
970  case Intrinsic::experimental_patchpoint_i64:
971  return false;
972  }
973 }
974 
975 /// This defines the "Intrinsic::getAttributes(ID id)" method.
976 #define GET_INTRINSIC_ATTRIBUTES
977 #include "llvm/IR/Intrinsics.gen"
978 #undef GET_INTRINSIC_ATTRIBUTES
979 
981  // There can never be multiple globals with the same name of different types,
982  // because intrinsics must be a specific type.
983  return
984  cast<Function>(M->getOrInsertFunction(getName(id, Tys),
985  getType(M->getContext(), id, Tys)));
986 }
987 
988 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
989 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
990 #include "llvm/IR/Intrinsics.gen"
991 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
992 
993 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
994 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
995 #include "llvm/IR/Intrinsics.gen"
996 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
997 
999  SmallVectorImpl<Type*> &ArgTys) {
1000  using namespace Intrinsic;
1001 
1002  // If we ran out of descriptors, there are too many arguments.
1003  if (Infos.empty()) return true;
1004  IITDescriptor D = Infos.front();
1005  Infos = Infos.slice(1);
1006 
1007  switch (D.Kind) {
1008  case IITDescriptor::Void: return !Ty->isVoidTy();
1009  case IITDescriptor::VarArg: return true;
1010  case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
1011  case IITDescriptor::Token: return !Ty->isTokenTy();
1012  case IITDescriptor::Metadata: return !Ty->isMetadataTy();
1013  case IITDescriptor::Half: return !Ty->isHalfTy();
1014  case IITDescriptor::Float: return !Ty->isFloatTy();
1015  case IITDescriptor::Double: return !Ty->isDoubleTy();
1016  case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
1017  case IITDescriptor::Vector: {
1018  VectorType *VT = dyn_cast<VectorType>(Ty);
1019  return !VT || VT->getNumElements() != D.Vector_Width ||
1020  matchIntrinsicType(VT->getElementType(), Infos, ArgTys);
1021  }
1022  case IITDescriptor::Pointer: {
1023  PointerType *PT = dyn_cast<PointerType>(Ty);
1024  return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
1025  matchIntrinsicType(PT->getElementType(), Infos, ArgTys);
1026  }
1027 
1028  case IITDescriptor::Struct: {
1029  StructType *ST = dyn_cast<StructType>(Ty);
1030  if (!ST || ST->getNumElements() != D.Struct_NumElements)
1031  return true;
1032 
1033  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
1034  if (matchIntrinsicType(ST->getElementType(i), Infos, ArgTys))
1035  return true;
1036  return false;
1037  }
1038 
1039  case IITDescriptor::Argument:
1040  // Two cases here - If this is the second occurrence of an argument, verify
1041  // that the later instance matches the previous instance.
1042  if (D.getArgumentNumber() < ArgTys.size())
1043  return Ty != ArgTys[D.getArgumentNumber()];
1044 
1045  // Otherwise, if this is the first instance of an argument, record it and
1046  // verify the "Any" kind.
1047  assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error");
1048  ArgTys.push_back(Ty);
1049 
1050  switch (D.getArgumentKind()) {
1051  case IITDescriptor::AK_Any: return false; // Success
1052  case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
1053  case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
1054  case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
1055  case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
1056  }
1057  llvm_unreachable("all argument kinds not covered");
1058 
1059  case IITDescriptor::ExtendArgument: {
1060  // This may only be used when referring to a previous vector argument.
1061  if (D.getArgumentNumber() >= ArgTys.size())
1062  return true;
1063 
1064  Type *NewTy = ArgTys[D.getArgumentNumber()];
1065  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1067  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1068  NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
1069  else
1070  return true;
1071 
1072  return Ty != NewTy;
1073  }
1074  case IITDescriptor::TruncArgument: {
1075  // This may only be used when referring to a previous vector argument.
1076  if (D.getArgumentNumber() >= ArgTys.size())
1077  return true;
1078 
1079  Type *NewTy = ArgTys[D.getArgumentNumber()];
1080  if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
1082  else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
1083  NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
1084  else
1085  return true;
1086 
1087  return Ty != NewTy;
1088  }
1089  case IITDescriptor::HalfVecArgument:
1090  // This may only be used when referring to a previous vector argument.
1091  return D.getArgumentNumber() >= ArgTys.size() ||
1092  !isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
1094  cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
1095  case IITDescriptor::SameVecWidthArgument: {
1096  if (D.getArgumentNumber() >= ArgTys.size())
1097  return true;
1098  VectorType * ReferenceType =
1099  dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
1100  VectorType *ThisArgType = dyn_cast<VectorType>(Ty);
1101  if (!ThisArgType || !ReferenceType ||
1102  (ReferenceType->getVectorNumElements() !=
1103  ThisArgType->getVectorNumElements()))
1104  return true;
1105  return matchIntrinsicType(ThisArgType->getVectorElementType(),
1106  Infos, ArgTys);
1107  }
1108  case IITDescriptor::PtrToArgument: {
1109  if (D.getArgumentNumber() >= ArgTys.size())
1110  return true;
1111  Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1112  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1113  return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
1114  }
1115  case IITDescriptor::PtrToElt: {
1116  if (D.getArgumentNumber() >= ArgTys.size())
1117  return true;
1118  VectorType * ReferenceType =
1119  dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
1120  PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
1121 
1122  return (!ThisArgType || !ReferenceType ||
1123  ThisArgType->getElementType() != ReferenceType->getElementType());
1124  }
1125  case IITDescriptor::VecOfAnyPtrsToElt: {
1126  unsigned RefArgNumber = D.getRefArgNumber();
1127 
1128  // This may only be used when referring to a previous argument.
1129  if (RefArgNumber >= ArgTys.size())
1130  return true;
1131 
1132  // Record the overloaded type
1133  assert(D.getOverloadArgNumber() == ArgTys.size() &&
1134  "Table consistency error");
1135  ArgTys.push_back(Ty);
1136 
1137  // Verify the overloaded type "matches" the Ref type.
1138  // i.e. Ty is a vector with the same width as Ref.
1139  // Composed of pointers to the same element type as Ref.
1140  VectorType *ReferenceType = dyn_cast<VectorType>(ArgTys[RefArgNumber]);
1141  VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty);
1142  if (!ThisArgVecTy || !ReferenceType ||
1143  (ReferenceType->getVectorNumElements() !=
1144  ThisArgVecTy->getVectorNumElements()))
1145  return true;
1146  PointerType *ThisArgEltTy =
1147  dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());
1148  if (!ThisArgEltTy)
1149  return true;
1150  return ThisArgEltTy->getElementType() !=
1151  ReferenceType->getVectorElementType();
1152  }
1153  }
1154  llvm_unreachable("unhandled");
1155 }
1156 
1157 bool
1160  // If there are no descriptors left, then it can't be a vararg.
1161  if (Infos.empty())
1162  return isVarArg;
1163 
1164  // There should be only one descriptor remaining at this point.
1165  if (Infos.size() != 1)
1166  return true;
1167 
1168  // Check and verify the descriptor.
1169  IITDescriptor D = Infos.front();
1170  Infos = Infos.slice(1);
1171  if (D.Kind == IITDescriptor::VarArg)
1172  return !isVarArg;
1173 
1174  return true;
1175 }
1176 
1179  if (!ID)
1180  return None;
1181 
1182  FunctionType *FTy = F->getFunctionType();
1183  // Accumulate an array of overloaded types for the given intrinsic
1184  SmallVector<Type *, 4> ArgTys;
1185  {
1187  getIntrinsicInfoTableEntries(ID, Table);
1189 
1190  // If we encounter any problems matching the signature with the descriptor
1191  // just give up remangling. It's up to verifier to report the discrepancy.
1192  if (Intrinsic::matchIntrinsicType(FTy->getReturnType(), TableRef, ArgTys))
1193  return None;
1194  for (auto Ty : FTy->params())
1195  if (Intrinsic::matchIntrinsicType(Ty, TableRef, ArgTys))
1196  return None;
1197  if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef))
1198  return None;
1199  }
1200 
1201  StringRef Name = F->getName();
1202  if (Name == Intrinsic::getName(ID, ArgTys))
1203  return None;
1204 
1205  auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
1206  NewDecl->setCallingConv(F->getCallingConv());
1207  assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature");
1208  return NewDecl;
1209 }
1210 
1211 /// hasAddressTaken - returns true if there are any uses of this function
1212 /// other than direct calls or invokes to it.
1213 bool Function::hasAddressTaken(const User* *PutOffender) const {
1214  for (const Use &U : uses()) {
1215  const User *FU = U.getUser();
1216  if (isa<BlockAddress>(FU))
1217  continue;
1218  if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU)) {
1219  if (PutOffender)
1220  *PutOffender = FU;
1221  return true;
1222  }
1223  ImmutableCallSite CS(cast<Instruction>(FU));
1224  if (!CS.isCallee(&U)) {
1225  if (PutOffender)
1226  *PutOffender = FU;
1227  return true;
1228  }
1229  }
1230  return false;
1231 }
1232 
1234  // Check the linkage
1235  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
1236  !hasAvailableExternallyLinkage())
1237  return false;
1238 
1239  // Check if the function is used by anything other than a blockaddress.
1240  for (const User *U : users())
1241  if (!isa<BlockAddress>(U))
1242  return false;
1243 
1244  return true;
1245 }
1246 
1247 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
1248 /// setjmp or other function that gcc recognizes as "returning twice".
1250  for (const_inst_iterator
1251  I = inst_begin(this), E = inst_end(this); I != E; ++I) {
1252  ImmutableCallSite CS(&*I);
1253  if (CS && CS.hasFnAttr(Attribute::ReturnsTwice))
1254  return true;
1255  }
1256 
1257  return false;
1258 }
1259 
1261  assert(hasPersonalityFn() && getNumOperands());
1262  return cast<Constant>(Op<0>());
1263 }
1264 
1266  setHungoffOperand<0>(Fn);
1267  setValueSubclassDataBit(3, Fn != nullptr);
1268 }
1269 
1271  assert(hasPrefixData() && getNumOperands());
1272  return cast<Constant>(Op<1>());
1273 }
1274 
1276  setHungoffOperand<1>(PrefixData);
1277  setValueSubclassDataBit(1, PrefixData != nullptr);
1278 }
1279 
1281  assert(hasPrologueData() && getNumOperands());
1282  return cast<Constant>(Op<2>());
1283 }
1284 
1286  setHungoffOperand<2>(PrologueData);
1287  setValueSubclassDataBit(2, PrologueData != nullptr);
1288 }
1289 
1290 void Function::allocHungoffUselist() {
1291  // If we've already allocated a uselist, stop here.
1292  if (getNumOperands())
1293  return;
1294 
1295  allocHungoffUses(3, /*IsPhi=*/ false);
1296  setNumHungOffUseOperands(3);
1297 
1298  // Initialize the uselist with placeholder operands to allow traversal.
1300  Op<0>().set(CPN);
1301  Op<1>().set(CPN);
1302  Op<2>().set(CPN);
1303 }
1304 
1305 template <int Idx>
1306 void Function::setHungoffOperand(Constant *C) {
1307  if (C) {
1308  allocHungoffUselist();
1309  Op<Idx>().set(C);
1310  } else if (getNumOperands()) {
1311  Op<Idx>().set(
1313  }
1314 }
1315 
1316 void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
1317  assert(Bit < 16 && "SubclassData contains only 16 bits");
1318  if (On)
1320  else
1322 }
1323 
1324 void Function::setEntryCount(uint64_t Count,
1325  const DenseSet<GlobalValue::GUID> *S) {
1326  MDBuilder MDB(getContext());
1328 }
1329 
1331  MDNode *MD = getMetadata(LLVMContext::MD_prof);
1332  if (MD && MD->getOperand(0))
1333  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1334  if (MDS->getString().equals("function_entry_count")) {
1335  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1336  uint64_t Count = CI->getValue().getZExtValue();
1337  if (Count == 0)
1338  return None;
1339  return Count;
1340  }
1341  return None;
1342 }
1343 
1346  if (MDNode *MD = getMetadata(LLVMContext::MD_prof))
1347  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
1348  if (MDS->getString().equals("function_entry_count"))
1349  for (unsigned i = 2; i < MD->getNumOperands(); i++)
1350  R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
1351  ->getValue()
1352  .getZExtValue());
1353  return R;
1354 }
1355 
1357  MDBuilder MDB(getContext());
1359  MDB.createFunctionSectionPrefix(Prefix));
1360 }
1361 
1363  if (MDNode *MD = getMetadata(LLVMContext::MD_section_prefix)) {
1364  assert(dyn_cast<MDString>(MD->getOperand(0))
1365  ->getString()
1366  .equals("function_section_prefix") &&
1367  "Metadata not match");
1368  return dyn_cast<MDString>(MD->getOperand(1))->getString();
1369  }
1370  return None;
1371 }
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:152
bool hasNestAttr() const
Return true if this argument has the nest attribute.
Definition: Function.cpp:130
Type * getVectorElementType() const
Definition: Type.h:368
uint64_t CallInst * C
unsigned short getSubclassDataFromValue() const
Definition: Value.h:661
iterator_range< use_iterator > uses()
Definition: Value.h:356
bool hasAttribute(Attribute::AttrKind Kind) const
Check if an argument has a given attribute.
Definition: Function.cpp:186
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:401
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:165
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1542
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
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:124
ArgKind getArgumentKind() const
Definition: Intrinsics.h:130
void dropAllReferences()
Drop all references to operands.
Definition: User.h:279
uint64_t getParamDereferenceableBytes(unsigned ArgNo) const
Extract the number of dereferenceable bytes for a parameter.
Definition: Function.h:376
bool isMetadataTy() const
Return true if this is &#39;metadata&#39;.
Definition: Type.h:191
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:314
void removeAttr(Attribute::AttrKind Kind)
Remove attributes from an argument.
Definition: Function.cpp:182
Argument(Type *Ty, const Twine &Name="", Function *F=nullptr, unsigned ArgNo=0)
Argument constructor.
Definition: Function.cpp:69
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:142
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
adds the attribute to the list of attributes for the given arg.
Definition: Function.cpp:365
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
const std::string & getGC(const Function &Fn)
Return the GC for a function.
MDNode * createFunctionEntryCount(uint64_t Count, const DenseSet< GlobalValue::GUID > *Imports)
Return metadata containing the entry Count for a function, and the GUIDs stored in Imports that need ...
Definition: MDBuilder.cpp:60
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
Definition: Function.cpp:419
AMDGPU Rewrite Out Arguments
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:313
void clearGC()
Definition: Function.cpp:454
unsigned getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:363
bool hasByValOrInAllocaAttr() const
Return true if this argument has the byval attribute or inalloca attribute.
Definition: Function.cpp:106
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
void setGC(const Function &Fn, std::string GCName)
Define the GC for a function.
void setGC(std::string Str)
Definition: Function.cpp:449
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:617
void addAttrs(AttrBuilder &B)
Add attributes to an argument.
Definition: Function.cpp:168
bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
Definition: Function.cpp:957
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:728
static MutableArrayRef< Argument > makeArgArray(Argument *Args, size_t Count)
Definition: Function.cpp:267
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:652
void setSectionPrefix(StringRef Prefix)
Set the section prefix for this function.
Definition: Function.cpp:1356
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:767
Metadata node.
Definition: Metadata.h:862
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
F(f)
This is a type descriptor which explains the type requirements of an intrinsic.
Definition: Intrinsics.h:98
static bool isValidReturnType(Type *RetTy)
Return true if the specified type is valid as a return type.
Definition: Type.cpp:321
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:166
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:423
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:171
bool hasByValAttr() const
Return true if this argument has the byval attribute.
Definition: Function.cpp:88
void removeFromParent()
removeFromParent - This method unlinks &#39;this&#39; from the containing module, but does not delete it...
Definition: Function.cpp:198
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:1344
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1280
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:130
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:476
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:643
static Type * getTokenTy(LLVMContext &C)
Definition: Type.cpp:167
inst_iterator inst_begin(Function *F)
Definition: InstIterator.h:132
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:591
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:489
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:164
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:398
Class to represent struct types.
Definition: DerivedTypes.h:201
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:237
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
void deleteGC(const Function &Fn)
Remove the GC for a function.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
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:335
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:286
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
unsigned getArgumentNumber() const
Definition: Intrinsics.h:123
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:336
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1270
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:267
llvm::Optional< Function * > remangleIntrinsicFunction(Function *F)
Definition: Function.cpp:1177
Class to represent function types.
Definition: DerivedTypes.h:103
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
Definition: Function.cpp:611
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
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:162
Class to represent array types.
Definition: DerivedTypes.h:369
bool isVarArg() const
Definition: DerivedTypes.h:123
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:138
const std::string & getGC() const
Definition: Function.cpp:444
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
Definition: Function.cpp:431
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:205
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:634
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:858
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:66
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Extract the number of dereferenceable_or_null bytes for a parameter.
Definition: Function.h:390
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:980
Class to represent pointers.
Definition: DerivedTypes.h:467
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
Definition: Function.cpp:135
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:556
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
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:198
void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
adds the attributes to the list of attributes for the given arg.
Definition: Function.cpp:377
void addAttr(Attribute::AttrKind Kind)
Definition: Function.cpp:174
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:433
void stealArgumentListFrom(Function &Src)
Steal arguments from another function.
Definition: Function.cpp:280
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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:1306
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:291
bool isLeaf(ID id)
Returns true if the intrinsic is a leaf, i.e.
Definition: Function.cpp:963
static Intrinsic::ID lookupIntrinsicID(StringRef Name)
This does the actual lookup of an intrinsic ID which matches the given function name.
Definition: Function.cpp:514
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
const FunctionListType & getFunctionList() const
Get the Module&#39;s list of functions (constant).
Definition: Module.h:507
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:69
bool hasNonNullAttr() const
Return true if this argument has the nonnull attribute.
Definition: Function.cpp:78
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
bool hasStructRetAttr() const
Return true if this argument has the sret attribute.
Definition: Function.cpp:145
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:463
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if this function has the given attribute.
Definition: CallSite.h:362
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:158
void removeAttribute(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: Function.cpp:383
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:130
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: Function.cpp:347
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:161
bool isHalfTy() const
Return true if this is &#39;half&#39;, a 16-bit IEEE fp type.
Definition: Type.h:144
std::string getEVTString() const
This function returns value type as a string, e.g. "i32".
Definition: ValueTypes.cpp:120
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:297
bool hasReturnedAttr() const
Return true if this argument has the returned attribute.
Definition: Function.cpp:150
size_t arg_size() const
Definition: Function.h:630
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:495
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics.h.
Definition: Function.cpp:531
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:1362
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:413
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:194
Optional< uint64_t > getEntryCount() const
Get the entry count for this function.
Definition: Function.cpp:1330
bool hasInAllocaAttr() const
Return true if this argument has the inalloca attribute.
Definition: Function.cpp:101
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:496
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:146
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:645
void setEntryCount(uint64_t Count, const DenseSet< GlobalValue::GUID > *Imports=nullptr)
Set the entry count for this function.
Definition: Function.cpp:1324
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:163
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:240
unsigned getOverloadArgNumber() const
Definition: Intrinsics.h:139
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:216
enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind
bool matchIntrinsicVarArg(bool isVarArg, ArrayRef< IITDescriptor > &Infos)
Verify if the intrinsic has variable arguments.
Definition: Function.cpp:1158
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:482
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:825
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:194
unsigned getParamAlignment() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:113
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:936
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:727
bool hasSwiftSelfAttr() const
Return true if this argument has the swiftself attribute.
Definition: Function.cpp:93
Type * getReturnType() const
Definition: DerivedTypes.h:124
AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
Definition: Attributes.h:418
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:325
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:174
void setValueSubclassData(unsigned short D)
Definition: Value.h:662
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:208
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:415
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:175
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:462
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:145
Class to represent vector types.
Definition: DerivedTypes.h:393
Target - Wrapper for Target specific information.
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:458
void push_back(pointer val)
Definition: ilist.h:326
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Argument.h:48
iterator_range< user_iterator > users()
Definition: Value.h:401
auto lower_bound(R &&Range, ForwardIt I) -> decltype(std::begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:859
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:179
static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)
Definition: Function.cpp:658
void removeAttributes(unsigned i, const AttrBuilder &Attrs)
removes the attributes from the list of attributes.
Definition: Function.cpp:395
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:286
const Function * getParent() const
Definition: Argument.h:42
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:143
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
bool isTokenTy() const
Return true if this is &#39;token&#39;.
Definition: Type.h:194
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:220
Establish a view to a call site for examination.
Definition: CallSite.h:713
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:998
#define I(x, y, z)
Definition: MD5.cpp:58
bool hasSwiftErrorAttr() const
Return true if this argument has the swifterror attribute.
Definition: Function.cpp:97
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1285
Compile-time customization of User operands.
Definition: User.h:43
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:323
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:202
static EVT getEVT(Type *Ty, bool HandleUnknown=false)
Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:311
AttributeList addAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &B) const
Add attributes to the attribute set at the given index.
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:1249
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
Definition: Type.h:185
const unsigned Kind
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:1213
void addAttributes(unsigned i, const AttrBuilder &Attrs)
adds the attributes to the list of attributes.
Definition: Function.cpp:359
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:437
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:556
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1260
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:593
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:235
bool hasZExtAttr() const
Return true if this argument has the zext attribute.
Definition: Function.cpp:154
static const char *const IntrinsicNameTable[]
Table of string intrinsic names indexed by enum value.
Definition: Function.cpp:480
Type * getElementType() const
Definition: DerivedTypes.h:360
MDNode * createFunctionSectionPrefix(StringRef Prefix)
Return metadata containing the section prefix for a function.
Definition: MDBuilder.cpp:77
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
inst_iterator inst_end(Function *F)
Definition: InstIterator.h:133
A single uniqued string.
Definition: Metadata.h:602
int lookupLLVMIntrinsicByName(ArrayRef< const char *> NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1265
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:444
bool hasNoCaptureAttr() const
Return true if this argument has the nocapture attribute.
Definition: Function.cpp:140
void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes for the given arg.
Definition: Function.cpp:425
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:121
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:328
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:1233
uint64_t getDereferenceableBytes() const
If this argument has the dereferenceable attribute, return the number of bytes known to be dereferenc...
Definition: Function.cpp:118
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:105
Type * getElementType() const
Definition: DerivedTypes.h:486
void dropAllReferences()
Cause all subinstructions to "let go" of all the references that said subinstructions are maintaining...
Definition: BasicBlock.cpp:210
std::vector< uint32_t > Metadata
PAL metadata represented as a vector.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1275
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand&#39;s Use.
Definition: CallSite.h:143