1193323Sed//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// This file implements the ValueEnumerator class. 11193323Sed// 12193323Sed//===----------------------------------------------------------------------===// 13193323Sed 14193323Sed#include "ValueEnumerator.h" 15249423Sdim#include "llvm/ADT/STLExtras.h" 16221345Sdim#include "llvm/ADT/SmallPtrSet.h" 17249423Sdim#include "llvm/IR/Constants.h" 18249423Sdim#include "llvm/IR/DerivedTypes.h" 19249423Sdim#include "llvm/IR/Instructions.h" 20249423Sdim#include "llvm/IR/Module.h" 21249423Sdim#include "llvm/IR/ValueSymbolTable.h" 22234353Sdim#include "llvm/Support/Debug.h" 23234353Sdim#include "llvm/Support/raw_ostream.h" 24193323Sed#include <algorithm> 25193323Sedusing namespace llvm; 26193323Sed 27249423Sdimstatic bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) { 28249423Sdim return V.first->getType()->isIntOrIntVectorTy(); 29193323Sed} 30193323Sed 31193323Sed/// ValueEnumerator - Enumerate module-level information. 32193323SedValueEnumerator::ValueEnumerator(const Module *M) { 33193323Sed // Enumerate the global variables. 34193323Sed for (Module::const_global_iterator I = M->global_begin(), 35193323Sed E = M->global_end(); I != E; ++I) 36193323Sed EnumerateValue(I); 37193323Sed 38193323Sed // Enumerate the functions. 39193323Sed for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { 40193323Sed EnumerateValue(I); 41193323Sed EnumerateAttributes(cast<Function>(I)->getAttributes()); 42193323Sed } 43193323Sed 44193323Sed // Enumerate the aliases. 45193323Sed for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 46193323Sed I != E; ++I) 47193323Sed EnumerateValue(I); 48198090Srdivacky 49193323Sed // Remember what is the cutoff between globalvalue's and other constants. 50193323Sed unsigned FirstConstant = Values.size(); 51198090Srdivacky 52193323Sed // Enumerate the global variable initializers. 53193323Sed for (Module::const_global_iterator I = M->global_begin(), 54193323Sed E = M->global_end(); I != E; ++I) 55193323Sed if (I->hasInitializer()) 56193323Sed EnumerateValue(I->getInitializer()); 57193323Sed 58193323Sed // Enumerate the aliasees. 59193323Sed for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 60193323Sed I != E; ++I) 61193323Sed EnumerateValue(I->getAliasee()); 62198090Srdivacky 63263508Sdim // Enumerate the prefix data constants. 64263508Sdim for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 65263508Sdim if (I->hasPrefixData()) 66263508Sdim EnumerateValue(I->getPrefixData()); 67263508Sdim 68249423Sdim // Insert constants and metadata that are named at module level into the slot 69202375Srdivacky // pool so that the module symbol table can refer to them... 70193323Sed EnumerateValueSymbolTable(M->getValueSymbolTable()); 71212904Sdim EnumerateNamedMetadata(M); 72198090Srdivacky 73201360Srdivacky SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 74201360Srdivacky 75193323Sed // Enumerate types used by function bodies and argument lists. 76193323Sed for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) { 77198090Srdivacky 78193323Sed for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 79193323Sed I != E; ++I) 80193323Sed EnumerateType(I->getType()); 81198090Srdivacky 82193323Sed for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 83193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){ 84198090Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 85202375Srdivacky OI != E; ++OI) { 86202375Srdivacky if (MDNode *MD = dyn_cast<MDNode>(*OI)) 87203954Srdivacky if (MD->isFunctionLocal() && MD->getFunction()) 88202375Srdivacky // These will get enumerated during function-incorporation. 89202375Srdivacky continue; 90193323Sed EnumerateOperandType(*OI); 91202375Srdivacky } 92193323Sed EnumerateType(I->getType()); 93193323Sed if (const CallInst *CI = dyn_cast<CallInst>(I)) 94193323Sed EnumerateAttributes(CI->getAttributes()); 95193323Sed else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) 96193323Sed EnumerateAttributes(II->getAttributes()); 97198090Srdivacky 98198090Srdivacky // Enumerate metadata attached with this instruction. 99198396Srdivacky MDs.clear(); 100206124Srdivacky I->getAllMetadataOtherThanDebugLoc(MDs); 101201360Srdivacky for (unsigned i = 0, e = MDs.size(); i != e; ++i) 102201360Srdivacky EnumerateMetadata(MDs[i].second); 103249423Sdim 104206124Srdivacky if (!I->getDebugLoc().isUnknown()) { 105206124Srdivacky MDNode *Scope, *IA; 106206124Srdivacky I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext()); 107206124Srdivacky if (Scope) EnumerateMetadata(Scope); 108206124Srdivacky if (IA) EnumerateMetadata(IA); 109206124Srdivacky } 110193323Sed } 111193323Sed } 112198090Srdivacky 113193323Sed // Optimize constant ordering. 114193323Sed OptimizeConstants(FirstConstant, Values.size()); 115193323Sed} 116193323Sed 117198090Srdivackyunsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { 118198090Srdivacky InstructionMapType::const_iterator I = InstructionMap.find(Inst); 119224145Sdim assert(I != InstructionMap.end() && "Instruction is not mapped!"); 120212904Sdim return I->second; 121198090Srdivacky} 122198090Srdivacky 123198090Srdivackyvoid ValueEnumerator::setInstructionID(const Instruction *I) { 124198090Srdivacky InstructionMap[I] = InstructionCount++; 125198090Srdivacky} 126198090Srdivacky 127198090Srdivackyunsigned ValueEnumerator::getValueID(const Value *V) const { 128202878Srdivacky if (isa<MDNode>(V) || isa<MDString>(V)) { 129198090Srdivacky ValueMapType::const_iterator I = MDValueMap.find(V); 130198090Srdivacky assert(I != MDValueMap.end() && "Value not in slotcalculator!"); 131198090Srdivacky return I->second-1; 132198090Srdivacky } 133198090Srdivacky 134198090Srdivacky ValueMapType::const_iterator I = ValueMap.find(V); 135198090Srdivacky assert(I != ValueMap.end() && "Value not in slotcalculator!"); 136198090Srdivacky return I->second-1; 137198090Srdivacky} 138198090Srdivacky 139234353Sdimvoid ValueEnumerator::dump() const { 140234353Sdim print(dbgs(), ValueMap, "Default"); 141234353Sdim dbgs() << '\n'; 142234353Sdim print(dbgs(), MDValueMap, "MetaData"); 143234353Sdim dbgs() << '\n'; 144234353Sdim} 145234353Sdim 146234353Sdimvoid ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map, 147234353Sdim const char *Name) const { 148234353Sdim 149234353Sdim OS << "Map Name: " << Name << "\n"; 150234353Sdim OS << "Size: " << Map.size() << "\n"; 151234353Sdim for (ValueMapType::const_iterator I = Map.begin(), 152234353Sdim E = Map.end(); I != E; ++I) { 153234353Sdim 154234353Sdim const Value *V = I->first; 155234353Sdim if (V->hasName()) 156234353Sdim OS << "Value: " << V->getName(); 157234353Sdim else 158234353Sdim OS << "Value: [null]\n"; 159234353Sdim V->dump(); 160234353Sdim 161234353Sdim OS << " Uses(" << std::distance(V->use_begin(),V->use_end()) << "):"; 162234353Sdim for (Value::const_use_iterator UI = V->use_begin(), UE = V->use_end(); 163234353Sdim UI != UE; ++UI) { 164234353Sdim if (UI != V->use_begin()) 165234353Sdim OS << ","; 166234353Sdim if((*UI)->hasName()) 167234353Sdim OS << " " << (*UI)->getName(); 168234353Sdim else 169234353Sdim OS << " [null]"; 170234353Sdim 171234353Sdim } 172234353Sdim OS << "\n\n"; 173234353Sdim } 174234353Sdim} 175234353Sdim 176193323Sed// Optimize constant ordering. 177193323Sednamespace { 178193323Sed struct CstSortPredicate { 179193323Sed ValueEnumerator &VE; 180193323Sed explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {} 181193323Sed bool operator()(const std::pair<const Value*, unsigned> &LHS, 182193323Sed const std::pair<const Value*, unsigned> &RHS) { 183193323Sed // Sort by plane. 184193323Sed if (LHS.first->getType() != RHS.first->getType()) 185198090Srdivacky return VE.getTypeID(LHS.first->getType()) < 186193323Sed VE.getTypeID(RHS.first->getType()); 187193323Sed // Then by frequency. 188193323Sed return LHS.second > RHS.second; 189193323Sed } 190193323Sed }; 191193323Sed} 192193323Sed 193193323Sed/// OptimizeConstants - Reorder constant pool for denser encoding. 194193323Sedvoid ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { 195193323Sed if (CstStart == CstEnd || CstStart+1 == CstEnd) return; 196198090Srdivacky 197193323Sed CstSortPredicate P(*this); 198193323Sed std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P); 199198090Srdivacky 200249423Sdim // Ensure that integer and vector of integer constants are at the start of the 201249423Sdim // constant pool. This is important so that GEP structure indices come before 202249423Sdim // gep constant exprs. 203193323Sed std::partition(Values.begin()+CstStart, Values.begin()+CstEnd, 204249423Sdim isIntOrIntVectorValue); 205198090Srdivacky 206193323Sed // Rebuild the modified portion of ValueMap. 207193323Sed for (; CstStart != CstEnd; ++CstStart) 208193323Sed ValueMap[Values[CstStart].first] = CstStart+1; 209193323Sed} 210193323Sed 211193323Sed 212193323Sed/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol 213193323Sed/// table into the values table. 214193323Sedvoid ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { 215198090Srdivacky for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); 216193323Sed VI != VE; ++VI) 217193323Sed EnumerateValue(VI->getValue()); 218193323Sed} 219193323Sed 220212904Sdim/// EnumerateNamedMetadata - Insert all of the values referenced by 221212904Sdim/// named metadata in the specified module. 222212904Sdimvoid ValueEnumerator::EnumerateNamedMetadata(const Module *M) { 223212904Sdim for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), 224212904Sdim E = M->named_metadata_end(); I != E; ++I) 225212904Sdim EnumerateNamedMDNode(I); 226202375Srdivacky} 227202375Srdivacky 228202375Srdivackyvoid ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) { 229212904Sdim for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) 230212904Sdim EnumerateMetadata(MD->getOperand(i)); 231212904Sdim} 232212904Sdim 233212904Sdim/// EnumerateMDNodeOperands - Enumerate all non-function-local values 234212904Sdim/// and types referenced by the given MDNode. 235212904Sdimvoid ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) { 236212904Sdim for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 237212904Sdim if (Value *V = N->getOperand(i)) { 238212904Sdim if (isa<MDNode>(V) || isa<MDString>(V)) 239212904Sdim EnumerateMetadata(V); 240212904Sdim else if (!isa<Instruction>(V) && !isa<Argument>(V)) 241212904Sdim EnumerateValue(V); 242212904Sdim } else 243212904Sdim EnumerateType(Type::getVoidTy(N->getContext())); 244212904Sdim } 245212904Sdim} 246212904Sdim 247212904Sdimvoid ValueEnumerator::EnumerateMetadata(const Value *MD) { 248212904Sdim assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind"); 249212904Sdim 250212904Sdim // Enumerate the type of this value. 251212904Sdim EnumerateType(MD->getType()); 252212904Sdim 253212904Sdim const MDNode *N = dyn_cast<MDNode>(MD); 254212904Sdim 255212904Sdim // In the module-level pass, skip function-local nodes themselves, but 256212904Sdim // do walk their operands. 257212904Sdim if (N && N->isFunctionLocal() && N->getFunction()) { 258212904Sdim EnumerateMDNodeOperands(N); 259212904Sdim return; 260212904Sdim } 261212904Sdim 262202375Srdivacky // Check to see if it's already in! 263202375Srdivacky unsigned &MDValueID = MDValueMap[MD]; 264202375Srdivacky if (MDValueID) { 265202375Srdivacky // Increment use count. 266202375Srdivacky MDValues[MDValueID-1].second++; 267202375Srdivacky return; 268202375Srdivacky } 269212904Sdim MDValues.push_back(std::make_pair(MD, 1U)); 270212904Sdim MDValueID = MDValues.size(); 271202375Srdivacky 272212904Sdim // Enumerate all non-function-local operands. 273212904Sdim if (N) 274212904Sdim EnumerateMDNodeOperands(N); 275212904Sdim} 276212904Sdim 277212904Sdim/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata 278212904Sdim/// information reachable from the given MDNode. 279212904Sdimvoid ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) { 280212904Sdim assert(N->isFunctionLocal() && N->getFunction() && 281212904Sdim "EnumerateFunctionLocalMetadata called on non-function-local mdnode!"); 282212904Sdim 283202375Srdivacky // Enumerate the type of this value. 284212904Sdim EnumerateType(N->getType()); 285202375Srdivacky 286198090Srdivacky // Check to see if it's already in! 287212904Sdim unsigned &MDValueID = MDValueMap[N]; 288198090Srdivacky if (MDValueID) { 289198090Srdivacky // Increment use count. 290198090Srdivacky MDValues[MDValueID-1].second++; 291198090Srdivacky return; 292198090Srdivacky } 293212904Sdim MDValues.push_back(std::make_pair(N, 1U)); 294212904Sdim MDValueID = MDValues.size(); 295198090Srdivacky 296212904Sdim // To incoroporate function-local information visit all function-local 297212904Sdim // MDNodes and all function-local values they reference. 298212904Sdim for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 299212904Sdim if (Value *V = N->getOperand(i)) { 300212904Sdim if (MDNode *O = dyn_cast<MDNode>(V)) { 301212904Sdim if (O->isFunctionLocal() && O->getFunction()) 302212904Sdim EnumerateFunctionLocalMetadata(O); 303212904Sdim } else if (isa<Instruction>(V) || isa<Argument>(V)) 304198396Srdivacky EnumerateValue(V); 305198090Srdivacky } 306212904Sdim 307212904Sdim // Also, collect all function-local MDNodes for easy access. 308212904Sdim FunctionLocalMDs.push_back(N); 309198090Srdivacky} 310198090Srdivacky 311193323Sedvoid ValueEnumerator::EnumerateValue(const Value *V) { 312201360Srdivacky assert(!V->getType()->isVoidTy() && "Can't insert void values!"); 313212904Sdim assert(!isa<MDNode>(V) && !isa<MDString>(V) && 314212904Sdim "EnumerateValue doesn't handle Metadata!"); 315198090Srdivacky 316193323Sed // Check to see if it's already in! 317193323Sed unsigned &ValueID = ValueMap[V]; 318193323Sed if (ValueID) { 319193323Sed // Increment use count. 320193323Sed Values[ValueID-1].second++; 321193323Sed return; 322193323Sed } 323193323Sed 324193323Sed // Enumerate the type of this value. 325193323Sed EnumerateType(V->getType()); 326198090Srdivacky 327193323Sed if (const Constant *C = dyn_cast<Constant>(V)) { 328193323Sed if (isa<GlobalValue>(C)) { 329193323Sed // Initializers for globals are handled explicitly elsewhere. 330193323Sed } else if (C->getNumOperands()) { 331193323Sed // If a constant has operands, enumerate them. This makes sure that if a 332193323Sed // constant has uses (for example an array of const ints), that they are 333193323Sed // inserted also. 334198090Srdivacky 335193323Sed // We prefer to enumerate them with values before we enumerate the user 336193323Sed // itself. This makes it more likely that we can avoid forward references 337193323Sed // in the reader. We know that there can be no cycles in the constants 338193323Sed // graph that don't go through a global variable. 339193323Sed for (User::const_op_iterator I = C->op_begin(), E = C->op_end(); 340193323Sed I != E; ++I) 341198892Srdivacky if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress. 342198892Srdivacky EnumerateValue(*I); 343198090Srdivacky 344193323Sed // Finally, add the value. Doing this could make the ValueID reference be 345193323Sed // dangling, don't reuse it. 346193323Sed Values.push_back(std::make_pair(V, 1U)); 347193323Sed ValueMap[V] = Values.size(); 348193323Sed return; 349193323Sed } 350193323Sed } 351198090Srdivacky 352193323Sed // Add the value. 353193323Sed Values.push_back(std::make_pair(V, 1U)); 354193323Sed ValueID = Values.size(); 355193323Sed} 356193323Sed 357193323Sed 358226633Sdimvoid ValueEnumerator::EnumerateType(Type *Ty) { 359224145Sdim unsigned *TypeID = &TypeMap[Ty]; 360198090Srdivacky 361221345Sdim // We've already seen this type. 362224145Sdim if (*TypeID) 363193323Sed return; 364198090Srdivacky 365224145Sdim // If it is a non-anonymous struct, mark the type as being visited so that we 366224145Sdim // don't recursively visit it. This is safe because we allow forward 367224145Sdim // references of these in the bitcode reader. 368226633Sdim if (StructType *STy = dyn_cast<StructType>(Ty)) 369226633Sdim if (!STy->isLiteral()) 370224145Sdim *TypeID = ~0U; 371249423Sdim 372224145Sdim // Enumerate all of the subtypes before we enumerate this type. This ensures 373224145Sdim // that the type will be enumerated in an order that can be directly built. 374193323Sed for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); 375193323Sed I != E; ++I) 376193323Sed EnumerateType(*I); 377249423Sdim 378224145Sdim // Refresh the TypeID pointer in case the table rehashed. 379224145Sdim TypeID = &TypeMap[Ty]; 380249423Sdim 381224145Sdim // Check to see if we got the pointer another way. This can happen when 382224145Sdim // enumerating recursive types that hit the base case deeper than they start. 383224145Sdim // 384224145Sdim // If this is actually a struct that we are treating as forward ref'able, 385224145Sdim // then emit the definition now that all of its contents are available. 386224145Sdim if (*TypeID && *TypeID != ~0U) 387224145Sdim return; 388249423Sdim 389224145Sdim // Add this type now that its contents are all happily enumerated. 390224145Sdim Types.push_back(Ty); 391249423Sdim 392224145Sdim *TypeID = Types.size(); 393193323Sed} 394193323Sed 395193323Sed// Enumerate the types for the specified value. If the value is a constant, 396193323Sed// walk through it, enumerating the types of the constant. 397193323Sedvoid ValueEnumerator::EnumerateOperandType(const Value *V) { 398193323Sed EnumerateType(V->getType()); 399249423Sdim 400193323Sed if (const Constant *C = dyn_cast<Constant>(V)) { 401193323Sed // If this constant is already enumerated, ignore it, we know its type must 402193323Sed // be enumerated. 403193323Sed if (ValueMap.count(V)) return; 404193323Sed 405193323Sed // This constant may have operands, make sure to enumerate the types in 406193323Sed // them. 407198892Srdivacky for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 408221345Sdim const Value *Op = C->getOperand(i); 409249423Sdim 410198892Srdivacky // Don't enumerate basic blocks here, this happens as operands to 411198892Srdivacky // blockaddress. 412198892Srdivacky if (isa<BasicBlock>(Op)) continue; 413249423Sdim 414212904Sdim EnumerateOperandType(Op); 415198892Srdivacky } 416193323Sed 417193323Sed if (const MDNode *N = dyn_cast<MDNode>(V)) { 418201360Srdivacky for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 419201360Srdivacky if (Value *Elem = N->getOperand(i)) 420198090Srdivacky EnumerateOperandType(Elem); 421193323Sed } 422198090Srdivacky } else if (isa<MDString>(V) || isa<MDNode>(V)) 423212904Sdim EnumerateMetadata(V); 424193323Sed} 425193323Sed 426249423Sdimvoid ValueEnumerator::EnumerateAttributes(AttributeSet PAL) { 427193323Sed if (PAL.isEmpty()) return; // null is always 0. 428249423Sdim 429193323Sed // Do a lookup. 430249423Sdim unsigned &Entry = AttributeMap[PAL]; 431193323Sed if (Entry == 0) { 432193323Sed // Never saw this before, add it. 433249423Sdim Attribute.push_back(PAL); 434249423Sdim Entry = Attribute.size(); 435193323Sed } 436249423Sdim 437249423Sdim // Do lookups for all attribute groups. 438249423Sdim for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) { 439249423Sdim AttributeSet AS = PAL.getSlotAttributes(i); 440249423Sdim unsigned &Entry = AttributeGroupMap[AS]; 441249423Sdim if (Entry == 0) { 442249423Sdim AttributeGroups.push_back(AS); 443249423Sdim Entry = AttributeGroups.size(); 444249423Sdim } 445249423Sdim } 446193323Sed} 447193323Sed 448193323Sedvoid ValueEnumerator::incorporateFunction(const Function &F) { 449204642Srdivacky InstructionCount = 0; 450193323Sed NumModuleValues = Values.size(); 451212904Sdim NumModuleMDValues = MDValues.size(); 452198090Srdivacky 453193323Sed // Adding function arguments to the value table. 454212904Sdim for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); 455212904Sdim I != E; ++I) 456193323Sed EnumerateValue(I); 457193323Sed 458193323Sed FirstFuncConstantID = Values.size(); 459198090Srdivacky 460193323Sed // Add all function-level constants to the value table. 461193323Sed for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 462193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) 463198090Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 464193323Sed OI != E; ++OI) { 465193323Sed if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || 466193323Sed isa<InlineAsm>(*OI)) 467193323Sed EnumerateValue(*OI); 468193323Sed } 469193323Sed BasicBlocks.push_back(BB); 470193323Sed ValueMap[BB] = BasicBlocks.size(); 471193323Sed } 472198090Srdivacky 473193323Sed // Optimize the constant layout. 474193323Sed OptimizeConstants(FirstFuncConstantID, Values.size()); 475198090Srdivacky 476193323Sed // Add the function's parameter attributes so they are available for use in 477193323Sed // the function's instruction. 478193323Sed EnumerateAttributes(F.getAttributes()); 479193323Sed 480193323Sed FirstInstID = Values.size(); 481198090Srdivacky 482210299Sed SmallVector<MDNode *, 8> FnLocalMDVector; 483193323Sed // Add all of the instructions. 484193323Sed for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 485193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 486202375Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 487202375Srdivacky OI != E; ++OI) { 488202375Srdivacky if (MDNode *MD = dyn_cast<MDNode>(*OI)) 489203954Srdivacky if (MD->isFunctionLocal() && MD->getFunction()) 490203954Srdivacky // Enumerate metadata after the instructions they might refer to. 491210299Sed FnLocalMDVector.push_back(MD); 492202375Srdivacky } 493212904Sdim 494212904Sdim SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 495212904Sdim I->getAllMetadataOtherThanDebugLoc(MDs); 496212904Sdim for (unsigned i = 0, e = MDs.size(); i != e; ++i) { 497212904Sdim MDNode *N = MDs[i].second; 498212904Sdim if (N->isFunctionLocal() && N->getFunction()) 499212904Sdim FnLocalMDVector.push_back(N); 500212904Sdim } 501249423Sdim 502202375Srdivacky if (!I->getType()->isVoidTy()) 503193323Sed EnumerateValue(I); 504193323Sed } 505193323Sed } 506203954Srdivacky 507203954Srdivacky // Add all of the function-local metadata. 508210299Sed for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i) 509212904Sdim EnumerateFunctionLocalMetadata(FnLocalMDVector[i]); 510193323Sed} 511193323Sed 512193323Sedvoid ValueEnumerator::purgeFunction() { 513193323Sed /// Remove purged values from the ValueMap. 514193323Sed for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i) 515193323Sed ValueMap.erase(Values[i].first); 516212904Sdim for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i) 517212904Sdim MDValueMap.erase(MDValues[i].first); 518193323Sed for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) 519193323Sed ValueMap.erase(BasicBlocks[i]); 520198090Srdivacky 521193323Sed Values.resize(NumModuleValues); 522212904Sdim MDValues.resize(NumModuleMDValues); 523193323Sed BasicBlocks.clear(); 524212904Sdim FunctionLocalMDs.clear(); 525193323Sed} 526198892Srdivacky 527198892Srdivackystatic void IncorporateFunctionInfoGlobalBBIDs(const Function *F, 528198892Srdivacky DenseMap<const BasicBlock*, unsigned> &IDMap) { 529198892Srdivacky unsigned Counter = 0; 530198892Srdivacky for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 531198892Srdivacky IDMap[BB] = ++Counter; 532198892Srdivacky} 533198892Srdivacky 534198892Srdivacky/// getGlobalBasicBlockID - This returns the function-specific ID for the 535198892Srdivacky/// specified basic block. This is relatively expensive information, so it 536198892Srdivacky/// should only be used by rare constructs such as address-of-label. 537198892Srdivackyunsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const { 538198892Srdivacky unsigned &Idx = GlobalBasicBlockIDs[BB]; 539198892Srdivacky if (Idx != 0) 540198892Srdivacky return Idx-1; 541198892Srdivacky 542198892Srdivacky IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs); 543198892Srdivacky return getGlobalBasicBlockID(BB); 544198892Srdivacky} 545198892Srdivacky 546