1249259Sdim//===-- Function.cpp - Implement the Global object classes ----------------===// 2249259Sdim// 3249259Sdim// The LLVM Compiler Infrastructure 4249259Sdim// 5249259Sdim// This file is distributed under the University of Illinois Open Source 6249259Sdim// License. See LICENSE.TXT for details. 7249259Sdim// 8249259Sdim//===----------------------------------------------------------------------===// 9249259Sdim// 10249259Sdim// This file implements the Function class for the IR library. 11249259Sdim// 12249259Sdim//===----------------------------------------------------------------------===// 13249259Sdim 14249259Sdim#include "llvm/IR/Function.h" 15249259Sdim#include "LLVMContextImpl.h" 16249259Sdim#include "SymbolTableListTraitsImpl.h" 17249259Sdim#include "llvm/ADT/DenseMap.h" 18249259Sdim#include "llvm/ADT/STLExtras.h" 19249259Sdim#include "llvm/ADT/StringExtras.h" 20249259Sdim#include "llvm/CodeGen/ValueTypes.h" 21249259Sdim#include "llvm/IR/DerivedTypes.h" 22249259Sdim#include "llvm/IR/IntrinsicInst.h" 23249259Sdim#include "llvm/IR/LLVMContext.h" 24249259Sdim#include "llvm/IR/Module.h" 25249259Sdim#include "llvm/Support/CallSite.h" 26249259Sdim#include "llvm/Support/InstIterator.h" 27249259Sdim#include "llvm/Support/LeakDetector.h" 28249259Sdim#include "llvm/Support/ManagedStatic.h" 29249259Sdim#include "llvm/Support/RWMutex.h" 30249259Sdim#include "llvm/Support/StringPool.h" 31249259Sdim#include "llvm/Support/Threading.h" 32249259Sdimusing namespace llvm; 33249259Sdim 34249259Sdim// Explicit instantiations of SymbolTableListTraits since some of the methods 35249259Sdim// are not in the public header file... 36249259Sdimtemplate class llvm::SymbolTableListTraits<Argument, Function>; 37249259Sdimtemplate class llvm::SymbolTableListTraits<BasicBlock, Function>; 38249259Sdim 39249259Sdim//===----------------------------------------------------------------------===// 40249259Sdim// Argument Implementation 41249259Sdim//===----------------------------------------------------------------------===// 42249259Sdim 43249259Sdimvoid Argument::anchor() { } 44249259Sdim 45249259SdimArgument::Argument(Type *Ty, const Twine &Name, Function *Par) 46249259Sdim : Value(Ty, Value::ArgumentVal) { 47249259Sdim Parent = 0; 48249259Sdim 49249259Sdim // Make sure that we get added to a function 50249259Sdim LeakDetector::addGarbageObject(this); 51249259Sdim 52249259Sdim if (Par) 53249259Sdim Par->getArgumentList().push_back(this); 54249259Sdim setName(Name); 55249259Sdim} 56249259Sdim 57249259Sdimvoid Argument::setParent(Function *parent) { 58249259Sdim if (getParent()) 59249259Sdim LeakDetector::addGarbageObject(this); 60249259Sdim Parent = parent; 61249259Sdim if (getParent()) 62249259Sdim LeakDetector::removeGarbageObject(this); 63249259Sdim} 64249259Sdim 65249259Sdim/// getArgNo - Return the index of this formal argument in its containing 66249259Sdim/// function. For example in "void foo(int a, float b)" a is 0 and b is 1. 67249259Sdimunsigned Argument::getArgNo() const { 68249259Sdim const Function *F = getParent(); 69249259Sdim assert(F && "Argument is not in a function"); 70249259Sdim 71249259Sdim Function::const_arg_iterator AI = F->arg_begin(); 72249259Sdim unsigned ArgIdx = 0; 73249259Sdim for (; &*AI != this; ++AI) 74249259Sdim ++ArgIdx; 75249259Sdim 76249259Sdim return ArgIdx; 77249259Sdim} 78249259Sdim 79249259Sdim/// hasByValAttr - Return true if this argument has the byval attribute on it 80249259Sdim/// in its containing function. 81249259Sdimbool Argument::hasByValAttr() const { 82249259Sdim if (!getType()->isPointerTy()) return false; 83249259Sdim return getParent()->getAttributes(). 84249259Sdim hasAttribute(getArgNo()+1, Attribute::ByVal); 85249259Sdim} 86249259Sdim 87249259Sdimunsigned Argument::getParamAlignment() const { 88249259Sdim assert(getType()->isPointerTy() && "Only pointers have alignments"); 89249259Sdim return getParent()->getParamAlignment(getArgNo()+1); 90249259Sdim 91249259Sdim} 92249259Sdim 93249259Sdim/// hasNestAttr - Return true if this argument has the nest attribute on 94249259Sdim/// it in its containing function. 95249259Sdimbool Argument::hasNestAttr() const { 96249259Sdim if (!getType()->isPointerTy()) return false; 97249259Sdim return getParent()->getAttributes(). 98249259Sdim hasAttribute(getArgNo()+1, Attribute::Nest); 99249259Sdim} 100249259Sdim 101249259Sdim/// hasNoAliasAttr - Return true if this argument has the noalias attribute on 102249259Sdim/// it in its containing function. 103249259Sdimbool Argument::hasNoAliasAttr() const { 104249259Sdim if (!getType()->isPointerTy()) return false; 105249259Sdim return getParent()->getAttributes(). 106249259Sdim hasAttribute(getArgNo()+1, Attribute::NoAlias); 107249259Sdim} 108249259Sdim 109249259Sdim/// hasNoCaptureAttr - Return true if this argument has the nocapture attribute 110249259Sdim/// on it in its containing function. 111249259Sdimbool Argument::hasNoCaptureAttr() const { 112249259Sdim if (!getType()->isPointerTy()) return false; 113249259Sdim return getParent()->getAttributes(). 114249259Sdim hasAttribute(getArgNo()+1, Attribute::NoCapture); 115249259Sdim} 116249259Sdim 117249259Sdim/// hasSRetAttr - Return true if this argument has the sret attribute on 118249259Sdim/// it in its containing function. 119249259Sdimbool Argument::hasStructRetAttr() const { 120249259Sdim if (!getType()->isPointerTy()) return false; 121249259Sdim if (this != getParent()->arg_begin()) 122249259Sdim return false; // StructRet param must be first param 123249259Sdim return getParent()->getAttributes(). 124249259Sdim hasAttribute(1, Attribute::StructRet); 125249259Sdim} 126249259Sdim 127251662Sdim/// hasReturnedAttr - Return true if this argument has the returned attribute on 128251662Sdim/// it in its containing function. 129251662Sdimbool Argument::hasReturnedAttr() const { 130251662Sdim return getParent()->getAttributes(). 131251662Sdim hasAttribute(getArgNo()+1, Attribute::Returned); 132251662Sdim} 133251662Sdim 134263508Sdim/// Return true if this argument has the readonly or readnone attribute on it 135263508Sdim/// in its containing function. 136263508Sdimbool Argument::onlyReadsMemory() const { 137263508Sdim return getParent()->getAttributes(). 138263508Sdim hasAttribute(getArgNo()+1, Attribute::ReadOnly) || 139263508Sdim getParent()->getAttributes(). 140263508Sdim hasAttribute(getArgNo()+1, Attribute::ReadNone); 141263508Sdim} 142263508Sdim 143249259Sdim/// addAttr - Add attributes to an argument. 144249259Sdimvoid Argument::addAttr(AttributeSet AS) { 145249259Sdim assert(AS.getNumSlots() <= 1 && 146249259Sdim "Trying to add more than one attribute set to an argument!"); 147249259Sdim AttrBuilder B(AS, AS.getSlotIndex(0)); 148249259Sdim getParent()->addAttributes(getArgNo() + 1, 149249259Sdim AttributeSet::get(Parent->getContext(), 150249259Sdim getArgNo() + 1, B)); 151249259Sdim} 152249259Sdim 153249259Sdim/// removeAttr - Remove attributes from an argument. 154249259Sdimvoid Argument::removeAttr(AttributeSet AS) { 155249259Sdim assert(AS.getNumSlots() <= 1 && 156249259Sdim "Trying to remove more than one attribute set from an argument!"); 157249259Sdim AttrBuilder B(AS, AS.getSlotIndex(0)); 158249259Sdim getParent()->removeAttributes(getArgNo() + 1, 159249259Sdim AttributeSet::get(Parent->getContext(), 160249259Sdim getArgNo() + 1, B)); 161249259Sdim} 162249259Sdim 163249259Sdim//===----------------------------------------------------------------------===// 164249259Sdim// Helper Methods in Function 165249259Sdim//===----------------------------------------------------------------------===// 166249259Sdim 167249259SdimLLVMContext &Function::getContext() const { 168249259Sdim return getType()->getContext(); 169249259Sdim} 170249259Sdim 171249259SdimFunctionType *Function::getFunctionType() const { 172249259Sdim return cast<FunctionType>(getType()->getElementType()); 173249259Sdim} 174249259Sdim 175249259Sdimbool Function::isVarArg() const { 176249259Sdim return getFunctionType()->isVarArg(); 177249259Sdim} 178249259Sdim 179249259SdimType *Function::getReturnType() const { 180249259Sdim return getFunctionType()->getReturnType(); 181249259Sdim} 182249259Sdim 183249259Sdimvoid Function::removeFromParent() { 184249259Sdim getParent()->getFunctionList().remove(this); 185249259Sdim} 186249259Sdim 187249259Sdimvoid Function::eraseFromParent() { 188249259Sdim getParent()->getFunctionList().erase(this); 189249259Sdim} 190249259Sdim 191249259Sdim//===----------------------------------------------------------------------===// 192249259Sdim// Function Implementation 193249259Sdim//===----------------------------------------------------------------------===// 194249259Sdim 195249259SdimFunction::Function(FunctionType *Ty, LinkageTypes Linkage, 196249259Sdim const Twine &name, Module *ParentModule) 197249259Sdim : GlobalValue(PointerType::getUnqual(Ty), 198249259Sdim Value::FunctionVal, 0, 0, Linkage, name) { 199249259Sdim assert(FunctionType::isValidReturnType(getReturnType()) && 200249259Sdim "invalid return type"); 201249259Sdim SymTab = new ValueSymbolTable(); 202249259Sdim 203249259Sdim // If the function has arguments, mark them as lazily built. 204249259Sdim if (Ty->getNumParams()) 205249259Sdim setValueSubclassData(1); // Set the "has lazy arguments" bit. 206249259Sdim 207249259Sdim // Make sure that we get added to a function 208249259Sdim LeakDetector::addGarbageObject(this); 209249259Sdim 210249259Sdim if (ParentModule) 211249259Sdim ParentModule->getFunctionList().push_back(this); 212249259Sdim 213249259Sdim // Ensure intrinsics have the right parameter attributes. 214249259Sdim if (unsigned IID = getIntrinsicID()) 215249259Sdim setAttributes(Intrinsic::getAttributes(getContext(), Intrinsic::ID(IID))); 216249259Sdim 217249259Sdim} 218249259Sdim 219249259SdimFunction::~Function() { 220249259Sdim dropAllReferences(); // After this it is safe to delete instructions. 221249259Sdim 222249259Sdim // Delete all of the method arguments and unlink from symbol table... 223249259Sdim ArgumentList.clear(); 224249259Sdim delete SymTab; 225249259Sdim 226249259Sdim // Remove the function from the on-the-side GC table. 227249259Sdim clearGC(); 228249259Sdim 229249259Sdim // Remove the intrinsicID from the Cache. 230249259Sdim if (getValueName() && isIntrinsic()) 231249259Sdim getContext().pImpl->IntrinsicIDCache.erase(this); 232249259Sdim} 233249259Sdim 234249259Sdimvoid Function::BuildLazyArguments() const { 235249259Sdim // Create the arguments vector, all arguments start out unnamed. 236249259Sdim FunctionType *FT = getFunctionType(); 237249259Sdim for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 238249259Sdim assert(!FT->getParamType(i)->isVoidTy() && 239249259Sdim "Cannot have void typed arguments!"); 240249259Sdim ArgumentList.push_back(new Argument(FT->getParamType(i))); 241249259Sdim } 242249259Sdim 243249259Sdim // Clear the lazy arguments bit. 244249259Sdim unsigned SDC = getSubclassDataFromValue(); 245249259Sdim const_cast<Function*>(this)->setValueSubclassData(SDC &= ~1); 246249259Sdim} 247249259Sdim 248249259Sdimsize_t Function::arg_size() const { 249249259Sdim return getFunctionType()->getNumParams(); 250249259Sdim} 251249259Sdimbool Function::arg_empty() const { 252249259Sdim return getFunctionType()->getNumParams() == 0; 253249259Sdim} 254249259Sdim 255249259Sdimvoid Function::setParent(Module *parent) { 256249259Sdim if (getParent()) 257249259Sdim LeakDetector::addGarbageObject(this); 258249259Sdim Parent = parent; 259249259Sdim if (getParent()) 260249259Sdim LeakDetector::removeGarbageObject(this); 261249259Sdim} 262249259Sdim 263249259Sdim// dropAllReferences() - This function causes all the subinstructions to "let 264249259Sdim// go" of all references that they are maintaining. This allows one to 265249259Sdim// 'delete' a whole class at a time, even though there may be circular 266249259Sdim// references... first all references are dropped, and all use counts go to 267249259Sdim// zero. Then everything is deleted for real. Note that no operations are 268249259Sdim// valid on an object that has "dropped all references", except operator 269249259Sdim// delete. 270249259Sdim// 271249259Sdimvoid Function::dropAllReferences() { 272249259Sdim for (iterator I = begin(), E = end(); I != E; ++I) 273249259Sdim I->dropAllReferences(); 274249259Sdim 275249259Sdim // Delete all basic blocks. They are now unused, except possibly by 276249259Sdim // blockaddresses, but BasicBlock's destructor takes care of those. 277249259Sdim while (!BasicBlocks.empty()) 278249259Sdim BasicBlocks.begin()->eraseFromParent(); 279263508Sdim 280263508Sdim // Prefix data is stored in a side table. 281263508Sdim setPrefixData(0); 282249259Sdim} 283249259Sdim 284249259Sdimvoid Function::addAttribute(unsigned i, Attribute::AttrKind attr) { 285249259Sdim AttributeSet PAL = getAttributes(); 286249259Sdim PAL = PAL.addAttribute(getContext(), i, attr); 287249259Sdim setAttributes(PAL); 288249259Sdim} 289249259Sdim 290249259Sdimvoid Function::addAttributes(unsigned i, AttributeSet attrs) { 291249259Sdim AttributeSet PAL = getAttributes(); 292249259Sdim PAL = PAL.addAttributes(getContext(), i, attrs); 293249259Sdim setAttributes(PAL); 294249259Sdim} 295249259Sdim 296249259Sdimvoid Function::removeAttributes(unsigned i, AttributeSet attrs) { 297249259Sdim AttributeSet PAL = getAttributes(); 298249259Sdim PAL = PAL.removeAttributes(getContext(), i, attrs); 299249259Sdim setAttributes(PAL); 300249259Sdim} 301249259Sdim 302249259Sdim// Maintain the GC name for each function in an on-the-side table. This saves 303249259Sdim// allocating an additional word in Function for programs which do not use GC 304249259Sdim// (i.e., most programs) at the cost of increased overhead for clients which do 305249259Sdim// use GC. 306249259Sdimstatic DenseMap<const Function*,PooledStringPtr> *GCNames; 307249259Sdimstatic StringPool *GCNamePool; 308249259Sdimstatic ManagedStatic<sys::SmartRWMutex<true> > GCLock; 309249259Sdim 310249259Sdimbool Function::hasGC() const { 311249259Sdim sys::SmartScopedReader<true> Reader(*GCLock); 312249259Sdim return GCNames && GCNames->count(this); 313249259Sdim} 314249259Sdim 315249259Sdimconst char *Function::getGC() const { 316249259Sdim assert(hasGC() && "Function has no collector"); 317249259Sdim sys::SmartScopedReader<true> Reader(*GCLock); 318249259Sdim return *(*GCNames)[this]; 319249259Sdim} 320249259Sdim 321249259Sdimvoid Function::setGC(const char *Str) { 322249259Sdim sys::SmartScopedWriter<true> Writer(*GCLock); 323249259Sdim if (!GCNamePool) 324249259Sdim GCNamePool = new StringPool(); 325249259Sdim if (!GCNames) 326249259Sdim GCNames = new DenseMap<const Function*,PooledStringPtr>(); 327249259Sdim (*GCNames)[this] = GCNamePool->intern(Str); 328249259Sdim} 329249259Sdim 330249259Sdimvoid Function::clearGC() { 331249259Sdim sys::SmartScopedWriter<true> Writer(*GCLock); 332249259Sdim if (GCNames) { 333249259Sdim GCNames->erase(this); 334249259Sdim if (GCNames->empty()) { 335249259Sdim delete GCNames; 336249259Sdim GCNames = 0; 337249259Sdim if (GCNamePool->empty()) { 338249259Sdim delete GCNamePool; 339249259Sdim GCNamePool = 0; 340249259Sdim } 341249259Sdim } 342249259Sdim } 343249259Sdim} 344249259Sdim 345249259Sdim/// copyAttributesFrom - copy all additional attributes (those not needed to 346249259Sdim/// create a Function) from the Function Src to this one. 347249259Sdimvoid Function::copyAttributesFrom(const GlobalValue *Src) { 348249259Sdim assert(isa<Function>(Src) && "Expected a Function!"); 349249259Sdim GlobalValue::copyAttributesFrom(Src); 350249259Sdim const Function *SrcF = cast<Function>(Src); 351249259Sdim setCallingConv(SrcF->getCallingConv()); 352249259Sdim setAttributes(SrcF->getAttributes()); 353249259Sdim if (SrcF->hasGC()) 354249259Sdim setGC(SrcF->getGC()); 355249259Sdim else 356249259Sdim clearGC(); 357263508Sdim if (SrcF->hasPrefixData()) 358263508Sdim setPrefixData(SrcF->getPrefixData()); 359263508Sdim else 360263508Sdim setPrefixData(0); 361249259Sdim} 362249259Sdim 363249259Sdim/// getIntrinsicID - This method returns the ID number of the specified 364249259Sdim/// function, or Intrinsic::not_intrinsic if the function is not an 365249259Sdim/// intrinsic, or if the pointer is null. This value is always defined to be 366249259Sdim/// zero to allow easy checking for whether a function is intrinsic or not. The 367249259Sdim/// particular intrinsic functions which correspond to this value are defined in 368249259Sdim/// llvm/Intrinsics.h. Results are cached in the LLVM context, subsequent 369249259Sdim/// requests for the same ID return results much faster from the cache. 370249259Sdim/// 371249259Sdimunsigned Function::getIntrinsicID() const { 372249259Sdim const ValueName *ValName = this->getValueName(); 373249259Sdim if (!ValName || !isIntrinsic()) 374249259Sdim return 0; 375249259Sdim 376249259Sdim LLVMContextImpl::IntrinsicIDCacheTy &IntrinsicIDCache = 377249259Sdim getContext().pImpl->IntrinsicIDCache; 378249259Sdim if (!IntrinsicIDCache.count(this)) { 379249259Sdim unsigned Id = lookupIntrinsicID(); 380249259Sdim IntrinsicIDCache[this]=Id; 381249259Sdim return Id; 382249259Sdim } 383249259Sdim return IntrinsicIDCache[this]; 384249259Sdim} 385249259Sdim 386249259Sdim/// This private method does the actual lookup of an intrinsic ID when the query 387249259Sdim/// could not be answered from the cache. 388249259Sdimunsigned Function::lookupIntrinsicID() const { 389249259Sdim const ValueName *ValName = this->getValueName(); 390249259Sdim unsigned Len = ValName->getKeyLength(); 391249259Sdim const char *Name = ValName->getKeyData(); 392249259Sdim 393249259Sdim#define GET_FUNCTION_RECOGNIZER 394249259Sdim#include "llvm/IR/Intrinsics.gen" 395249259Sdim#undef GET_FUNCTION_RECOGNIZER 396249259Sdim 397249259Sdim return 0; 398249259Sdim} 399249259Sdim 400249259Sdimstd::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) { 401249259Sdim assert(id < num_intrinsics && "Invalid intrinsic ID!"); 402249259Sdim static const char * const Table[] = { 403249259Sdim "not_intrinsic", 404249259Sdim#define GET_INTRINSIC_NAME_TABLE 405249259Sdim#include "llvm/IR/Intrinsics.gen" 406249259Sdim#undef GET_INTRINSIC_NAME_TABLE 407249259Sdim }; 408249259Sdim if (Tys.empty()) 409249259Sdim return Table[id]; 410249259Sdim std::string Result(Table[id]); 411249259Sdim for (unsigned i = 0; i < Tys.size(); ++i) { 412249259Sdim if (PointerType* PTyp = dyn_cast<PointerType>(Tys[i])) { 413249259Sdim Result += ".p" + llvm::utostr(PTyp->getAddressSpace()) + 414249259Sdim EVT::getEVT(PTyp->getElementType()).getEVTString(); 415249259Sdim } 416249259Sdim else if (Tys[i]) 417249259Sdim Result += "." + EVT::getEVT(Tys[i]).getEVTString(); 418249259Sdim } 419249259Sdim return Result; 420249259Sdim} 421249259Sdim 422249259Sdim 423249259Sdim/// IIT_Info - These are enumerators that describe the entries returned by the 424249259Sdim/// getIntrinsicInfoTableEntries function. 425249259Sdim/// 426249259Sdim/// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter! 427249259Sdimenum IIT_Info { 428249259Sdim // Common values should be encoded with 0-15. 429249259Sdim IIT_Done = 0, 430249259Sdim IIT_I1 = 1, 431249259Sdim IIT_I8 = 2, 432249259Sdim IIT_I16 = 3, 433249259Sdim IIT_I32 = 4, 434249259Sdim IIT_I64 = 5, 435249259Sdim IIT_F16 = 6, 436249259Sdim IIT_F32 = 7, 437249259Sdim IIT_F64 = 8, 438249259Sdim IIT_V2 = 9, 439249259Sdim IIT_V4 = 10, 440249259Sdim IIT_V8 = 11, 441249259Sdim IIT_V16 = 12, 442249259Sdim IIT_V32 = 13, 443249259Sdim IIT_PTR = 14, 444249259Sdim IIT_ARG = 15, 445249259Sdim 446249259Sdim // Values from 16+ are only encodable with the inefficient encoding. 447249259Sdim IIT_MMX = 16, 448249259Sdim IIT_METADATA = 17, 449249259Sdim IIT_EMPTYSTRUCT = 18, 450249259Sdim IIT_STRUCT2 = 19, 451249259Sdim IIT_STRUCT3 = 20, 452249259Sdim IIT_STRUCT4 = 21, 453249259Sdim IIT_STRUCT5 = 22, 454249259Sdim IIT_EXTEND_VEC_ARG = 23, 455249259Sdim IIT_TRUNC_VEC_ARG = 24, 456263508Sdim IIT_ANYPTR = 25, 457263508Sdim IIT_V1 = 26, 458263508Sdim IIT_VARARG = 27 459249259Sdim}; 460249259Sdim 461249259Sdim 462249259Sdimstatic void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, 463249259Sdim SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { 464249259Sdim IIT_Info Info = IIT_Info(Infos[NextElt++]); 465249259Sdim unsigned StructElts = 2; 466249259Sdim using namespace Intrinsic; 467249259Sdim 468249259Sdim switch (Info) { 469249259Sdim case IIT_Done: 470249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); 471249259Sdim return; 472263508Sdim case IIT_VARARG: 473263508Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); 474263508Sdim return; 475249259Sdim case IIT_MMX: 476249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); 477249259Sdim return; 478249259Sdim case IIT_METADATA: 479249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); 480249259Sdim return; 481249259Sdim case IIT_F16: 482249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); 483249259Sdim return; 484249259Sdim case IIT_F32: 485249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Float, 0)); 486249259Sdim return; 487249259Sdim case IIT_F64: 488249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Double, 0)); 489249259Sdim return; 490249259Sdim case IIT_I1: 491249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 1)); 492249259Sdim return; 493249259Sdim case IIT_I8: 494249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 8)); 495249259Sdim return; 496249259Sdim case IIT_I16: 497249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer,16)); 498249259Sdim return; 499249259Sdim case IIT_I32: 500249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 32)); 501249259Sdim return; 502249259Sdim case IIT_I64: 503249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Integer, 64)); 504249259Sdim return; 505263508Sdim case IIT_V1: 506263508Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 1)); 507263508Sdim DecodeIITType(NextElt, Infos, OutputTable); 508263508Sdim return; 509249259Sdim case IIT_V2: 510249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 2)); 511249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 512249259Sdim return; 513249259Sdim case IIT_V4: 514249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 4)); 515249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 516249259Sdim return; 517249259Sdim case IIT_V8: 518249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 8)); 519249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 520249259Sdim return; 521249259Sdim case IIT_V16: 522249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 16)); 523249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 524249259Sdim return; 525249259Sdim case IIT_V32: 526249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Vector, 32)); 527249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 528249259Sdim return; 529249259Sdim case IIT_PTR: 530249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 0)); 531249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 532249259Sdim return; 533249259Sdim case IIT_ANYPTR: { // [ANYPTR addrspace, subtype] 534249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Pointer, 535249259Sdim Infos[NextElt++])); 536249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 537249259Sdim return; 538249259Sdim } 539249259Sdim case IIT_ARG: { 540249259Sdim unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 541249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Argument, ArgInfo)); 542249259Sdim return; 543249259Sdim } 544249259Sdim case IIT_EXTEND_VEC_ARG: { 545249259Sdim unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 546249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::ExtendVecArgument, 547249259Sdim ArgInfo)); 548249259Sdim return; 549249259Sdim } 550249259Sdim case IIT_TRUNC_VEC_ARG: { 551249259Sdim unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]); 552249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::TruncVecArgument, 553249259Sdim ArgInfo)); 554249259Sdim return; 555249259Sdim } 556249259Sdim case IIT_EMPTYSTRUCT: 557249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0)); 558249259Sdim return; 559249259Sdim case IIT_STRUCT5: ++StructElts; // FALL THROUGH. 560249259Sdim case IIT_STRUCT4: ++StructElts; // FALL THROUGH. 561249259Sdim case IIT_STRUCT3: ++StructElts; // FALL THROUGH. 562249259Sdim case IIT_STRUCT2: { 563249259Sdim OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts)); 564249259Sdim 565249259Sdim for (unsigned i = 0; i != StructElts; ++i) 566249259Sdim DecodeIITType(NextElt, Infos, OutputTable); 567249259Sdim return; 568249259Sdim } 569249259Sdim } 570249259Sdim llvm_unreachable("unhandled"); 571249259Sdim} 572249259Sdim 573249259Sdim 574249259Sdim#define GET_INTRINSIC_GENERATOR_GLOBAL 575249259Sdim#include "llvm/IR/Intrinsics.gen" 576249259Sdim#undef GET_INTRINSIC_GENERATOR_GLOBAL 577249259Sdim 578249259Sdimvoid Intrinsic::getIntrinsicInfoTableEntries(ID id, 579249259Sdim SmallVectorImpl<IITDescriptor> &T){ 580249259Sdim // Check to see if the intrinsic's type was expressible by the table. 581249259Sdim unsigned TableVal = IIT_Table[id-1]; 582249259Sdim 583249259Sdim // Decode the TableVal into an array of IITValues. 584249259Sdim SmallVector<unsigned char, 8> IITValues; 585249259Sdim ArrayRef<unsigned char> IITEntries; 586249259Sdim unsigned NextElt = 0; 587249259Sdim if ((TableVal >> 31) != 0) { 588249259Sdim // This is an offset into the IIT_LongEncodingTable. 589249259Sdim IITEntries = IIT_LongEncodingTable; 590249259Sdim 591249259Sdim // Strip sentinel bit. 592249259Sdim NextElt = (TableVal << 1) >> 1; 593249259Sdim } else { 594249259Sdim // Decode the TableVal into an array of IITValues. If the entry was encoded 595249259Sdim // into a single word in the table itself, decode it now. 596249259Sdim do { 597249259Sdim IITValues.push_back(TableVal & 0xF); 598249259Sdim TableVal >>= 4; 599249259Sdim } while (TableVal); 600249259Sdim 601249259Sdim IITEntries = IITValues; 602249259Sdim NextElt = 0; 603249259Sdim } 604249259Sdim 605249259Sdim // Okay, decode the table into the output vector of IITDescriptors. 606249259Sdim DecodeIITType(NextElt, IITEntries, T); 607249259Sdim while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0) 608249259Sdim DecodeIITType(NextElt, IITEntries, T); 609249259Sdim} 610249259Sdim 611249259Sdim 612249259Sdimstatic Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos, 613249259Sdim ArrayRef<Type*> Tys, LLVMContext &Context) { 614249259Sdim using namespace Intrinsic; 615249259Sdim IITDescriptor D = Infos.front(); 616249259Sdim Infos = Infos.slice(1); 617249259Sdim 618249259Sdim switch (D.Kind) { 619249259Sdim case IITDescriptor::Void: return Type::getVoidTy(Context); 620263508Sdim case IITDescriptor::VarArg: return Type::getVoidTy(Context); 621249259Sdim case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); 622249259Sdim case IITDescriptor::Metadata: return Type::getMetadataTy(Context); 623249259Sdim case IITDescriptor::Half: return Type::getHalfTy(Context); 624249259Sdim case IITDescriptor::Float: return Type::getFloatTy(Context); 625249259Sdim case IITDescriptor::Double: return Type::getDoubleTy(Context); 626249259Sdim 627249259Sdim case IITDescriptor::Integer: 628249259Sdim return IntegerType::get(Context, D.Integer_Width); 629249259Sdim case IITDescriptor::Vector: 630249259Sdim return VectorType::get(DecodeFixedType(Infos, Tys, Context),D.Vector_Width); 631249259Sdim case IITDescriptor::Pointer: 632249259Sdim return PointerType::get(DecodeFixedType(Infos, Tys, Context), 633249259Sdim D.Pointer_AddressSpace); 634249259Sdim case IITDescriptor::Struct: { 635249259Sdim Type *Elts[5]; 636249259Sdim assert(D.Struct_NumElements <= 5 && "Can't handle this yet"); 637249259Sdim for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i) 638249259Sdim Elts[i] = DecodeFixedType(Infos, Tys, Context); 639249259Sdim return StructType::get(Context, ArrayRef<Type*>(Elts,D.Struct_NumElements)); 640249259Sdim } 641249259Sdim 642249259Sdim case IITDescriptor::Argument: 643249259Sdim return Tys[D.getArgumentNumber()]; 644249259Sdim case IITDescriptor::ExtendVecArgument: 645249259Sdim return VectorType::getExtendedElementVectorType(cast<VectorType>( 646249259Sdim Tys[D.getArgumentNumber()])); 647249259Sdim 648249259Sdim case IITDescriptor::TruncVecArgument: 649249259Sdim return VectorType::getTruncatedElementVectorType(cast<VectorType>( 650249259Sdim Tys[D.getArgumentNumber()])); 651249259Sdim } 652249259Sdim llvm_unreachable("unhandled"); 653249259Sdim} 654249259Sdim 655249259Sdim 656249259Sdim 657249259SdimFunctionType *Intrinsic::getType(LLVMContext &Context, 658249259Sdim ID id, ArrayRef<Type*> Tys) { 659249259Sdim SmallVector<IITDescriptor, 8> Table; 660249259Sdim getIntrinsicInfoTableEntries(id, Table); 661249259Sdim 662249259Sdim ArrayRef<IITDescriptor> TableRef = Table; 663249259Sdim Type *ResultTy = DecodeFixedType(TableRef, Tys, Context); 664249259Sdim 665249259Sdim SmallVector<Type*, 8> ArgTys; 666249259Sdim while (!TableRef.empty()) 667249259Sdim ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context)); 668249259Sdim 669249259Sdim return FunctionType::get(ResultTy, ArgTys, false); 670249259Sdim} 671249259Sdim 672249259Sdimbool Intrinsic::isOverloaded(ID id) { 673249259Sdim#define GET_INTRINSIC_OVERLOAD_TABLE 674249259Sdim#include "llvm/IR/Intrinsics.gen" 675249259Sdim#undef GET_INTRINSIC_OVERLOAD_TABLE 676249259Sdim} 677249259Sdim 678249259Sdim/// This defines the "Intrinsic::getAttributes(ID id)" method. 679249259Sdim#define GET_INTRINSIC_ATTRIBUTES 680249259Sdim#include "llvm/IR/Intrinsics.gen" 681249259Sdim#undef GET_INTRINSIC_ATTRIBUTES 682249259Sdim 683249259SdimFunction *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) { 684249259Sdim // There can never be multiple globals with the same name of different types, 685249259Sdim // because intrinsics must be a specific type. 686249259Sdim return 687249259Sdim cast<Function>(M->getOrInsertFunction(getName(id, Tys), 688249259Sdim getType(M->getContext(), id, Tys))); 689249259Sdim} 690249259Sdim 691249259Sdim// This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method. 692249259Sdim#define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 693249259Sdim#include "llvm/IR/Intrinsics.gen" 694249259Sdim#undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN 695249259Sdim 696249259Sdim/// hasAddressTaken - returns true if there are any uses of this function 697249259Sdim/// other than direct calls or invokes to it. 698249259Sdimbool Function::hasAddressTaken(const User* *PutOffender) const { 699249259Sdim for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) { 700249259Sdim const User *U = *I; 701249259Sdim if (isa<BlockAddress>(U)) 702249259Sdim continue; 703249259Sdim if (!isa<CallInst>(U) && !isa<InvokeInst>(U)) 704249259Sdim return PutOffender ? (*PutOffender = U, true) : true; 705249259Sdim ImmutableCallSite CS(cast<Instruction>(U)); 706249259Sdim if (!CS.isCallee(I)) 707249259Sdim return PutOffender ? (*PutOffender = U, true) : true; 708249259Sdim } 709249259Sdim return false; 710249259Sdim} 711249259Sdim 712249259Sdimbool Function::isDefTriviallyDead() const { 713249259Sdim // Check the linkage 714249259Sdim if (!hasLinkOnceLinkage() && !hasLocalLinkage() && 715249259Sdim !hasAvailableExternallyLinkage()) 716249259Sdim return false; 717249259Sdim 718249259Sdim // Check if the function is used by anything other than a blockaddress. 719249259Sdim for (Value::const_use_iterator I = use_begin(), E = use_end(); I != E; ++I) 720249259Sdim if (!isa<BlockAddress>(*I)) 721249259Sdim return false; 722249259Sdim 723249259Sdim return true; 724249259Sdim} 725249259Sdim 726249259Sdim/// callsFunctionThatReturnsTwice - Return true if the function has a call to 727249259Sdim/// setjmp or other function that gcc recognizes as "returning twice". 728249259Sdimbool Function::callsFunctionThatReturnsTwice() const { 729249259Sdim for (const_inst_iterator 730249259Sdim I = inst_begin(this), E = inst_end(this); I != E; ++I) { 731249259Sdim const CallInst* callInst = dyn_cast<CallInst>(&*I); 732249259Sdim if (!callInst) 733249259Sdim continue; 734249259Sdim if (callInst->canReturnTwice()) 735249259Sdim return true; 736249259Sdim } 737249259Sdim 738249259Sdim return false; 739249259Sdim} 740249259Sdim 741263508SdimConstant *Function::getPrefixData() const { 742263508Sdim assert(hasPrefixData()); 743263508Sdim const LLVMContextImpl::PrefixDataMapTy &PDMap = 744263508Sdim getContext().pImpl->PrefixDataMap; 745263508Sdim assert(PDMap.find(this) != PDMap.end()); 746263508Sdim return cast<Constant>(PDMap.find(this)->second->getReturnValue()); 747263508Sdim} 748263508Sdim 749263508Sdimvoid Function::setPrefixData(Constant *PrefixData) { 750263508Sdim if (!PrefixData && !hasPrefixData()) 751263508Sdim return; 752263508Sdim 753263508Sdim unsigned SCData = getSubclassDataFromValue(); 754263508Sdim LLVMContextImpl::PrefixDataMapTy &PDMap = getContext().pImpl->PrefixDataMap; 755263508Sdim ReturnInst *&PDHolder = PDMap[this]; 756263508Sdim if (PrefixData) { 757263508Sdim if (PDHolder) 758263508Sdim PDHolder->setOperand(0, PrefixData); 759263508Sdim else 760263508Sdim PDHolder = ReturnInst::Create(getContext(), PrefixData); 761263508Sdim SCData |= 2; 762263508Sdim } else { 763263508Sdim delete PDHolder; 764263508Sdim PDMap.erase(this); 765263508Sdim SCData &= ~2; 766263508Sdim } 767263508Sdim setValueSubclassData(SCData); 768263508Sdim} 769