LLVM  3.7.0
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/DenseMap.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/IR/CallSite.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DerivedTypes.h"
24 #include "llvm/IR/InstIterator.h"
25 #include "llvm/IR/IntrinsicInst.h"
26 #include "llvm/IR/LLVMContext.h"
27 #include "llvm/IR/MDBuilder.h"
28 #include "llvm/IR/Metadata.h"
29 #include "llvm/IR/Module.h"
31 #include "llvm/Support/RWMutex.h"
33 #include "llvm/Support/Threading.h"
34 using namespace llvm;
35 
36 // Explicit instantiations of SymbolTableListTraits since some of the methods
37 // are not in the public header file...
40 
41 //===----------------------------------------------------------------------===//
42 // Argument Implementation
43 //===----------------------------------------------------------------------===//
44 
45 void Argument::anchor() { }
46 
48  : Value(Ty, Value::ArgumentVal) {
49  Parent = nullptr;
50 
51  if (Par)
52  Par->getArgumentList().push_back(this);
53  setName(Name);
54 }
55 
56 void Argument::setParent(Function *parent) {
57  Parent = parent;
58 }
59 
60 /// getArgNo - Return the index of this formal argument in its containing
61 /// function. For example in "void foo(int a, float b)" a is 0 and b is 1.
62 unsigned Argument::getArgNo() const {
63  const Function *F = getParent();
64  assert(F && "Argument is not in a function");
65 
67  unsigned ArgIdx = 0;
68  for (; &*AI != this; ++AI)
69  ++ArgIdx;
70 
71  return ArgIdx;
72 }
73 
74 /// hasNonNullAttr - Return true if this argument has the nonnull attribute on
75 /// it in its containing function. Also returns true if at least one byte is
76 /// known to be dereferenceable and the pointer is in addrspace(0).
78  if (!getType()->isPointerTy()) return false;
79  if (getParent()->getAttributes().
80  hasAttribute(getArgNo()+1, Attribute::NonNull))
81  return true;
82  else if (getDereferenceableBytes() > 0 &&
83  getType()->getPointerAddressSpace() == 0)
84  return true;
85  return false;
86 }
87 
88 /// hasByValAttr - Return true if this argument has the byval attribute on it
89 /// in its containing function.
90 bool Argument::hasByValAttr() const {
91  if (!getType()->isPointerTy()) return false;
92  return getParent()->getAttributes().
93  hasAttribute(getArgNo()+1, Attribute::ByVal);
94 }
95 
96 /// \brief Return true if this argument has the inalloca attribute on it in
97 /// its containing function.
99  if (!getType()->isPointerTy()) return false;
100  return getParent()->getAttributes().
101  hasAttribute(getArgNo()+1, Attribute::InAlloca);
102 }
103 
105  if (!getType()->isPointerTy()) return false;
106  AttributeSet Attrs = getParent()->getAttributes();
107  return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) ||
109 }
110 
111 unsigned Argument::getParamAlignment() const {
112  assert(getType()->isPointerTy() && "Only pointers have alignments");
113  return getParent()->getParamAlignment(getArgNo()+1);
114 
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 /// hasNestAttr - Return true if this argument has the nest attribute on
130 /// it in its containing function.
131 bool Argument::hasNestAttr() const {
132  if (!getType()->isPointerTy()) return false;
133  return getParent()->getAttributes().
134  hasAttribute(getArgNo()+1, Attribute::Nest);
135 }
136 
137 /// hasNoAliasAttr - Return true if this argument has the noalias attribute on
138 /// it in its containing function.
140  if (!getType()->isPointerTy()) return false;
141  return getParent()->getAttributes().
142  hasAttribute(getArgNo()+1, Attribute::NoAlias);
143 }
144 
145 /// hasNoCaptureAttr - Return true if this argument has the nocapture attribute
146 /// on it in its containing function.
148  if (!getType()->isPointerTy()) return false;
149  return getParent()->getAttributes().
150  hasAttribute(getArgNo()+1, Attribute::NoCapture);
151 }
152 
153 /// hasSRetAttr - Return true if this argument has the sret attribute on
154 /// it in its containing function.
156  if (!getType()->isPointerTy()) return false;
157  return getParent()->getAttributes().
158  hasAttribute(getArgNo()+1, Attribute::StructRet);
159 }
160 
161 /// hasReturnedAttr - Return true if this argument has the returned attribute on
162 /// it in its containing function.
164  return getParent()->getAttributes().
165  hasAttribute(getArgNo()+1, Attribute::Returned);
166 }
167 
168 /// hasZExtAttr - Return true if this argument has the zext attribute on it in
169 /// its containing function.
170 bool Argument::hasZExtAttr() const {
171  return getParent()->getAttributes().
172  hasAttribute(getArgNo()+1, Attribute::ZExt);
173 }
174 
175 /// hasSExtAttr Return true if this argument has the sext attribute on it in its
176 /// containing function.
177 bool Argument::hasSExtAttr() const {
178  return getParent()->getAttributes().
179  hasAttribute(getArgNo()+1, Attribute::SExt);
180 }
181 
182 /// Return true if this argument has the readonly or readnone attribute on it
183 /// in its containing function.
185  return getParent()->getAttributes().
186  hasAttribute(getArgNo()+1, Attribute::ReadOnly) ||
188  hasAttribute(getArgNo()+1, Attribute::ReadNone);
189 }
190 
191 /// addAttr - Add attributes to an argument.
193  assert(AS.getNumSlots() <= 1 &&
194  "Trying to add more than one attribute set to an argument!");
195  AttrBuilder B(AS, AS.getSlotIndex(0));
197  AttributeSet::get(Parent->getContext(),
198  getArgNo() + 1, B));
199 }
200 
201 /// removeAttr - Remove attributes from an argument.
203  assert(AS.getNumSlots() <= 1 &&
204  "Trying to remove more than one attribute set from an argument!");
205  AttrBuilder B(AS, AS.getSlotIndex(0));
207  AttributeSet::get(Parent->getContext(),
208  getArgNo() + 1, B));
209 }
210 
211 //===----------------------------------------------------------------------===//
212 // Helper Methods in Function
213 //===----------------------------------------------------------------------===//
214 
216  return getGlobalObjectSubClassData() & IsMaterializableBit;
217 }
218 
220  setGlobalObjectBit(IsMaterializableBit, V);
221 }
222 
224  return getType()->getContext();
225 }
226 
228 
229 bool Function::isVarArg() const {
230  return getFunctionType()->isVarArg();
231 }
232 
234  return getFunctionType()->getReturnType();
235 }
236 
238  getParent()->getFunctionList().remove(this);
239 }
240 
242  getParent()->getFunctionList().erase(this);
243 }
244 
245 //===----------------------------------------------------------------------===//
246 // Function Implementation
247 //===----------------------------------------------------------------------===//
248 
249 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name,
250  Module *ParentModule)
251  : GlobalObject(PointerType::getUnqual(Ty), Value::FunctionVal,
252  OperandTraits<Function>::op_begin(this), 0, Linkage, name),
253  Ty(Ty) {
255  "invalid return type");
257  SymTab = new ValueSymbolTable();
258 
259  // If the function has arguments, mark them as lazily built.
260  if (Ty->getNumParams())
261  setValueSubclassData(1); // Set the "has lazy arguments" bit.
262 
263  if (ParentModule)
264  ParentModule->getFunctionList().push_back(this);
265 
266  // Ensure intrinsics have the right parameter attributes.
267  // Note, the IntID field will have been set in Value::setName if this function
268  // name is a valid intrinsic ID.
269  if (IntID)
271 }
272 
274  dropAllReferences(); // After this it is safe to delete instructions.
275 
276  // Delete all of the method arguments and unlink from symbol table...
277  ArgumentList.clear();
278  delete SymTab;
279 
280  // Remove the function from the on-the-side GC table.
281  clearGC();
282 
283  // FIXME: needed by operator delete
285 }
286 
287 void Function::BuildLazyArguments() const {
288  // Create the arguments vector, all arguments start out unnamed.
290  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
291  assert(!FT->getParamType(i)->isVoidTy() &&
292  "Cannot have void typed arguments!");
293  ArgumentList.push_back(new Argument(FT->getParamType(i)));
294  }
295 
296  // Clear the lazy arguments bit.
297  unsigned SDC = getSubclassDataFromValue();
298  const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0));
299 }
300 
301 size_t Function::arg_size() const {
302  return getFunctionType()->getNumParams();
303 }
304 bool Function::arg_empty() const {
305  return getFunctionType()->getNumParams() == 0;
306 }
307 
308 void Function::setParent(Module *parent) {
309  Parent = parent;
310 }
311 
312 // dropAllReferences() - This function causes all the subinstructions to "let
313 // go" of all references that they are maintaining. This allows one to
314 // 'delete' a whole class at a time, even though there may be circular
315 // references... first all references are dropped, and all use counts go to
316 // zero. Then everything is deleted for real. Note that no operations are
317 // valid on an object that has "dropped all references", except operator
318 // delete.
319 //
321  setIsMaterializable(false);
322 
323  for (iterator I = begin(), E = end(); I != E; ++I)
324  I->dropAllReferences();
325 
326  // Delete all basic blocks. They are now unused, except possibly by
327  // blockaddresses, but BasicBlock's destructor takes care of those.
328  while (!BasicBlocks.empty())
329  BasicBlocks.begin()->eraseFromParent();
330 
331  // Prefix and prologue data are stored in a side table.
332  setPrefixData(nullptr);
333  setPrologueData(nullptr);
334 
335  // Metadata is stored in a side-table.
336  clearMetadata();
337 
338  setPersonalityFn(nullptr);
339 }
340 
342  AttributeSet PAL = getAttributes();
343  PAL = PAL.addAttribute(getContext(), i, attr);
344  setAttributes(PAL);
345 }
346 
347 void Function::addAttributes(unsigned i, AttributeSet attrs) {
348  AttributeSet PAL = getAttributes();
349  PAL = PAL.addAttributes(getContext(), i, attrs);
350  setAttributes(PAL);
351 }
352 
353 void Function::removeAttributes(unsigned i, AttributeSet attrs) {
354  AttributeSet PAL = getAttributes();
355  PAL = PAL.removeAttributes(getContext(), i, attrs);
356  setAttributes(PAL);
357 }
358 
359 void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
360  AttributeSet PAL = getAttributes();
361  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
362  setAttributes(PAL);
363 }
364 
365 void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
366  AttributeSet PAL = getAttributes();
367  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
368  setAttributes(PAL);
369 }
370 
371 // Maintain the GC name for each function in an on-the-side table. This saves
372 // allocating an additional word in Function for programs which do not use GC
373 // (i.e., most programs) at the cost of increased overhead for clients which do
374 // use GC.
378 
379 bool Function::hasGC() const {
381  return GCNames && GCNames->count(this);
382 }
383 
384 const char *Function::getGC() const {
385  assert(hasGC() && "Function has no collector");
387  return *(*GCNames)[this];
388 }
389 
390 void Function::setGC(const char *Str) {
392  if (!GCNamePool)
393  GCNamePool = new StringPool();
394  if (!GCNames)
396  (*GCNames)[this] = GCNamePool->intern(Str);
397 }
398 
401  if (GCNames) {
402  GCNames->erase(this);
403  if (GCNames->empty()) {
404  delete GCNames;
405  GCNames = nullptr;
406  if (GCNamePool->empty()) {
407  delete GCNamePool;
408  GCNamePool = nullptr;
409  }
410  }
411  }
412 }
413 
414 /// copyAttributesFrom - copy all additional attributes (those not needed to
415 /// create a Function) from the Function Src to this one.
417  assert(isa<Function>(Src) && "Expected a Function!");
419  const Function *SrcF = cast<Function>(Src);
421  setAttributes(SrcF->getAttributes());
422  if (SrcF->hasGC())
423  setGC(SrcF->getGC());
424  else
425  clearGC();
426  if (SrcF->hasPrefixData())
427  setPrefixData(SrcF->getPrefixData());
428  else
429  setPrefixData(nullptr);
430  if (SrcF->hasPrologueData())
432  else
433  setPrologueData(nullptr);
434  if (SrcF->hasPersonalityFn())
436  else
437  setPersonalityFn(nullptr);
438 }
439 
440 /// \brief This does the actual lookup of an intrinsic ID which
441 /// matches the given function name.
442 static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
443  unsigned Len = ValName->getKeyLength();
444  const char *Name = ValName->getKeyData();
445 
446 #define GET_FUNCTION_RECOGNIZER
447 #include "llvm/IR/Intrinsics.gen"
448 #undef GET_FUNCTION_RECOGNIZER
449 
451 }
452 
454  const ValueName *ValName = this->getValueName();
455  if (!ValName || !isIntrinsic()) {
457  return;
458  }
459  IntID = lookupIntrinsicID(ValName);
460 }
461 
462 /// Returns a stable mangling for the type specified for use in the name
463 /// mangling scheme used by 'any' types in intrinsic signatures. The mangling
464 /// of named types is simply their name. Manglings for unnamed types consist
465 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
466 /// combined with the mangling of their component types. A vararg function
467 /// type will have a suffix of 'vararg'. Since function types can contain
468 /// other function types, we close a function type mangling with suffix 'f'
469 /// which can't be confused with it's prefix. This ensures we don't have
470 /// collisions between two unrelated function types. Otherwise, you might
471 /// parse ffXX as f(fXX) or f(fX)X. (X is a placeholder for any other type.)
472 /// Manglings of integers, floats, and vectors ('i', 'f', and 'v' prefix in most
473 /// cases) fall back to the MVT codepath, where they could be mangled to
474 /// 'x86mmx', for example; matching on derived types is not sufficient to mangle
475 /// everything.
476 static std::string getMangledTypeStr(Type* Ty) {
477  std::string Result;
478  if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
479  Result += "p" + llvm::utostr(PTyp->getAddressSpace()) +
480  getMangledTypeStr(PTyp->getElementType());
481  } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
482  Result += "a" + llvm::utostr(ATyp->getNumElements()) +
483  getMangledTypeStr(ATyp->getElementType());
484  } else if (StructType* STyp = dyn_cast<StructType>(Ty)) {
485  assert(!STyp->isLiteral() && "TODO: implement literal types");
486  Result += STyp->getName();
487  } else if (FunctionType* FT = dyn_cast<FunctionType>(Ty)) {
488  Result += "f_" + getMangledTypeStr(FT->getReturnType());
489  for (size_t i = 0; i < FT->getNumParams(); i++)
490  Result += getMangledTypeStr(FT->getParamType(i));
491  if (FT->isVarArg())
492  Result += "vararg";
493  // Ensure nested function types are distinguishable.
494  Result += "f";
495  } else if (Ty)
496  Result += EVT::getEVT(Ty).getEVTString();
497  return Result;
498 }
499 
500 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
501  assert(id < num_intrinsics && "Invalid intrinsic ID!");
502  static const char * const Table[] = {
503  "not_intrinsic",
504 #define GET_INTRINSIC_NAME_TABLE
505 #include "llvm/IR/Intrinsics.gen"
506 #undef GET_INTRINSIC_NAME_TABLE
507  };
508  if (Tys.empty())
509  return Table[id];
510  std::string Result(Table[id]);
511  for (unsigned i = 0; i < Tys.size(); ++i) {
512  Result += "." + getMangledTypeStr(Tys[i]);
513  }
514  return Result;
515 }
516 
517 
518 /// IIT_Info - These are enumerators that describe the entries returned by the
519 /// getIntrinsicInfoTableEntries function.
520 ///
521 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
522 enum IIT_Info {
523  // Common values should be encoded with 0-15.
524  IIT_Done = 0,
525  IIT_I1 = 1,
526  IIT_I8 = 2,
527  IIT_I16 = 3,
528  IIT_I32 = 4,
529  IIT_I64 = 5,
530  IIT_F16 = 6,
531  IIT_F32 = 7,
532  IIT_F64 = 8,
533  IIT_V2 = 9,
534  IIT_V4 = 10,
535  IIT_V8 = 11,
536  IIT_V16 = 12,
537  IIT_V32 = 13,
538  IIT_PTR = 14,
539  IIT_ARG = 15,
540 
541  // Values from 16+ are only encodable with the inefficient encoding.
542  IIT_V64 = 16,
543  IIT_MMX = 17,
553  IIT_V1 = 27,
559  IIT_I128 = 33
560 };
561 
562 
563 static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
565  IIT_Info Info = IIT_Info(Infos[NextElt++]);
566  unsigned StructElts = 2;
567  using namespace Intrinsic;
568 
569  switch (Info) {
570  case IIT_Done:
572  return;
573  case IIT_VARARG:
575  return;
576  case IIT_MMX:
578  return;
579  case IIT_METADATA:
581  return;
582  case IIT_F16:
584  return;
585  case IIT_F32:
587  return;
588  case IIT_F64:
590  return;
591  case IIT_I1:
593  return;
594  case IIT_I8:
596  return;
597  case IIT_I16:
599  return;
600  case IIT_I32:
602  return;
603  case IIT_I64:
605  return;
606  case IIT_I128:
608  return;
609  case IIT_V1:
611  DecodeIITType(NextElt, Infos, OutputTable);
612  return;
613  case IIT_V2:
615  DecodeIITType(NextElt, Infos, OutputTable);
616  return;
617  case IIT_V4:
619  DecodeIITType(NextElt, Infos, OutputTable);
620  return;
621  case IIT_V8:
623  DecodeIITType(NextElt, Infos, OutputTable);
624  return;
625  case IIT_V16:
627  DecodeIITType(NextElt, Infos, OutputTable);
628  return;
629  case IIT_V32:
631  DecodeIITType(NextElt, Infos, OutputTable);
632  return;
633  case IIT_V64:
635  DecodeIITType(NextElt, Infos, OutputTable);
636  return;
637  case IIT_PTR:
639  DecodeIITType(NextElt, Infos, OutputTable);
640  return;
641  case IIT_ANYPTR: { // [ANYPTR addrspace, subtype]
643  Infos[NextElt++]));
644  DecodeIITType(NextElt, Infos, OutputTable);
645  return;
646  }
647  case IIT_ARG: {
648  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
650  return;
651  }
652  case IIT_EXTEND_ARG: {
653  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
655  ArgInfo));
656  return;
657  }
658  case IIT_TRUNC_ARG: {
659  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
661  ArgInfo));
662  return;
663  }
664  case IIT_HALF_VEC_ARG: {
665  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
667  ArgInfo));
668  return;
669  }
670  case IIT_SAME_VEC_WIDTH_ARG: {
671  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
673  ArgInfo));
674  return;
675  }
676  case IIT_PTR_TO_ARG: {
677  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
679  ArgInfo));
680  return;
681  }
682  case IIT_VEC_OF_PTRS_TO_ELT: {
683  unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
685  ArgInfo));
686  return;
687  }
688  case IIT_EMPTYSTRUCT:
690  return;
691  case IIT_STRUCT5: ++StructElts; // FALL THROUGH.
692  case IIT_STRUCT4: ++StructElts; // FALL THROUGH.
693  case IIT_STRUCT3: ++StructElts; // FALL THROUGH.
694  case IIT_STRUCT2: {
695  OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
696 
697  for (unsigned i = 0; i != StructElts; ++i)
698  DecodeIITType(NextElt, Infos, OutputTable);
699  return;
700  }
701  }
702  llvm_unreachable("unhandled");
703 }
704 
705 
706 #define GET_INTRINSIC_GENERATOR_GLOBAL
707 #include "llvm/IR/Intrinsics.gen"
708 #undef GET_INTRINSIC_GENERATOR_GLOBAL
709 
712  // Check to see if the intrinsic's type was expressible by the table.
713  unsigned TableVal = IIT_Table[id-1];
714 
715  // Decode the TableVal into an array of IITValues.
717  ArrayRef<unsigned char> IITEntries;
718  unsigned NextElt = 0;
719  if ((TableVal >> 31) != 0) {
720  // This is an offset into the IIT_LongEncodingTable.
721  IITEntries = IIT_LongEncodingTable;
722 
723  // Strip sentinel bit.
724  NextElt = (TableVal << 1) >> 1;
725  } else {
726  // Decode the TableVal into an array of IITValues. If the entry was encoded
727  // into a single word in the table itself, decode it now.
728  do {
729  IITValues.push_back(TableVal & 0xF);
730  TableVal >>= 4;
731  } while (TableVal);
732 
733  IITEntries = IITValues;
734  NextElt = 0;
735  }
736 
737  // Okay, decode the table into the output vector of IITDescriptors.
738  DecodeIITType(NextElt, IITEntries, T);
739  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
740  DecodeIITType(NextElt, IITEntries, T);
741 }
742 
743 
745  ArrayRef<Type*> Tys, LLVMContext &Context) {
746  using namespace Intrinsic;
747  IITDescriptor D = Infos.front();
748  Infos = Infos.slice(1);
749 
750  switch (D.Kind) {
751  case IITDescriptor::Void: return Type::getVoidTy(Context);
752  case IITDescriptor::VarArg: return Type::getVoidTy(Context);
753  case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
754  case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
755  case IITDescriptor::Half: return Type::getHalfTy(Context);
756  case IITDescriptor::Float: return Type::getFloatTy(Context);
757  case IITDescriptor::Double: return Type::getDoubleTy(Context);
758 
760  return IntegerType::get(Context, D.Integer_Width);
762  return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
764  return PointerType::get(DecodeFixedType(Infos, Tys, Context),
765  D.Pointer_AddressSpace);
766  case IITDescriptor::Struct: {
767  Type *Elts[5];
768  assert(D.Struct_NumElements <= 5 && "Can't handle this yet");
769  for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
770  Elts[i] = DecodeFixedType(Infos, Tys, Context);
771  return StructType::get(Context, makeArrayRef(Elts,D.Struct_NumElements));
772  }
773 
775  return Tys[D.getArgumentNumber()];
777  Type *Ty = Tys[D.getArgumentNumber()];
778  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
780 
781  return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
782  }
784  Type *Ty = Tys[D.getArgumentNumber()];
785  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
787 
788  IntegerType *ITy = cast<IntegerType>(Ty);
789  assert(ITy->getBitWidth() % 2 == 0);
790  return IntegerType::get(Context, ITy->getBitWidth() / 2);
791  }
793  return VectorType::getHalfElementsVectorType(cast<VectorType>(
794  Tys[D.getArgumentNumber()]));
796  Type *EltTy = DecodeFixedType(Infos, Tys, Context);
797  Type *Ty = Tys[D.getArgumentNumber()];
798  if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
799  return VectorType::get(EltTy, VTy->getNumElements());
800  }
801  llvm_unreachable("unhandled");
802  }
804  Type *Ty = Tys[D.getArgumentNumber()];
805  return PointerType::getUnqual(Ty);
806  }
808  Type *Ty = Tys[D.getArgumentNumber()];
809  VectorType *VTy = dyn_cast<VectorType>(Ty);
810  if (!VTy)
811  llvm_unreachable("Expected an argument of Vector Type");
812  Type *EltTy = VTy->getVectorElementType();
814  VTy->getNumElements());
815  }
816  }
817  llvm_unreachable("unhandled");
818 }
819 
820 
821 
823  ID id, ArrayRef<Type*> Tys) {
825  getIntrinsicInfoTableEntries(id, Table);
826 
827  ArrayRef<IITDescriptor> TableRef = Table;
828  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
829 
830  SmallVector<Type*, 8> ArgTys;
831  while (!TableRef.empty())
832  ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
833 
834  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
835  // If we see void type as the type of the last argument, it is vararg intrinsic
836  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
837  ArgTys.pop_back();
838  return FunctionType::get(ResultTy, ArgTys, true);
839  }
840  return FunctionType::get(ResultTy, ArgTys, false);
841 }
842 
844 #define GET_INTRINSIC_OVERLOAD_TABLE
845 #include "llvm/IR/Intrinsics.gen"
846 #undef GET_INTRINSIC_OVERLOAD_TABLE
847 }
848 
850  switch (id) {
851  default:
852  return true;
853 
854  case Intrinsic::experimental_gc_statepoint:
855  case Intrinsic::experimental_patchpoint_void:
856  case Intrinsic::experimental_patchpoint_i64:
857  return false;
858  }
859 }
860 
861 /// This defines the "Intrinsic::getAttributes(ID id)" method.
862 #define GET_INTRINSIC_ATTRIBUTES
863 #include "llvm/IR/Intrinsics.gen"
864 #undef GET_INTRINSIC_ATTRIBUTES
865 
867  // There can never be multiple globals with the same name of different types,
868  // because intrinsics must be a specific type.
869  return
870  cast<Function>(M->getOrInsertFunction(getName(id, Tys),
871  getType(M->getContext(), id, Tys)));
872 }
873 
874 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
875 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
876 #include "llvm/IR/Intrinsics.gen"
877 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
878 
879 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
880 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
881 #include "llvm/IR/Intrinsics.gen"
882 #undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
883 
884 /// hasAddressTaken - returns true if there are any uses of this function
885 /// other than direct calls or invokes to it.
886 bool Function::hasAddressTaken(const User* *PutOffender) const {
887  for (const Use &U : uses()) {
888  const User *FU = U.getUser();
889  if (isa<BlockAddress>(FU))
890  continue;
891  if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU))
892  return PutOffender ? (*PutOffender = FU, true) : true;
893  ImmutableCallSite CS(cast<Instruction>(FU));
894  if (!CS.isCallee(&U))
895  return PutOffender ? (*PutOffender = FU, true) : true;
896  }
897  return false;
898 }
899 
901  // Check the linkage
902  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
904  return false;
905 
906  // Check if the function is used by anything other than a blockaddress.
907  for (const User *U : users())
908  if (!isa<BlockAddress>(U))
909  return false;
910 
911  return true;
912 }
913 
914 /// callsFunctionThatReturnsTwice - Return true if the function has a call to
915 /// setjmp or other function that gcc recognizes as "returning twice".
918  I = inst_begin(this), E = inst_end(this); I != E; ++I) {
920  if (CS && CS.hasFnAttr(Attribute::ReturnsTwice))
921  return true;
922  }
923 
924  return false;
925 }
926 
928  assert(hasPrefixData());
929  const LLVMContextImpl::PrefixDataMapTy &PDMap =
931  assert(PDMap.find(this) != PDMap.end());
932  return cast<Constant>(PDMap.find(this)->second->getReturnValue());
933 }
934 
936  if (!PrefixData && !hasPrefixData())
937  return;
938 
939  unsigned SCData = getSubclassDataFromValue();
941  ReturnInst *&PDHolder = PDMap[this];
942  if (PrefixData) {
943  if (PDHolder)
944  PDHolder->setOperand(0, PrefixData);
945  else
946  PDHolder = ReturnInst::Create(getContext(), PrefixData);
947  SCData |= (1<<1);
948  } else {
949  delete PDHolder;
950  PDMap.erase(this);
951  SCData &= ~(1<<1);
952  }
953  setValueSubclassData(SCData);
954 }
955 
957  assert(hasPrologueData());
960  assert(SOMap.find(this) != SOMap.end());
961  return cast<Constant>(SOMap.find(this)->second->getReturnValue());
962 }
963 
964 void Function::setPrologueData(Constant *PrologueData) {
965  if (!PrologueData && !hasPrologueData())
966  return;
967 
968  unsigned PDData = getSubclassDataFromValue();
970  ReturnInst *&PDHolder = PDMap[this];
971  if (PrologueData) {
972  if (PDHolder)
973  PDHolder->setOperand(0, PrologueData);
974  else
975  PDHolder = ReturnInst::Create(getContext(), PrologueData);
976  PDData |= (1<<2);
977  } else {
978  delete PDHolder;
979  PDMap.erase(this);
980  PDData &= ~(1<<2);
981  }
982  setValueSubclassData(PDData);
983 }
984 
985 void Function::setEntryCount(uint64_t Count) {
986  MDBuilder MDB(getContext());
988 }
989 
992  if (MD && MD->getOperand(0))
993  if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
994  if (MDS->getString().equals("function_entry_count")) {
995  ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
996  return CI->getValue().getZExtValue();
997  }
998  return None;
999 }
1000 
1002  if (!C) {
1003  if (hasPersonalityFn()) {
1004  // Note, the num operands is used to compute the offset of the operand, so
1005  // the order here matters. Clearing the operand then clearing the num
1006  // operands ensures we have the correct offset to the operand.
1007  Op<0>().set(nullptr);
1009  }
1010  } else {
1011  // Note, the num operands is used to compute the offset of the operand, so
1012  // the order here matters. We need to set num operands to 1 first so that
1013  // we get the correct offset to the first operand when we set it.
1014  if (!hasPersonalityFn())
1016  Op<0>().set(C);
1017  }
1018 }
bool hasNoCaptureAttr() const
Return true if this argument has the nocapture attribute on it in its containing function.
Definition: Function.cpp:147
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute on it in its containing function.
Definition: Function.cpp:139
bool isDefTriviallyDead() const
isDefTriviallyDead - Return true if it is trivially safe to remove this function definition from the ...
Definition: Function.cpp:900
void setPersonalityFn(Constant *C)
Definition: Function.cpp:1001
ReturnInst - Return a value (possibly void), from a function.
This class provides a symbol table of name/value pairs.
iterator_range< use_iterator > uses()
Definition: Value.h:283
void setFunctionNumOperands(unsigned NumOps)
Set the number of operands on a Function.
Definition: User.h:161
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:229
PooledStringPtr intern(StringRef Str)
intern - Adds a string to the pool and returns a reference-counted pointer to it. ...
Definition: StringPool.cpp:25
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
LLVM Argument representation.
Definition: Argument.h:35
Constant * getPrologueData() const
Definition: Function.cpp:956
bool onlyReadsMemory() const
Return true if this argument has the readonly or readnone attribute on it in its containing function...
Definition: Function.cpp:184
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
Sign extended before/after call.
Definition: Attributes.h:105
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:28
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
unsigned getNumParams() const
getNumParams - Return the number of fixed parameters this function type requires. ...
Definition: DerivedTypes.h:136
iterator end()
Definition: Function.h:459
PrefixDataMapTy PrefixDataMap
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:137
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
Definition: Function.cpp:359
bool hasByValOrInAllocaAttr() const
Return true if this argument has the byval attribute or inalloca attribute on it in its containing fu...
Definition: Function.cpp:104
Nested function static chain.
Definition: Attributes.h:82
void clearGC()
Definition: Function.cpp:399
const char * getGC() const
Definition: Function.cpp:384
bool isIntrinsic() const
Definition: Function.h:160
This file contains the declarations for metadata subclasses.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
PointerType::get - This constructs a pointer to an object of the specified type in a numbered address...
Definition: Type.cpp:738
bool isOverloaded(ID id)
Returns true if the intrinsic can be overloaded.
Definition: Function.cpp:843
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:261
Type * getReturnType() const
Definition: Function.cpp:233
bool hasPrologueData() const
Definition: Function.h:509
Metadata node.
Definition: Metadata.h:740
F(f)
static bool isValidReturnType(Type *RetTy)
isValidReturnType - Return true if the specified type is valid as a return type.
Definition: Type.cpp:387
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:61
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
iterator begin()
Definition: ilist.h:359
static Type * getMetadataTy(LLVMContext &C)
Definition: Type.cpp:230
static VectorType * getTruncatedElementVectorType(VectorType *VTy)
VectorType::getTruncatedElementVectorType - This static method is like getInteger except that the ele...
Definition: DerivedTypes.h:399
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:956
static Type * getX86_MMXTy(LLVMContext &C)
Definition: Type.cpp:234
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:172
bool isMaterializable() const
Definition: Function.cpp:215
size_t arg_size() const
Definition: Function.cpp:301
uint64_t getDereferenceableBytes(unsigned i) const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
Definition: Function.h:267
unsigned getGlobalObjectSubClassData() const
Definition: Globals.cpp:87
void addAttr(AttributeSet AS)
Add a Attribute to an argument.
Definition: Function.cpp:192
bool empty() const
empty - Checks whether the pool is empty.
Definition: StringPool.h:70
static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, Instruction *InsertBefore=nullptr)
StringPool - An interned string pool.
Definition: StringPool.h:42
void push_back(NodeTy *val)
Definition: ilist.h:554
std::string getEVTString() const
getEVTString - This function returns value type as a string, e.g.
Definition: ValueTypes.cpp:106
inst_iterator inst_begin(Function *F)
Definition: InstIterator.h:127
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:228
static DenseMap< const Function *, PooledStringPtr > * GCNames
Definition: Function.cpp:375
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:308
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
static StringRef getName(Value *V)
void setMetadata(unsigned KindID, MDNode *MD)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1191
AttributeSet addDereferenceableAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
Definition: Attributes.cpp:907
bool hasFnAttr(Attribute::AttrKind A) const
Return true if this function has the given attribute.
Definition: CallSite.h:237
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
uint64_t getDereferenceableOrNullBytes() const
If this argument has the dereferenceable_or_null attribute on it in its containing function...
Definition: Function.cpp:123
Type * getVectorElementType() const
Definition: Type.h:364
ScopedReader - RAII acquisition of a reader lock.
Definition: RWMutex.h:147
Function does not access memory.
Definition: Attributes.h:99
Hidden pointer to structure to return.
Definition: Attributes.h:114
Function creates no aliases of pointer.
Definition: Attributes.h:85
uint64_t getDereferenceableBytes() const
If this argument has the dereferenceable attribute on it in its containing function, return the number of bytes known to be dereferenceable.
Definition: Function.cpp:117
void clear()
Definition: ilist.h:550
void removeAttr(AttributeSet AS)
Remove a Attribute from an argument.
Definition: Function.cpp:202
ScopedWriter - RAII acquisition of a writer lock.
Definition: RWMutex.h:162
PrologueDataMapTy PrologueDataMap
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
IIT_Info
IIT_Info - These are enumerators that describe the entries returned by the getIntrinsicInfoTableEntri...
Definition: Function.cpp:522
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
Definition: Type.h:125
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
bool hasStructRetAttr() const
Return true if this argument has the sret attribute on it in its containing function.
Definition: Function.cpp:155
ArrayRef< T > slice(unsigned N) const
slice(n) - Chop off the first N elements of the array.
Definition: ArrayRef.h:165
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
static StringPool * GCNamePool
Definition: Function.cpp:376
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
FunctionType::get - This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:93
Pass structure by value.
Definition: Attributes.h:73
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:866
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
Definition: Function.cpp:365
bool hasNestAttr() const
Return true if this argument has the nest attribute on it in its containing function.
Definition: Function.cpp:131
Optional< uint64_t > getEntryCount() const
Get the entry count for this function.
Definition: Function.cpp:990
unsigned getNumElements() const
Return the number of elements in the Vector type.
Definition: DerivedTypes.h:432
void removeAttributes(unsigned i, AttributeSet attr)
removes the attributes from the list of attributes.
Definition: Function.cpp:353
iterator begin()
Definition: Function.h:457
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
Considered to not alias after call.
Definition: Attributes.h:83
ValueName * getValueName() const
Definition: Value.cpp:160
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
static std::string getMangledTypeStr(Type *Ty)
Returns a stable mangling for the type specified for use in the name mangling scheme used by 'any' ty...
Definition: Function.cpp:476
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:175
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:131
bool erase(const KeyT &Val)
Definition: DenseMap.h:206
static VectorType * getHalfElementsVectorType(VectorType *VTy)
VectorType::getHalfElementsVectorType - This static method returns a VectorType with half as many ele...
Definition: DerivedTypes.h:411
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachment, if any.
Definition: Metadata.cpp:1179
bool isLeaf(ID id)
Returns true if the intrinsic is a leaf, i.e.
Definition: Function.cpp:849
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeSet AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:115
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
const Function * getParent() const
Definition: Argument.h:49
This is an important base class in LLVM.
Definition: Constant.h:41
bool hasInAllocaAttr() const
Return true if this argument has the inalloca attribute on it in its containing function.
Definition: Function.cpp:98
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned getParamAlignment() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:111
bool hasPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.h:132
Return value is always equal to this argument.
Definition: Attributes.h:103
Pass structure in an alloca.
Definition: Attributes.h:74
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:225
bool hasSExtAttr() const
Return true if this argument has the sext attribute on it in its containing function.
Definition: Function.cpp:177
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:416
Zero extended before/after call.
Definition: Attributes.h:119
static IITDescriptor get(IITDescriptorKind K, unsigned Field)
Definition: Intrinsics.h:119
void recalculateIntrinsicID()
Recalculate the ID for this function if it is an Intrinsic defined in llvm/Intrinsics.h.
Definition: Function.cpp:453
arg_iterator arg_begin()
Definition: Function.h:472
Intrinsic::ID IntID
The intrinsic ID for this subclass (which must be a Function).
Definition: GlobalValue.h:104
Class to represent integer types.
Definition: DerivedTypes.h:37
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:129
MDNode * createFunctionEntryCount(uint64_t Count)
Return metadata containing the entry count for a function.
Definition: MDBuilder.cpp:56
iterator erase(iterator where)
Definition: ilist.h:465
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:43
Pointer is known to be not null.
Definition: Attributes.h:91
static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName)
This does the actual lookup of an intrinsic ID which matches the given function name.
Definition: Function.cpp:442
void setEntryCount(uint64_t Count)
Set the entry count for this function.
Definition: Function.cpp:985
bool hasByValAttr() const
Return true if this argument has the byval attribute on it in its containing function.
Definition: Function.cpp:90
const FunctionListType & getFunctionList() const
Get the Module's list of functions (constant).
Definition: Module.h:519
static Type * getHalfTy(LLVMContext &C)
Definition: Type.cpp:227
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:304
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:936
~Function() override
Definition: Function.cpp:273
uint64_t getDereferenceableOrNullBytes(unsigned i) const
Extract the number of dereferenceable_or_null bytes for a call or parameter (0=unknown).
Definition: Function.h:273
static PointerType * getUnqual(Type *ElementType)
PointerType::getUnqual - This constructs a pointer to an object of the specified type in the generic ...
Definition: DerivedTypes.h:460
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
StructType::get - This static method is the primary way to create a literal StructType.
Definition: Type.cpp:404
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Function.cpp:710
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: ilist.h:385
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:320
const char * getKeyData() const
getKeyData - Return the start of the string data that is the key for this value.
Definition: StringMap.h:136
void copyAttributesFrom(const GlobalValue *Src) override
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to...
Definition: Globals.cpp:99
bool hasZExtAttr() const
Return true if this argument has the zext attribute on it in its containing function.
Definition: Function.cpp:170
static VectorType * getExtendedElementVectorType(VectorType *VTy)
VectorType::getExtendedElementVectorType - This static method is like getInteger except that the elem...
Definition: DerivedTypes.h:389
void setOperand(unsigned i, Value *Val)
Definition: User.h:122
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:181
AttributeSet removeAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:828
bool arg_empty() const
Definition: Function.cpp:304
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
Argument(Type *Ty, const Twine &Name="", Function *F=nullptr)
Constructor.
Definition: Function.cpp:47
void addAttribute(unsigned i, Attribute::AttrKind attr)
adds the attribute to the list of attributes.
Definition: Function.cpp:341
iterator_range< user_iterator > users()
Definition: Value.h:300
Function only reads from memory.
Definition: Attributes.h:100
bool hasNonNullAttr() const
Return true if this argument has the nonnull attribute on it in its containing function.
Definition: Function.cpp:77
LLVM_ATTRIBUTE_UNUSED_RESULT 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:285
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.cpp:379
void setGC(const char *Str)
Definition: Function.cpp:390
void setIsMaterializable(bool V)
Definition: Function.cpp:219
static void DecodeIITType(unsigned &NextElt, ArrayRef< unsigned char > Infos, SmallVectorImpl< Intrinsic::IITDescriptor > &OutputTable)
Definition: Function.cpp:563
void eraseFromParent() override
eraseFromParent - This method unlinks 'this' from the containing module and deletes it...
Definition: Function.cpp:241
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:264
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
AttributeSet addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Attr) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:753
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:886
void removeFromParent() override
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it...
Definition: Function.cpp:237
unsigned short getSubclassDataFromValue() const
Definition: Value.h:507
std::string getName(ID id, ArrayRef< Type * > Tys=None)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:500
Constant * getPersonalityFn() const
Definition: Function.h:133
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
AttributeSet addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given index.
Definition: Attributes.cpp:914
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:418
#define I(x, y, z)
Definition: MD5.cpp:54
FunctionType * getFunctionType() const
Definition: Function.cpp:227
bool callsFunctionThatReturnsTwice() const
callsFunctionThatReturnsTwice - Return true if the function has a call to setjmp or other function th...
Definition: Function.cpp:916
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:964
unsigned getKeyLength() const
Definition: StringMap.h:36
iterator end()
Definition: DenseMap.h:68
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
Compile-time customization of User operands.
Definition: User.h:34
bool hasPrefixData() const
Definition: Function.h:502
Constant * getPrefixData() const
Definition: Function.cpp:927
static EVT getEVT(Type *Ty, bool HandleUnknown=false)
getEVT - Return the value type corresponding to the specified type.
Definition: ValueTypes.cpp:277
AttributeSet getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
static ManagedStatic< sys::SmartRWMutex< true > > GCLock
Definition: Function.cpp:377
void setAttributes(AttributeSet attrs)
Set the attribute list for this Function.
Definition: Function.h:184
bool hasLocalLinkage() const
Definition: GlobalValue.h:280
bool isVarArg() const
Definition: DerivedTypes.h:120
Type * getReturnType() const
Definition: DerivedTypes.h:121
Function can return twice.
Definition: Attributes.h:104
unsigned getParamAlignment(unsigned i) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:261
static Type * DecodeFixedType(ArrayRef< Intrinsic::IITDescriptor > &Infos, ArrayRef< Type * > Tys, LLVMContext &Context)
Definition: Function.cpp:744
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
static const char * name
const ArgumentListType & getArgumentList() const
Get the underlying elements of the Function...
Definition: Function.h:424
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
Definition: Function.cpp:62
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
inst_iterator inst_end(Function *F)
Definition: InstIterator.h:128
A single uniqued string.
Definition: Metadata.h:508
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
void addAttributes(unsigned i, AttributeSet attrs)
adds the attributes to the list of attributes.
Definition: Function.cpp:347
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Add attributes to the attribute set at the given index.
Definition: Attributes.cpp:773
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
Definition: Function.cpp:229
NodeTy * remove(iterator &IT)
Definition: ilist.h:435
void setGlobalObjectSubClassData(unsigned Val)
Definition: Globals.cpp:92
bool hasReturnedAttr() const
Return true if this argument has the returned attribute on it in its containing function.
Definition: Function.cpp:163
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:265
bool isVoidTy() const
isVoidTy - Return true if this is 'void'.
Definition: Type.h:137
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:64
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:935