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