ValueEnumerator.cpp revision 224145
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" 15221345Sdim#include "llvm/ADT/SmallPtrSet.h" 16221345Sdim#include "llvm/ADT/STLExtras.h" 17193323Sed#include "llvm/Constants.h" 18193323Sed#include "llvm/DerivedTypes.h" 19193323Sed#include "llvm/Module.h" 20193323Sed#include "llvm/ValueSymbolTable.h" 21193323Sed#include "llvm/Instructions.h" 22193323Sed#include <algorithm> 23193323Sedusing namespace llvm; 24193323Sed 25193323Sedstatic bool isIntegerValue(const std::pair<const Value*, unsigned> &V) { 26204642Srdivacky return V.first->getType()->isIntegerTy(); 27193323Sed} 28193323Sed 29193323Sed/// ValueEnumerator - Enumerate module-level information. 30193323SedValueEnumerator::ValueEnumerator(const Module *M) { 31193323Sed // Enumerate the global variables. 32193323Sed for (Module::const_global_iterator I = M->global_begin(), 33193323Sed E = M->global_end(); I != E; ++I) 34193323Sed EnumerateValue(I); 35193323Sed 36193323Sed // Enumerate the functions. 37193323Sed for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { 38193323Sed EnumerateValue(I); 39193323Sed EnumerateAttributes(cast<Function>(I)->getAttributes()); 40193323Sed } 41193323Sed 42193323Sed // Enumerate the aliases. 43193323Sed for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 44193323Sed I != E; ++I) 45193323Sed EnumerateValue(I); 46198090Srdivacky 47193323Sed // Remember what is the cutoff between globalvalue's and other constants. 48193323Sed unsigned FirstConstant = Values.size(); 49198090Srdivacky 50193323Sed // Enumerate the global variable initializers. 51193323Sed for (Module::const_global_iterator I = M->global_begin(), 52193323Sed E = M->global_end(); I != E; ++I) 53193323Sed if (I->hasInitializer()) 54193323Sed EnumerateValue(I->getInitializer()); 55193323Sed 56193323Sed // Enumerate the aliasees. 57193323Sed for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 58193323Sed I != E; ++I) 59193323Sed EnumerateValue(I->getAliasee()); 60198090Srdivacky 61210299Sed // Insert constants and metadata that are named at module level into the slot 62202375Srdivacky // pool so that the module symbol table can refer to them... 63193323Sed EnumerateValueSymbolTable(M->getValueSymbolTable()); 64212904Sdim EnumerateNamedMetadata(M); 65198090Srdivacky 66201360Srdivacky SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 67201360Srdivacky 68193323Sed // Enumerate types used by function bodies and argument lists. 69193323Sed for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) { 70198090Srdivacky 71193323Sed for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 72193323Sed I != E; ++I) 73193323Sed EnumerateType(I->getType()); 74198090Srdivacky 75193323Sed for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 76193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){ 77198090Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 78202375Srdivacky OI != E; ++OI) { 79202375Srdivacky if (MDNode *MD = dyn_cast<MDNode>(*OI)) 80203954Srdivacky if (MD->isFunctionLocal() && MD->getFunction()) 81202375Srdivacky // These will get enumerated during function-incorporation. 82202375Srdivacky continue; 83193323Sed EnumerateOperandType(*OI); 84202375Srdivacky } 85193323Sed EnumerateType(I->getType()); 86193323Sed if (const CallInst *CI = dyn_cast<CallInst>(I)) 87193323Sed EnumerateAttributes(CI->getAttributes()); 88193323Sed else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) 89193323Sed EnumerateAttributes(II->getAttributes()); 90198090Srdivacky 91198090Srdivacky // Enumerate metadata attached with this instruction. 92198396Srdivacky MDs.clear(); 93206124Srdivacky I->getAllMetadataOtherThanDebugLoc(MDs); 94201360Srdivacky for (unsigned i = 0, e = MDs.size(); i != e; ++i) 95201360Srdivacky EnumerateMetadata(MDs[i].second); 96206124Srdivacky 97206124Srdivacky if (!I->getDebugLoc().isUnknown()) { 98206124Srdivacky MDNode *Scope, *IA; 99206124Srdivacky I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext()); 100206124Srdivacky if (Scope) EnumerateMetadata(Scope); 101206124Srdivacky if (IA) EnumerateMetadata(IA); 102206124Srdivacky } 103193323Sed } 104193323Sed } 105198090Srdivacky 106193323Sed // Optimize constant ordering. 107193323Sed OptimizeConstants(FirstConstant, Values.size()); 108193323Sed} 109193323Sed 110221345Sdim 111198090Srdivackyunsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { 112198090Srdivacky InstructionMapType::const_iterator I = InstructionMap.find(Inst); 113224145Sdim assert(I != InstructionMap.end() && "Instruction is not mapped!"); 114212904Sdim return I->second; 115198090Srdivacky} 116198090Srdivacky 117198090Srdivackyvoid ValueEnumerator::setInstructionID(const Instruction *I) { 118198090Srdivacky InstructionMap[I] = InstructionCount++; 119198090Srdivacky} 120198090Srdivacky 121198090Srdivackyunsigned ValueEnumerator::getValueID(const Value *V) const { 122202878Srdivacky if (isa<MDNode>(V) || isa<MDString>(V)) { 123198090Srdivacky ValueMapType::const_iterator I = MDValueMap.find(V); 124198090Srdivacky assert(I != MDValueMap.end() && "Value not in slotcalculator!"); 125198090Srdivacky return I->second-1; 126198090Srdivacky } 127198090Srdivacky 128198090Srdivacky ValueMapType::const_iterator I = ValueMap.find(V); 129198090Srdivacky assert(I != ValueMap.end() && "Value not in slotcalculator!"); 130198090Srdivacky return I->second-1; 131198090Srdivacky} 132198090Srdivacky 133193323Sed// Optimize constant ordering. 134193323Sednamespace { 135193323Sed struct CstSortPredicate { 136193323Sed ValueEnumerator &VE; 137193323Sed explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {} 138193323Sed bool operator()(const std::pair<const Value*, unsigned> &LHS, 139193323Sed const std::pair<const Value*, unsigned> &RHS) { 140193323Sed // Sort by plane. 141193323Sed if (LHS.first->getType() != RHS.first->getType()) 142198090Srdivacky return VE.getTypeID(LHS.first->getType()) < 143193323Sed VE.getTypeID(RHS.first->getType()); 144193323Sed // Then by frequency. 145193323Sed return LHS.second > RHS.second; 146193323Sed } 147193323Sed }; 148193323Sed} 149193323Sed 150193323Sed/// OptimizeConstants - Reorder constant pool for denser encoding. 151193323Sedvoid ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { 152193323Sed if (CstStart == CstEnd || CstStart+1 == CstEnd) return; 153198090Srdivacky 154193323Sed CstSortPredicate P(*this); 155193323Sed std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P); 156198090Srdivacky 157193323Sed // Ensure that integer constants are at the start of the constant pool. This 158193323Sed // is important so that GEP structure indices come before gep constant exprs. 159193323Sed std::partition(Values.begin()+CstStart, Values.begin()+CstEnd, 160193323Sed isIntegerValue); 161198090Srdivacky 162193323Sed // Rebuild the modified portion of ValueMap. 163193323Sed for (; CstStart != CstEnd; ++CstStart) 164193323Sed ValueMap[Values[CstStart].first] = CstStart+1; 165193323Sed} 166193323Sed 167193323Sed 168193323Sed/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol 169193323Sed/// table into the values table. 170193323Sedvoid ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { 171198090Srdivacky for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); 172193323Sed VI != VE; ++VI) 173193323Sed EnumerateValue(VI->getValue()); 174193323Sed} 175193323Sed 176212904Sdim/// EnumerateNamedMetadata - Insert all of the values referenced by 177212904Sdim/// named metadata in the specified module. 178212904Sdimvoid ValueEnumerator::EnumerateNamedMetadata(const Module *M) { 179212904Sdim for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), 180212904Sdim E = M->named_metadata_end(); I != E; ++I) 181212904Sdim EnumerateNamedMDNode(I); 182202375Srdivacky} 183202375Srdivacky 184202375Srdivackyvoid ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) { 185212904Sdim for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) 186212904Sdim EnumerateMetadata(MD->getOperand(i)); 187212904Sdim} 188212904Sdim 189212904Sdim/// EnumerateMDNodeOperands - Enumerate all non-function-local values 190212904Sdim/// and types referenced by the given MDNode. 191212904Sdimvoid ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) { 192212904Sdim for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 193212904Sdim if (Value *V = N->getOperand(i)) { 194212904Sdim if (isa<MDNode>(V) || isa<MDString>(V)) 195212904Sdim EnumerateMetadata(V); 196212904Sdim else if (!isa<Instruction>(V) && !isa<Argument>(V)) 197212904Sdim EnumerateValue(V); 198212904Sdim } else 199212904Sdim EnumerateType(Type::getVoidTy(N->getContext())); 200212904Sdim } 201212904Sdim} 202212904Sdim 203212904Sdimvoid ValueEnumerator::EnumerateMetadata(const Value *MD) { 204212904Sdim assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind"); 205212904Sdim 206212904Sdim // Enumerate the type of this value. 207212904Sdim EnumerateType(MD->getType()); 208212904Sdim 209212904Sdim const MDNode *N = dyn_cast<MDNode>(MD); 210212904Sdim 211212904Sdim // In the module-level pass, skip function-local nodes themselves, but 212212904Sdim // do walk their operands. 213212904Sdim if (N && N->isFunctionLocal() && N->getFunction()) { 214212904Sdim EnumerateMDNodeOperands(N); 215212904Sdim return; 216212904Sdim } 217212904Sdim 218202375Srdivacky // Check to see if it's already in! 219202375Srdivacky unsigned &MDValueID = MDValueMap[MD]; 220202375Srdivacky if (MDValueID) { 221202375Srdivacky // Increment use count. 222202375Srdivacky MDValues[MDValueID-1].second++; 223202375Srdivacky return; 224202375Srdivacky } 225212904Sdim MDValues.push_back(std::make_pair(MD, 1U)); 226212904Sdim MDValueID = MDValues.size(); 227202375Srdivacky 228212904Sdim // Enumerate all non-function-local operands. 229212904Sdim if (N) 230212904Sdim EnumerateMDNodeOperands(N); 231212904Sdim} 232212904Sdim 233212904Sdim/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata 234212904Sdim/// information reachable from the given MDNode. 235212904Sdimvoid ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) { 236212904Sdim assert(N->isFunctionLocal() && N->getFunction() && 237212904Sdim "EnumerateFunctionLocalMetadata called on non-function-local mdnode!"); 238212904Sdim 239202375Srdivacky // Enumerate the type of this value. 240212904Sdim EnumerateType(N->getType()); 241202375Srdivacky 242198090Srdivacky // Check to see if it's already in! 243212904Sdim unsigned &MDValueID = MDValueMap[N]; 244198090Srdivacky if (MDValueID) { 245198090Srdivacky // Increment use count. 246198090Srdivacky MDValues[MDValueID-1].second++; 247198090Srdivacky return; 248198090Srdivacky } 249212904Sdim MDValues.push_back(std::make_pair(N, 1U)); 250212904Sdim MDValueID = MDValues.size(); 251198090Srdivacky 252212904Sdim // To incoroporate function-local information visit all function-local 253212904Sdim // MDNodes and all function-local values they reference. 254212904Sdim for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 255212904Sdim if (Value *V = N->getOperand(i)) { 256212904Sdim if (MDNode *O = dyn_cast<MDNode>(V)) { 257212904Sdim if (O->isFunctionLocal() && O->getFunction()) 258212904Sdim EnumerateFunctionLocalMetadata(O); 259212904Sdim } else if (isa<Instruction>(V) || isa<Argument>(V)) 260198396Srdivacky EnumerateValue(V); 261198090Srdivacky } 262212904Sdim 263212904Sdim // Also, collect all function-local MDNodes for easy access. 264212904Sdim FunctionLocalMDs.push_back(N); 265198090Srdivacky} 266198090Srdivacky 267193323Sedvoid ValueEnumerator::EnumerateValue(const Value *V) { 268201360Srdivacky assert(!V->getType()->isVoidTy() && "Can't insert void values!"); 269212904Sdim assert(!isa<MDNode>(V) && !isa<MDString>(V) && 270212904Sdim "EnumerateValue doesn't handle Metadata!"); 271198090Srdivacky 272193323Sed // Check to see if it's already in! 273193323Sed unsigned &ValueID = ValueMap[V]; 274193323Sed if (ValueID) { 275193323Sed // Increment use count. 276193323Sed Values[ValueID-1].second++; 277193323Sed return; 278193323Sed } 279193323Sed 280193323Sed // Enumerate the type of this value. 281193323Sed EnumerateType(V->getType()); 282198090Srdivacky 283193323Sed if (const Constant *C = dyn_cast<Constant>(V)) { 284193323Sed if (isa<GlobalValue>(C)) { 285193323Sed // Initializers for globals are handled explicitly elsewhere. 286193323Sed } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) { 287193323Sed // Do not enumerate the initializers for an array of simple characters. 288221345Sdim // The initializers just pollute the value table, and we emit the strings 289193323Sed // specially. 290193323Sed } else if (C->getNumOperands()) { 291193323Sed // If a constant has operands, enumerate them. This makes sure that if a 292193323Sed // constant has uses (for example an array of const ints), that they are 293193323Sed // inserted also. 294198090Srdivacky 295193323Sed // We prefer to enumerate them with values before we enumerate the user 296193323Sed // itself. This makes it more likely that we can avoid forward references 297193323Sed // in the reader. We know that there can be no cycles in the constants 298193323Sed // graph that don't go through a global variable. 299193323Sed for (User::const_op_iterator I = C->op_begin(), E = C->op_end(); 300193323Sed I != E; ++I) 301198892Srdivacky if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress. 302198892Srdivacky EnumerateValue(*I); 303198090Srdivacky 304193323Sed // Finally, add the value. Doing this could make the ValueID reference be 305193323Sed // dangling, don't reuse it. 306193323Sed Values.push_back(std::make_pair(V, 1U)); 307193323Sed ValueMap[V] = Values.size(); 308193323Sed return; 309193323Sed } 310193323Sed } 311198090Srdivacky 312193323Sed // Add the value. 313193323Sed Values.push_back(std::make_pair(V, 1U)); 314193323Sed ValueID = Values.size(); 315193323Sed} 316193323Sed 317193323Sed 318193323Sedvoid ValueEnumerator::EnumerateType(const Type *Ty) { 319224145Sdim unsigned *TypeID = &TypeMap[Ty]; 320198090Srdivacky 321221345Sdim // We've already seen this type. 322224145Sdim if (*TypeID) 323193323Sed return; 324198090Srdivacky 325224145Sdim // If it is a non-anonymous struct, mark the type as being visited so that we 326224145Sdim // don't recursively visit it. This is safe because we allow forward 327224145Sdim // references of these in the bitcode reader. 328224145Sdim if (const StructType *STy = dyn_cast<StructType>(Ty)) 329224145Sdim if (!STy->isAnonymous()) 330224145Sdim *TypeID = ~0U; 331224145Sdim 332224145Sdim // Enumerate all of the subtypes before we enumerate this type. This ensures 333224145Sdim // that the type will be enumerated in an order that can be directly built. 334193323Sed for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); 335193323Sed I != E; ++I) 336193323Sed EnumerateType(*I); 337224145Sdim 338224145Sdim // Refresh the TypeID pointer in case the table rehashed. 339224145Sdim TypeID = &TypeMap[Ty]; 340224145Sdim 341224145Sdim // Check to see if we got the pointer another way. This can happen when 342224145Sdim // enumerating recursive types that hit the base case deeper than they start. 343224145Sdim // 344224145Sdim // If this is actually a struct that we are treating as forward ref'able, 345224145Sdim // then emit the definition now that all of its contents are available. 346224145Sdim if (*TypeID && *TypeID != ~0U) 347224145Sdim return; 348224145Sdim 349224145Sdim // Add this type now that its contents are all happily enumerated. 350224145Sdim Types.push_back(Ty); 351224145Sdim 352224145Sdim *TypeID = Types.size(); 353193323Sed} 354193323Sed 355193323Sed// Enumerate the types for the specified value. If the value is a constant, 356193323Sed// walk through it, enumerating the types of the constant. 357193323Sedvoid ValueEnumerator::EnumerateOperandType(const Value *V) { 358193323Sed EnumerateType(V->getType()); 359202375Srdivacky 360193323Sed if (const Constant *C = dyn_cast<Constant>(V)) { 361193323Sed // If this constant is already enumerated, ignore it, we know its type must 362193323Sed // be enumerated. 363193323Sed if (ValueMap.count(V)) return; 364193323Sed 365193323Sed // This constant may have operands, make sure to enumerate the types in 366193323Sed // them. 367198892Srdivacky for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 368221345Sdim const Value *Op = C->getOperand(i); 369198892Srdivacky 370198892Srdivacky // Don't enumerate basic blocks here, this happens as operands to 371198892Srdivacky // blockaddress. 372198892Srdivacky if (isa<BasicBlock>(Op)) continue; 373198892Srdivacky 374212904Sdim EnumerateOperandType(Op); 375198892Srdivacky } 376193323Sed 377193323Sed if (const MDNode *N = dyn_cast<MDNode>(V)) { 378201360Srdivacky for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 379201360Srdivacky if (Value *Elem = N->getOperand(i)) 380198090Srdivacky EnumerateOperandType(Elem); 381193323Sed } 382198090Srdivacky } else if (isa<MDString>(V) || isa<MDNode>(V)) 383212904Sdim EnumerateMetadata(V); 384193323Sed} 385193323Sed 386193323Sedvoid ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) { 387193323Sed if (PAL.isEmpty()) return; // null is always 0. 388193323Sed // Do a lookup. 389193323Sed unsigned &Entry = AttributeMap[PAL.getRawPointer()]; 390193323Sed if (Entry == 0) { 391193323Sed // Never saw this before, add it. 392193323Sed Attributes.push_back(PAL); 393193323Sed Entry = Attributes.size(); 394193323Sed } 395193323Sed} 396193323Sed 397193323Sedvoid ValueEnumerator::incorporateFunction(const Function &F) { 398204642Srdivacky InstructionCount = 0; 399193323Sed NumModuleValues = Values.size(); 400212904Sdim NumModuleMDValues = MDValues.size(); 401198090Srdivacky 402193323Sed // Adding function arguments to the value table. 403212904Sdim for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); 404212904Sdim I != E; ++I) 405193323Sed EnumerateValue(I); 406193323Sed 407193323Sed FirstFuncConstantID = Values.size(); 408198090Srdivacky 409193323Sed // Add all function-level constants to the value table. 410193323Sed for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 411193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) 412198090Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 413193323Sed OI != E; ++OI) { 414193323Sed if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || 415193323Sed isa<InlineAsm>(*OI)) 416193323Sed EnumerateValue(*OI); 417193323Sed } 418193323Sed BasicBlocks.push_back(BB); 419193323Sed ValueMap[BB] = BasicBlocks.size(); 420193323Sed } 421198090Srdivacky 422193323Sed // Optimize the constant layout. 423193323Sed OptimizeConstants(FirstFuncConstantID, Values.size()); 424198090Srdivacky 425193323Sed // Add the function's parameter attributes so they are available for use in 426193323Sed // the function's instruction. 427193323Sed EnumerateAttributes(F.getAttributes()); 428193323Sed 429193323Sed FirstInstID = Values.size(); 430198090Srdivacky 431210299Sed SmallVector<MDNode *, 8> FnLocalMDVector; 432193323Sed // Add all of the instructions. 433193323Sed for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 434193323Sed for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 435202375Srdivacky for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 436202375Srdivacky OI != E; ++OI) { 437202375Srdivacky if (MDNode *MD = dyn_cast<MDNode>(*OI)) 438203954Srdivacky if (MD->isFunctionLocal() && MD->getFunction()) 439203954Srdivacky // Enumerate metadata after the instructions they might refer to. 440210299Sed FnLocalMDVector.push_back(MD); 441202375Srdivacky } 442212904Sdim 443212904Sdim SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 444212904Sdim I->getAllMetadataOtherThanDebugLoc(MDs); 445212904Sdim for (unsigned i = 0, e = MDs.size(); i != e; ++i) { 446212904Sdim MDNode *N = MDs[i].second; 447212904Sdim if (N->isFunctionLocal() && N->getFunction()) 448212904Sdim FnLocalMDVector.push_back(N); 449212904Sdim } 450212904Sdim 451202375Srdivacky if (!I->getType()->isVoidTy()) 452193323Sed EnumerateValue(I); 453193323Sed } 454193323Sed } 455203954Srdivacky 456203954Srdivacky // Add all of the function-local metadata. 457210299Sed for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i) 458212904Sdim EnumerateFunctionLocalMetadata(FnLocalMDVector[i]); 459193323Sed} 460193323Sed 461193323Sedvoid ValueEnumerator::purgeFunction() { 462193323Sed /// Remove purged values from the ValueMap. 463193323Sed for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i) 464193323Sed ValueMap.erase(Values[i].first); 465212904Sdim for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i) 466212904Sdim MDValueMap.erase(MDValues[i].first); 467193323Sed for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) 468193323Sed ValueMap.erase(BasicBlocks[i]); 469198090Srdivacky 470193323Sed Values.resize(NumModuleValues); 471212904Sdim MDValues.resize(NumModuleMDValues); 472193323Sed BasicBlocks.clear(); 473212904Sdim FunctionLocalMDs.clear(); 474193323Sed} 475198892Srdivacky 476198892Srdivackystatic void IncorporateFunctionInfoGlobalBBIDs(const Function *F, 477198892Srdivacky DenseMap<const BasicBlock*, unsigned> &IDMap) { 478198892Srdivacky unsigned Counter = 0; 479198892Srdivacky for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 480198892Srdivacky IDMap[BB] = ++Counter; 481198892Srdivacky} 482198892Srdivacky 483198892Srdivacky/// getGlobalBasicBlockID - This returns the function-specific ID for the 484198892Srdivacky/// specified basic block. This is relatively expensive information, so it 485198892Srdivacky/// should only be used by rare constructs such as address-of-label. 486198892Srdivackyunsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const { 487198892Srdivacky unsigned &Idx = GlobalBasicBlockIDs[BB]; 488198892Srdivacky if (Idx != 0) 489198892Srdivacky return Idx-1; 490198892Srdivacky 491198892Srdivacky IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs); 492198892Srdivacky return getGlobalBasicBlockID(BB); 493198892Srdivacky} 494198892Srdivacky 495