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"
16#include "SymbolTableListTraitsImpl.h"
17#include "llvm/ADT/DenseMap.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/CodeGen/ValueTypes.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"
30#include "llvm/Support/ManagedStatic.h"
31#include "llvm/Support/RWMutex.h"
32#include "llvm/Support/StringPool.h"
33#include "llvm/Support/Threading.h"
34using namespace llvm;
35
36// Explicit instantiations of SymbolTableListTraits since some of the methods
37// are not in the public header file...
38template class llvm::SymbolTableListTraits<Argument>;
39template class llvm::SymbolTableListTraits<BasicBlock>;
40
41//===----------------------------------------------------------------------===//
42// Argument Implementation
43//===----------------------------------------------------------------------===//
44
45void Argument::anchor() { }
46
47Argument::Argument(Type *Ty, const Twine &Name, Function *Par)
48  : Value(Ty, Value::ArgumentVal) {
49  Parent = nullptr;
50
51  if (Par)
52    Par->getArgumentList().push_back(this);
53  setName(Name);
54}
55
56void 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.
62unsigned Argument::getArgNo() const {
63  const Function *F = getParent();
64  assert(F && "Argument is not in a function");
65
66  Function::const_arg_iterator AI = F->arg_begin();
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).
77bool Argument::hasNonNullAttr() const {
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.
90bool 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.
98bool Argument::hasInAllocaAttr() const {
99  if (!getType()->isPointerTy()) return false;
100  return getParent()->getAttributes().
101    hasAttribute(getArgNo()+1, Attribute::InAlloca);
102}
103
104bool Argument::hasByValOrInAllocaAttr() const {
105  if (!getType()->isPointerTy()) return false;
106  AttributeSet Attrs = getParent()->getAttributes();
107  return Attrs.hasAttribute(getArgNo() + 1, Attribute::ByVal) ||
108         Attrs.hasAttribute(getArgNo() + 1, Attribute::InAlloca);
109}
110
111unsigned Argument::getParamAlignment() const {
112  assert(getType()->isPointerTy() && "Only pointers have alignments");
113  return getParent()->getParamAlignment(getArgNo()+1);
114
115}
116
117uint64_t Argument::getDereferenceableBytes() const {
118  assert(getType()->isPointerTy() &&
119         "Only pointers have dereferenceable bytes");
120  return getParent()->getDereferenceableBytes(getArgNo()+1);
121}
122
123uint64_t Argument::getDereferenceableOrNullBytes() const {
124  assert(getType()->isPointerTy() &&
125         "Only pointers have dereferenceable bytes");
126  return getParent()->getDereferenceableOrNullBytes(getArgNo()+1);
127}
128
129/// hasNestAttr - Return true if this argument has the nest attribute on
130/// it in its containing function.
131bool 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.
139bool Argument::hasNoAliasAttr() const {
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.
147bool Argument::hasNoCaptureAttr() const {
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.
155bool Argument::hasStructRetAttr() const {
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.
163bool Argument::hasReturnedAttr() const {
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.
170bool 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.
177bool 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.
184bool Argument::onlyReadsMemory() const {
185  return getParent()->getAttributes().
186      hasAttribute(getArgNo()+1, Attribute::ReadOnly) ||
187      getParent()->getAttributes().
188      hasAttribute(getArgNo()+1, Attribute::ReadNone);
189}
190
191/// addAttr - Add attributes to an argument.
192void Argument::addAttr(AttributeSet AS) {
193  assert(AS.getNumSlots() <= 1 &&
194         "Trying to add more than one attribute set to an argument!");
195  AttrBuilder B(AS, AS.getSlotIndex(0));
196  getParent()->addAttributes(getArgNo() + 1,
197                             AttributeSet::get(Parent->getContext(),
198                                               getArgNo() + 1, B));
199}
200
201/// removeAttr - Remove attributes from an argument.
202void Argument::removeAttr(AttributeSet AS) {
203  assert(AS.getNumSlots() <= 1 &&
204         "Trying to remove more than one attribute set from an argument!");
205  AttrBuilder B(AS, AS.getSlotIndex(0));
206  getParent()->removeAttributes(getArgNo() + 1,
207                                AttributeSet::get(Parent->getContext(),
208                                                  getArgNo() + 1, B));
209}
210
211//===----------------------------------------------------------------------===//
212// Helper Methods in Function
213//===----------------------------------------------------------------------===//
214
215bool Function::isMaterializable() const {
216  return getGlobalObjectSubClassData() & IsMaterializableBit;
217}
218
219void Function::setIsMaterializable(bool V) {
220  setGlobalObjectBit(IsMaterializableBit, V);
221}
222
223LLVMContext &Function::getContext() const {
224  return getType()->getContext();
225}
226
227FunctionType *Function::getFunctionType() const { return Ty; }
228
229bool Function::isVarArg() const {
230  return getFunctionType()->isVarArg();
231}
232
233Type *Function::getReturnType() const {
234  return getFunctionType()->getReturnType();
235}
236
237void Function::removeFromParent() {
238  getParent()->getFunctionList().remove(getIterator());
239}
240
241void Function::eraseFromParent() {
242  getParent()->getFunctionList().erase(getIterator());
243}
244
245//===----------------------------------------------------------------------===//
246// Function Implementation
247//===----------------------------------------------------------------------===//
248
249Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name,
250                   Module *ParentModule)
251    : GlobalObject(Ty, Value::FunctionVal,
252                   OperandTraits<Function>::op_begin(this), 0, Linkage, name),
253      Ty(Ty) {
254  assert(FunctionType::isValidReturnType(getReturnType()) &&
255         "invalid return type");
256  setGlobalObjectSubClassData(0);
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)
270    setAttributes(Intrinsic::getAttributes(getContext(), IntID));
271}
272
273Function::~Function() {
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
284void Function::BuildLazyArguments() const {
285  // Create the arguments vector, all arguments start out unnamed.
286  FunctionType *FT = getFunctionType();
287  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
288    assert(!FT->getParamType(i)->isVoidTy() &&
289           "Cannot have void typed arguments!");
290    ArgumentList.push_back(new Argument(FT->getParamType(i)));
291  }
292
293  // Clear the lazy arguments bit.
294  unsigned SDC = getSubclassDataFromValue();
295  const_cast<Function*>(this)->setValueSubclassData(SDC &= ~(1<<0));
296}
297
298size_t Function::arg_size() const {
299  return getFunctionType()->getNumParams();
300}
301bool Function::arg_empty() const {
302  return getFunctionType()->getNumParams() == 0;
303}
304
305void Function::setParent(Module *parent) {
306  Parent = parent;
307}
308
309// dropAllReferences() - This function causes all the subinstructions to "let
310// go" of all references that they are maintaining.  This allows one to
311// 'delete' a whole class at a time, even though there may be circular
312// references... first all references are dropped, and all use counts go to
313// zero.  Then everything is deleted for real.  Note that no operations are
314// valid on an object that has "dropped all references", except operator
315// delete.
316//
317void Function::dropAllReferences() {
318  setIsMaterializable(false);
319
320  for (iterator I = begin(), E = end(); I != E; ++I)
321    I->dropAllReferences();
322
323  // Delete all basic blocks. They are now unused, except possibly by
324  // blockaddresses, but BasicBlock's destructor takes care of those.
325  while (!BasicBlocks.empty())
326    BasicBlocks.begin()->eraseFromParent();
327
328  // Drop uses of any optional data (real or placeholder).
329  if (getNumOperands()) {
330    User::dropAllReferences();
331    setNumHungOffUseOperands(0);
332    setValueSubclassData(getSubclassDataFromValue() & ~0xe);
333  }
334
335  // Metadata is stored in a side-table.
336  clearMetadata();
337}
338
339void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
340  AttributeSet PAL = getAttributes();
341  PAL = PAL.addAttribute(getContext(), i, attr);
342  setAttributes(PAL);
343}
344
345void Function::addAttributes(unsigned i, AttributeSet attrs) {
346  AttributeSet PAL = getAttributes();
347  PAL = PAL.addAttributes(getContext(), i, attrs);
348  setAttributes(PAL);
349}
350
351void Function::removeAttributes(unsigned i, AttributeSet attrs) {
352  AttributeSet PAL = getAttributes();
353  PAL = PAL.removeAttributes(getContext(), i, attrs);
354  setAttributes(PAL);
355}
356
357void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
358  AttributeSet PAL = getAttributes();
359  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
360  setAttributes(PAL);
361}
362
363void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
364  AttributeSet PAL = getAttributes();
365  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
366  setAttributes(PAL);
367}
368
369const std::string &Function::getGC() const {
370  assert(hasGC() && "Function has no collector");
371  return getContext().getGC(*this);
372}
373
374void Function::setGC(const std::string Str) {
375  setValueSubclassDataBit(14, !Str.empty());
376  getContext().setGC(*this, std::move(Str));
377}
378
379void Function::clearGC() {
380  if (!hasGC())
381    return;
382  getContext().deleteGC(*this);
383  setValueSubclassDataBit(14, false);
384}
385
386/// Copy all additional attributes (those not needed to create a Function) from
387/// the Function Src to this one.
388void Function::copyAttributesFrom(const GlobalValue *Src) {
389  GlobalObject::copyAttributesFrom(Src);
390  const Function *SrcF = dyn_cast<Function>(Src);
391  if (!SrcF)
392    return;
393
394  setCallingConv(SrcF->getCallingConv());
395  setAttributes(SrcF->getAttributes());
396  if (SrcF->hasGC())
397    setGC(SrcF->getGC());
398  else
399    clearGC();
400  if (SrcF->hasPersonalityFn())
401    setPersonalityFn(SrcF->getPersonalityFn());
402  if (SrcF->hasPrefixData())
403    setPrefixData(SrcF->getPrefixData());
404  if (SrcF->hasPrologueData())
405    setPrologueData(SrcF->getPrologueData());
406}
407
408/// \brief This does the actual lookup of an intrinsic ID which
409/// matches the given function name.
410static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
411  unsigned Len = ValName->getKeyLength();
412  const char *Name = ValName->getKeyData();
413
414#define GET_FUNCTION_RECOGNIZER
415#include "llvm/IR/Intrinsics.gen"
416#undef GET_FUNCTION_RECOGNIZER
417
418  return Intrinsic::not_intrinsic;
419}
420
421void Function::recalculateIntrinsicID() {
422  const ValueName *ValName = this->getValueName();
423  if (!ValName || !isIntrinsic()) {
424    IntID = Intrinsic::not_intrinsic;
425    return;
426  }
427  IntID = lookupIntrinsicID(ValName);
428}
429
430/// Returns a stable mangling for the type specified for use in the name
431/// mangling scheme used by 'any' types in intrinsic signatures.  The mangling
432/// of named types is simply their name.  Manglings for unnamed types consist
433/// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
434/// combined with the mangling of their component types.  A vararg function
435/// type will have a suffix of 'vararg'.  Since function types can contain
436/// other function types, we close a function type mangling with suffix 'f'
437/// which can't be confused with it's prefix.  This ensures we don't have
438/// collisions between two unrelated function types. Otherwise, you might
439/// parse ffXX as f(fXX) or f(fX)X.  (X is a placeholder for any other type.)
440/// Manglings of integers, floats, and vectors ('i', 'f', and 'v' prefix in most
441/// cases) fall back to the MVT codepath, where they could be mangled to
442/// 'x86mmx', for example; matching on derived types is not sufficient to mangle
443/// everything.
444static std::string getMangledTypeStr(Type* Ty) {
445  std::string Result;
446  if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
447    Result += "p" + llvm::utostr(PTyp->getAddressSpace()) +
448      getMangledTypeStr(PTyp->getElementType());
449  } else if (ArrayType* ATyp = dyn_cast<ArrayType>(Ty)) {
450    Result += "a" + llvm::utostr(ATyp->getNumElements()) +
451      getMangledTypeStr(ATyp->getElementType());
452  } else if (StructType* STyp = dyn_cast<StructType>(Ty)) {
453    assert(!STyp->isLiteral() && "TODO: implement literal types");
454    Result += STyp->getName();
455  } else if (FunctionType* FT = dyn_cast<FunctionType>(Ty)) {
456    Result += "f_" + getMangledTypeStr(FT->getReturnType());
457    for (size_t i = 0; i < FT->getNumParams(); i++)
458      Result += getMangledTypeStr(FT->getParamType(i));
459    if (FT->isVarArg())
460      Result += "vararg";
461    // Ensure nested function types are distinguishable.
462    Result += "f";
463  } else if (isa<VectorType>(Ty))
464    Result += "v" + utostr(Ty->getVectorNumElements()) +
465      getMangledTypeStr(Ty->getVectorElementType());
466  else if (Ty)
467    Result += EVT::getEVT(Ty).getEVTString();
468  return Result;
469}
470
471std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
472  assert(id < num_intrinsics && "Invalid intrinsic ID!");
473  static const char * const Table[] = {
474    "not_intrinsic",
475#define GET_INTRINSIC_NAME_TABLE
476#include "llvm/IR/Intrinsics.gen"
477#undef GET_INTRINSIC_NAME_TABLE
478  };
479  if (Tys.empty())
480    return Table[id];
481  std::string Result(Table[id]);
482  for (unsigned i = 0; i < Tys.size(); ++i) {
483    Result += "." + getMangledTypeStr(Tys[i]);
484  }
485  return Result;
486}
487
488
489/// IIT_Info - These are enumerators that describe the entries returned by the
490/// getIntrinsicInfoTableEntries function.
491///
492/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
493enum IIT_Info {
494  // Common values should be encoded with 0-15.
495  IIT_Done = 0,
496  IIT_I1   = 1,
497  IIT_I8   = 2,
498  IIT_I16  = 3,
499  IIT_I32  = 4,
500  IIT_I64  = 5,
501  IIT_F16  = 6,
502  IIT_F32  = 7,
503  IIT_F64  = 8,
504  IIT_V2   = 9,
505  IIT_V4   = 10,
506  IIT_V8   = 11,
507  IIT_V16  = 12,
508  IIT_V32  = 13,
509  IIT_PTR  = 14,
510  IIT_ARG  = 15,
511
512  // Values from 16+ are only encodable with the inefficient encoding.
513  IIT_V64  = 16,
514  IIT_MMX  = 17,
515  IIT_TOKEN = 18,
516  IIT_METADATA = 19,
517  IIT_EMPTYSTRUCT = 20,
518  IIT_STRUCT2 = 21,
519  IIT_STRUCT3 = 22,
520  IIT_STRUCT4 = 23,
521  IIT_STRUCT5 = 24,
522  IIT_EXTEND_ARG = 25,
523  IIT_TRUNC_ARG = 26,
524  IIT_ANYPTR = 27,
525  IIT_V1   = 28,
526  IIT_VARARG = 29,
527  IIT_HALF_VEC_ARG = 30,
528  IIT_SAME_VEC_WIDTH_ARG = 31,
529  IIT_PTR_TO_ARG = 32,
530  IIT_VEC_OF_PTRS_TO_ELT = 33,
531  IIT_I128 = 34,
532  IIT_V512 = 35,
533  IIT_V1024 = 36
534};
535
536
537static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
538                      SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
539  IIT_Info Info = IIT_Info(Infos[NextElt++]);
540  unsigned StructElts = 2;
541  using namespace Intrinsic;
542
543  switch (Info) {
544  case IIT_Done:
545    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
546    return;
547  case IIT_VARARG:
548    OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
549    return;
550  case IIT_MMX:
551    OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
552    return;
553  case IIT_TOKEN:
554    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
555    return;
556  case IIT_METADATA:
557    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
558    return;
559  case IIT_F16:
560    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
561    return;
562  case IIT_F32:
563    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0));
564    return;
565  case IIT_F64:
566    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0));
567    return;
568  case IIT_I1:
569    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1));
570    return;
571  case IIT_I8:
572    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8));
573    return;
574  case IIT_I16:
575    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16));
576    return;
577  case IIT_I32:
578    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32));
579    return;
580  case IIT_I64:
581    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64));
582    return;
583  case IIT_I128:
584    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 128));
585    return;
586  case IIT_V1:
587    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1));
588    DecodeIITType(NextElt, Infos, OutputTable);
589    return;
590  case IIT_V2:
591    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2));
592    DecodeIITType(NextElt, Infos, OutputTable);
593    return;
594  case IIT_V4:
595    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4));
596    DecodeIITType(NextElt, Infos, OutputTable);
597    return;
598  case IIT_V8:
599    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8));
600    DecodeIITType(NextElt, Infos, OutputTable);
601    return;
602  case IIT_V16:
603    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16));
604    DecodeIITType(NextElt, Infos, OutputTable);
605    return;
606  case IIT_V32:
607    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32));
608    DecodeIITType(NextElt, Infos, OutputTable);
609    return;
610  case IIT_V64:
611    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 64));
612    DecodeIITType(NextElt, Infos, OutputTable);
613    return;
614  case IIT_V512:
615    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 512));
616    DecodeIITType(NextElt, Infos, OutputTable);
617    return;
618  case IIT_V1024:
619    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1024));
620    DecodeIITType(NextElt, Infos, OutputTable);
621    return;
622  case IIT_PTR:
623    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0));
624    DecodeIITType(NextElt, Infos, OutputTable);
625    return;
626  case IIT_ANYPTR: {  // [ANYPTR addrspace, subtype]
627    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer,
628                                             Infos[NextElt++]));
629    DecodeIITType(NextElt, Infos, OutputTable);
630    return;
631  }
632  case IIT_ARG: {
633    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
634    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo));
635    return;
636  }
637  case IIT_EXTEND_ARG: {
638    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
639    OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendArgument,
640                                             ArgInfo));
641    return;
642  }
643  case IIT_TRUNC_ARG: {
644    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
645    OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncArgument,
646                                             ArgInfo));
647    return;
648  }
649  case IIT_HALF_VEC_ARG: {
650    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
651    OutputTable.push_back(IITDescriptor::get(IITDescriptor::HalfVecArgument,
652                                             ArgInfo));
653    return;
654  }
655  case IIT_SAME_VEC_WIDTH_ARG: {
656    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
657    OutputTable.push_back(IITDescriptor::get(IITDescriptor::SameVecWidthArgument,
658                                             ArgInfo));
659    return;
660  }
661  case IIT_PTR_TO_ARG: {
662    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
663    OutputTable.push_back(IITDescriptor::get(IITDescriptor::PtrToArgument,
664                                             ArgInfo));
665    return;
666  }
667  case IIT_VEC_OF_PTRS_TO_ELT: {
668    unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
669    OutputTable.push_back(IITDescriptor::get(IITDescriptor::VecOfPtrsToElt,
670                                             ArgInfo));
671    return;
672  }
673  case IIT_EMPTYSTRUCT:
674    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
675    return;
676  case IIT_STRUCT5: ++StructElts; // FALL THROUGH.
677  case IIT_STRUCT4: ++StructElts; // FALL THROUGH.
678  case IIT_STRUCT3: ++StructElts; // FALL THROUGH.
679  case IIT_STRUCT2: {
680    OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
681
682    for (unsigned i = 0; i != StructElts; ++i)
683      DecodeIITType(NextElt, Infos, OutputTable);
684    return;
685  }
686  }
687  llvm_unreachable("unhandled");
688}
689
690
691#define GET_INTRINSIC_GENERATOR_GLOBAL
692#include "llvm/IR/Intrinsics.gen"
693#undef GET_INTRINSIC_GENERATOR_GLOBAL
694
695void Intrinsic::getIntrinsicInfoTableEntries(ID id,
696                                             SmallVectorImpl<IITDescriptor> &T){
697  // Check to see if the intrinsic's type was expressible by the table.
698  unsigned TableVal = IIT_Table[id-1];
699
700  // Decode the TableVal into an array of IITValues.
701  SmallVector<unsigned char, 8> IITValues;
702  ArrayRef<unsigned char> IITEntries;
703  unsigned NextElt = 0;
704  if ((TableVal >> 31) != 0) {
705    // This is an offset into the IIT_LongEncodingTable.
706    IITEntries = IIT_LongEncodingTable;
707
708    // Strip sentinel bit.
709    NextElt = (TableVal << 1) >> 1;
710  } else {
711    // Decode the TableVal into an array of IITValues.  If the entry was encoded
712    // into a single word in the table itself, decode it now.
713    do {
714      IITValues.push_back(TableVal & 0xF);
715      TableVal >>= 4;
716    } while (TableVal);
717
718    IITEntries = IITValues;
719    NextElt = 0;
720  }
721
722  // Okay, decode the table into the output vector of IITDescriptors.
723  DecodeIITType(NextElt, IITEntries, T);
724  while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
725    DecodeIITType(NextElt, IITEntries, T);
726}
727
728
729static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
730                             ArrayRef<Type*> Tys, LLVMContext &Context) {
731  using namespace Intrinsic;
732  IITDescriptor D = Infos.front();
733  Infos = Infos.slice(1);
734
735  switch (D.Kind) {
736  case IITDescriptor::Void: return Type::getVoidTy(Context);
737  case IITDescriptor::VarArg: return Type::getVoidTy(Context);
738  case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
739  case IITDescriptor::Token: return Type::getTokenTy(Context);
740  case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
741  case IITDescriptor::Half: return Type::getHalfTy(Context);
742  case IITDescriptor::Float: return Type::getFloatTy(Context);
743  case IITDescriptor::Double: return Type::getDoubleTy(Context);
744
745  case IITDescriptor::Integer:
746    return IntegerType::get(Context, D.Integer_Width);
747  case IITDescriptor::Vector:
748    return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width);
749  case IITDescriptor::Pointer:
750    return PointerType::get(DecodeFixedType(Infos, Tys, Context),
751                            D.Pointer_AddressSpace);
752  case IITDescriptor::Struct: {
753    Type *Elts[5];
754    assert(D.Struct_NumElements <= 5 && "Can't handle this yet");
755    for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
756      Elts[i] = DecodeFixedType(Infos, Tys, Context);
757    return StructType::get(Context, makeArrayRef(Elts,D.Struct_NumElements));
758  }
759
760  case IITDescriptor::Argument:
761    return Tys[D.getArgumentNumber()];
762  case IITDescriptor::ExtendArgument: {
763    Type *Ty = Tys[D.getArgumentNumber()];
764    if (VectorType *VTy = dyn_cast<VectorType>(Ty))
765      return VectorType::getExtendedElementVectorType(VTy);
766
767    return IntegerType::get(Context, 2 * cast<IntegerType>(Ty)->getBitWidth());
768  }
769  case IITDescriptor::TruncArgument: {
770    Type *Ty = Tys[D.getArgumentNumber()];
771    if (VectorType *VTy = dyn_cast<VectorType>(Ty))
772      return VectorType::getTruncatedElementVectorType(VTy);
773
774    IntegerType *ITy = cast<IntegerType>(Ty);
775    assert(ITy->getBitWidth() % 2 == 0);
776    return IntegerType::get(Context, ITy->getBitWidth() / 2);
777  }
778  case IITDescriptor::HalfVecArgument:
779    return VectorType::getHalfElementsVectorType(cast<VectorType>(
780                                                  Tys[D.getArgumentNumber()]));
781  case IITDescriptor::SameVecWidthArgument: {
782    Type *EltTy = DecodeFixedType(Infos, Tys, Context);
783    Type *Ty = Tys[D.getArgumentNumber()];
784    if (VectorType *VTy = dyn_cast<VectorType>(Ty)) {
785      return VectorType::get(EltTy, VTy->getNumElements());
786    }
787    llvm_unreachable("unhandled");
788  }
789  case IITDescriptor::PtrToArgument: {
790    Type *Ty = Tys[D.getArgumentNumber()];
791    return PointerType::getUnqual(Ty);
792  }
793  case IITDescriptor::VecOfPtrsToElt: {
794    Type *Ty = Tys[D.getArgumentNumber()];
795    VectorType *VTy = dyn_cast<VectorType>(Ty);
796    if (!VTy)
797      llvm_unreachable("Expected an argument of Vector Type");
798    Type *EltTy = VTy->getVectorElementType();
799    return VectorType::get(PointerType::getUnqual(EltTy),
800                           VTy->getNumElements());
801  }
802 }
803  llvm_unreachable("unhandled");
804}
805
806
807
808FunctionType *Intrinsic::getType(LLVMContext &Context,
809                                 ID id, ArrayRef<Type*> Tys) {
810  SmallVector<IITDescriptor, 8> Table;
811  getIntrinsicInfoTableEntries(id, Table);
812
813  ArrayRef<IITDescriptor> TableRef = Table;
814  Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
815
816  SmallVector<Type*, 8> ArgTys;
817  while (!TableRef.empty())
818    ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
819
820  // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
821  // If we see void type as the type of the last argument, it is vararg intrinsic
822  if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
823    ArgTys.pop_back();
824    return FunctionType::get(ResultTy, ArgTys, true);
825  }
826  return FunctionType::get(ResultTy, ArgTys, false);
827}
828
829bool Intrinsic::isOverloaded(ID id) {
830#define GET_INTRINSIC_OVERLOAD_TABLE
831#include "llvm/IR/Intrinsics.gen"
832#undef GET_INTRINSIC_OVERLOAD_TABLE
833}
834
835bool Intrinsic::isLeaf(ID id) {
836  switch (id) {
837  default:
838    return true;
839
840  case Intrinsic::experimental_gc_statepoint:
841  case Intrinsic::experimental_patchpoint_void:
842  case Intrinsic::experimental_patchpoint_i64:
843    return false;
844  }
845}
846
847/// This defines the "Intrinsic::getAttributes(ID id)" method.
848#define GET_INTRINSIC_ATTRIBUTES
849#include "llvm/IR/Intrinsics.gen"
850#undef GET_INTRINSIC_ATTRIBUTES
851
852Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
853  // There can never be multiple globals with the same name of different types,
854  // because intrinsics must be a specific type.
855  return
856    cast<Function>(M->getOrInsertFunction(getName(id, Tys),
857                                          getType(M->getContext(), id, Tys)));
858}
859
860// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
861#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
862#include "llvm/IR/Intrinsics.gen"
863#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
864
865// This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
866#define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
867#include "llvm/IR/Intrinsics.gen"
868#undef GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
869
870/// hasAddressTaken - returns true if there are any uses of this function
871/// other than direct calls or invokes to it.
872bool Function::hasAddressTaken(const User* *PutOffender) const {
873  for (const Use &U : uses()) {
874    const User *FU = U.getUser();
875    if (isa<BlockAddress>(FU))
876      continue;
877    if (!isa<CallInst>(FU) && !isa<InvokeInst>(FU))
878      return PutOffender ? (*PutOffender = FU, true) : true;
879    ImmutableCallSite CS(cast<Instruction>(FU));
880    if (!CS.isCallee(&U))
881      return PutOffender ? (*PutOffender = FU, true) : true;
882  }
883  return false;
884}
885
886bool Function::isDefTriviallyDead() const {
887  // Check the linkage
888  if (!hasLinkOnceLinkage() && !hasLocalLinkage() &&
889      !hasAvailableExternallyLinkage())
890    return false;
891
892  // Check if the function is used by anything other than a blockaddress.
893  for (const User *U : users())
894    if (!isa<BlockAddress>(U))
895      return false;
896
897  return true;
898}
899
900/// callsFunctionThatReturnsTwice - Return true if the function has a call to
901/// setjmp or other function that gcc recognizes as "returning twice".
902bool Function::callsFunctionThatReturnsTwice() const {
903  for (const_inst_iterator
904         I = inst_begin(this), E = inst_end(this); I != E; ++I) {
905    ImmutableCallSite CS(&*I);
906    if (CS && CS.hasFnAttr(Attribute::ReturnsTwice))
907      return true;
908  }
909
910  return false;
911}
912
913Constant *Function::getPersonalityFn() const {
914  assert(hasPersonalityFn() && getNumOperands());
915  return cast<Constant>(Op<0>());
916}
917
918void Function::setPersonalityFn(Constant *Fn) {
919  setHungoffOperand<0>(Fn);
920  setValueSubclassDataBit(3, Fn != nullptr);
921}
922
923Constant *Function::getPrefixData() const {
924  assert(hasPrefixData() && getNumOperands());
925  return cast<Constant>(Op<1>());
926}
927
928void Function::setPrefixData(Constant *PrefixData) {
929  setHungoffOperand<1>(PrefixData);
930  setValueSubclassDataBit(1, PrefixData != nullptr);
931}
932
933Constant *Function::getPrologueData() const {
934  assert(hasPrologueData() && getNumOperands());
935  return cast<Constant>(Op<2>());
936}
937
938void Function::setPrologueData(Constant *PrologueData) {
939  setHungoffOperand<2>(PrologueData);
940  setValueSubclassDataBit(2, PrologueData != nullptr);
941}
942
943void Function::allocHungoffUselist() {
944  // If we've already allocated a uselist, stop here.
945  if (getNumOperands())
946    return;
947
948  allocHungoffUses(3, /*IsPhi=*/ false);
949  setNumHungOffUseOperands(3);
950
951  // Initialize the uselist with placeholder operands to allow traversal.
952  auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0));
953  Op<0>().set(CPN);
954  Op<1>().set(CPN);
955  Op<2>().set(CPN);
956}
957
958template <int Idx>
959void Function::setHungoffOperand(Constant *C) {
960  if (C) {
961    allocHungoffUselist();
962    Op<Idx>().set(C);
963  } else if (getNumOperands()) {
964    Op<Idx>().set(
965        ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)));
966  }
967}
968
969void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
970  assert(Bit < 16 && "SubclassData contains only 16 bits");
971  if (On)
972    setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
973  else
974    setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
975}
976
977void Function::setEntryCount(uint64_t Count) {
978  MDBuilder MDB(getContext());
979  setMetadata(LLVMContext::MD_prof, MDB.createFunctionEntryCount(Count));
980}
981
982Optional<uint64_t> Function::getEntryCount() const {
983  MDNode *MD = getMetadata(LLVMContext::MD_prof);
984  if (MD && MD->getOperand(0))
985    if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
986      if (MDS->getString().equals("function_entry_count")) {
987        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
988        return CI->getValue().getZExtValue();
989      }
990  return None;
991}
992