ValueEnumerator.cpp revision 9937d116e09feb32d46a4c76eca1be6afcd3bed5
19b044ec938fd56355012851890c63974c8042c9fStephen Hines//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===// 29b044ec938fd56355012851890c63974c8042c9fStephen Hines// 39b044ec938fd56355012851890c63974c8042c9fStephen Hines// The LLVM Compiler Infrastructure 49b044ec938fd56355012851890c63974c8042c9fStephen Hines// 59b044ec938fd56355012851890c63974c8042c9fStephen Hines// This file is distributed under the University of Illinois Open Source 69b044ec938fd56355012851890c63974c8042c9fStephen Hines// License. See LICENSE.TXT for details. 79b044ec938fd56355012851890c63974c8042c9fStephen Hines// 89b044ec938fd56355012851890c63974c8042c9fStephen Hines//===----------------------------------------------------------------------===// 99b044ec938fd56355012851890c63974c8042c9fStephen Hines// 109b044ec938fd56355012851890c63974c8042c9fStephen Hines// This file implements the ValueEnumerator class. 119b044ec938fd56355012851890c63974c8042c9fStephen Hines// 129b044ec938fd56355012851890c63974c8042c9fStephen Hines//===----------------------------------------------------------------------===// 139b044ec938fd56355012851890c63974c8042c9fStephen Hines 149b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "ValueEnumerator.h" 159b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/ADT/SmallPtrSet.h" 169b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/ADT/STLExtras.h" 179b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/Constants.h" 189b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/DerivedTypes.h" 199b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/Module.h" 209b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/ValueSymbolTable.h" 219b044ec938fd56355012851890c63974c8042c9fStephen Hines#include "llvm/Instructions.h" 229b044ec938fd56355012851890c63974c8042c9fStephen Hines#include <algorithm> 239b044ec938fd56355012851890c63974c8042c9fStephen Hinesusing namespace llvm; 249b044ec938fd56355012851890c63974c8042c9fStephen Hines 259937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hinesnamespace llvm_2_9_func { 269937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hines 279b044ec938fd56355012851890c63974c8042c9fStephen Hinesstatic bool isIntegerValue(const std::pair<const Value*, unsigned> &V) { 289b044ec938fd56355012851890c63974c8042c9fStephen Hines return V.first->getType()->isIntegerTy(); 299b044ec938fd56355012851890c63974c8042c9fStephen Hines} 309b044ec938fd56355012851890c63974c8042c9fStephen Hines 319b044ec938fd56355012851890c63974c8042c9fStephen Hines/// ValueEnumerator - Enumerate module-level information. 329b044ec938fd56355012851890c63974c8042c9fStephen HinesValueEnumerator::ValueEnumerator(const Module *M) { 339b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the global variables. 349b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_global_iterator I = M->global_begin(), 359b044ec938fd56355012851890c63974c8042c9fStephen Hines E = M->global_end(); I != E; ++I) 369b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 379b044ec938fd56355012851890c63974c8042c9fStephen Hines 389b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the functions. 399b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { 409b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 419b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(cast<Function>(I)->getAttributes()); 429b044ec938fd56355012851890c63974c8042c9fStephen Hines } 439b044ec938fd56355012851890c63974c8042c9fStephen Hines 449b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the aliases. 459b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 469b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 479b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 489b044ec938fd56355012851890c63974c8042c9fStephen Hines 499b044ec938fd56355012851890c63974c8042c9fStephen Hines // Remember what is the cutoff between globalvalue's and other constants. 509b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned FirstConstant = Values.size(); 519b044ec938fd56355012851890c63974c8042c9fStephen Hines 529b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the global variable initializers. 539b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_global_iterator I = M->global_begin(), 549b044ec938fd56355012851890c63974c8042c9fStephen Hines E = M->global_end(); I != E; ++I) 559b044ec938fd56355012851890c63974c8042c9fStephen Hines if (I->hasInitializer()) 569b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I->getInitializer()); 579b044ec938fd56355012851890c63974c8042c9fStephen Hines 589b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the aliasees. 599b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); 609b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 619b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I->getAliasee()); 629b044ec938fd56355012851890c63974c8042c9fStephen Hines 639b044ec938fd56355012851890c63974c8042c9fStephen Hines // Insert constants and metadata that are named at module level into the slot 649b044ec938fd56355012851890c63974c8042c9fStephen Hines // pool so that the module symbol table can refer to them... 659b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValueSymbolTable(M->getValueSymbolTable()); 669b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateNamedMetadata(M); 679b044ec938fd56355012851890c63974c8042c9fStephen Hines 689b044ec938fd56355012851890c63974c8042c9fStephen Hines SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 699b044ec938fd56355012851890c63974c8042c9fStephen Hines 709b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate types used by function bodies and argument lists. 719b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) { 729b044ec938fd56355012851890c63974c8042c9fStephen Hines 739b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); 749b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 759b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(I->getType()); 769b044ec938fd56355012851890c63974c8042c9fStephen Hines 779b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 789b044ec938fd56355012851890c63974c8042c9fStephen Hines for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){ 799b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 809b044ec938fd56355012851890c63974c8042c9fStephen Hines OI != E; ++OI) { 819b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MDNode *MD = dyn_cast<MDNode>(*OI)) 829b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MD->isFunctionLocal() && MD->getFunction()) 839b044ec938fd56355012851890c63974c8042c9fStephen Hines // These will get enumerated during function-incorporation. 849b044ec938fd56355012851890c63974c8042c9fStephen Hines continue; 859b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateOperandType(*OI); 869b044ec938fd56355012851890c63974c8042c9fStephen Hines } 879b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(I->getType()); 889b044ec938fd56355012851890c63974c8042c9fStephen Hines if (const CallInst *CI = dyn_cast<CallInst>(I)) 899b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(CI->getAttributes()); 909b044ec938fd56355012851890c63974c8042c9fStephen Hines else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) 919b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(II->getAttributes()); 929b044ec938fd56355012851890c63974c8042c9fStephen Hines 939b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate metadata attached with this instruction. 949b044ec938fd56355012851890c63974c8042c9fStephen Hines MDs.clear(); 959b044ec938fd56355012851890c63974c8042c9fStephen Hines I->getAllMetadataOtherThanDebugLoc(MDs); 969b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = MDs.size(); i != e; ++i) 979b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(MDs[i].second); 989b044ec938fd56355012851890c63974c8042c9fStephen Hines 999b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!I->getDebugLoc().isUnknown()) { 1009b044ec938fd56355012851890c63974c8042c9fStephen Hines MDNode *Scope, *IA; 1019b044ec938fd56355012851890c63974c8042c9fStephen Hines I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext()); 1029b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Scope) EnumerateMetadata(Scope); 1039b044ec938fd56355012851890c63974c8042c9fStephen Hines if (IA) EnumerateMetadata(IA); 1049b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1059b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1069b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1079b044ec938fd56355012851890c63974c8042c9fStephen Hines 1089b044ec938fd56355012851890c63974c8042c9fStephen Hines // Optimize constant ordering. 1099b044ec938fd56355012851890c63974c8042c9fStephen Hines OptimizeConstants(FirstConstant, Values.size()); 1109b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1119b044ec938fd56355012851890c63974c8042c9fStephen Hines 1129b044ec938fd56355012851890c63974c8042c9fStephen Hines 1139b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { 1149b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionMapType::const_iterator I = InstructionMap.find(Inst); 1159b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(I != InstructionMap.end() && "Instruction is not mapped!"); 1169b044ec938fd56355012851890c63974c8042c9fStephen Hines return I->second; 1179b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1189b044ec938fd56355012851890c63974c8042c9fStephen Hines 1199b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::setInstructionID(const Instruction *I) { 1209b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionMap[I] = InstructionCount++; 1219b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1229b044ec938fd56355012851890c63974c8042c9fStephen Hines 1239b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getValueID(const Value *V) const { 1249b044ec938fd56355012851890c63974c8042c9fStephen Hines if (isa<MDNode>(V) || isa<MDString>(V)) { 1259b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMapType::const_iterator I = MDValueMap.find(V); 1269b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(I != MDValueMap.end() && "Value not in slotcalculator!"); 1279b044ec938fd56355012851890c63974c8042c9fStephen Hines return I->second-1; 1289b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1299b044ec938fd56355012851890c63974c8042c9fStephen Hines 1309b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMapType::const_iterator I = ValueMap.find(V); 1319b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(I != ValueMap.end() && "Value not in slotcalculator!"); 1329b044ec938fd56355012851890c63974c8042c9fStephen Hines return I->second-1; 1339b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1349b044ec938fd56355012851890c63974c8042c9fStephen Hines 1359b044ec938fd56355012851890c63974c8042c9fStephen Hines// Optimize constant ordering. 1369b044ec938fd56355012851890c63974c8042c9fStephen Hinesnamespace { 1379b044ec938fd56355012851890c63974c8042c9fStephen Hines struct CstSortPredicate { 1389b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueEnumerator &VE; 1399b044ec938fd56355012851890c63974c8042c9fStephen Hines explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {} 1409b044ec938fd56355012851890c63974c8042c9fStephen Hines bool operator()(const std::pair<const Value*, unsigned> &LHS, 1419b044ec938fd56355012851890c63974c8042c9fStephen Hines const std::pair<const Value*, unsigned> &RHS) { 1429b044ec938fd56355012851890c63974c8042c9fStephen Hines // Sort by plane. 1439b044ec938fd56355012851890c63974c8042c9fStephen Hines if (LHS.first->getType() != RHS.first->getType()) 1449b044ec938fd56355012851890c63974c8042c9fStephen Hines return VE.getTypeID(LHS.first->getType()) < 1459b044ec938fd56355012851890c63974c8042c9fStephen Hines VE.getTypeID(RHS.first->getType()); 1469b044ec938fd56355012851890c63974c8042c9fStephen Hines // Then by frequency. 1479b044ec938fd56355012851890c63974c8042c9fStephen Hines return LHS.second > RHS.second; 1489b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1499b044ec938fd56355012851890c63974c8042c9fStephen Hines }; 1509b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1519b044ec938fd56355012851890c63974c8042c9fStephen Hines 1529b044ec938fd56355012851890c63974c8042c9fStephen Hines/// OptimizeConstants - Reorder constant pool for denser encoding. 1539b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { 1549b044ec938fd56355012851890c63974c8042c9fStephen Hines if (CstStart == CstEnd || CstStart+1 == CstEnd) return; 1559b044ec938fd56355012851890c63974c8042c9fStephen Hines 1569b044ec938fd56355012851890c63974c8042c9fStephen Hines CstSortPredicate P(*this); 1579b044ec938fd56355012851890c63974c8042c9fStephen Hines std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P); 1589b044ec938fd56355012851890c63974c8042c9fStephen Hines 1599b044ec938fd56355012851890c63974c8042c9fStephen Hines // Ensure that integer constants are at the start of the constant pool. This 1609b044ec938fd56355012851890c63974c8042c9fStephen Hines // is important so that GEP structure indices come before gep constant exprs. 1619b044ec938fd56355012851890c63974c8042c9fStephen Hines std::partition(Values.begin()+CstStart, Values.begin()+CstEnd, 1629b044ec938fd56355012851890c63974c8042c9fStephen Hines isIntegerValue); 1639b044ec938fd56355012851890c63974c8042c9fStephen Hines 1649b044ec938fd56355012851890c63974c8042c9fStephen Hines // Rebuild the modified portion of ValueMap. 1659b044ec938fd56355012851890c63974c8042c9fStephen Hines for (; CstStart != CstEnd; ++CstStart) 1669b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap[Values[CstStart].first] = CstStart+1; 1679b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1689b044ec938fd56355012851890c63974c8042c9fStephen Hines 1699b044ec938fd56355012851890c63974c8042c9fStephen Hines 1709b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol 1719b044ec938fd56355012851890c63974c8042c9fStephen Hines/// table into the values table. 1729b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { 1739b044ec938fd56355012851890c63974c8042c9fStephen Hines for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); 1749b044ec938fd56355012851890c63974c8042c9fStephen Hines VI != VE; ++VI) 1759b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(VI->getValue()); 1769b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1779b044ec938fd56355012851890c63974c8042c9fStephen Hines 1789b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateNamedMetadata - Insert all of the values referenced by 1799b044ec938fd56355012851890c63974c8042c9fStephen Hines/// named metadata in the specified module. 1809b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateNamedMetadata(const Module *M) { 1819b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Module::const_named_metadata_iterator I = M->named_metadata_begin(), 1829b044ec938fd56355012851890c63974c8042c9fStephen Hines E = M->named_metadata_end(); I != E; ++I) 1839b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateNamedMDNode(I); 1849b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1859b044ec938fd56355012851890c63974c8042c9fStephen Hines 1869b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) { 1879b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) 1889b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(MD->getOperand(i)); 1899b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1909b044ec938fd56355012851890c63974c8042c9fStephen Hines 1919b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateMDNodeOperands - Enumerate all non-function-local values 1929b044ec938fd56355012851890c63974c8042c9fStephen Hines/// and types referenced by the given MDNode. 1939b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) { 1949b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 1959b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Value *V = N->getOperand(i)) { 1969b044ec938fd56355012851890c63974c8042c9fStephen Hines if (isa<MDNode>(V) || isa<MDString>(V)) 1979b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(V); 1989b044ec938fd56355012851890c63974c8042c9fStephen Hines else if (!isa<Instruction>(V) && !isa<Argument>(V)) 1999b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(V); 2009b044ec938fd56355012851890c63974c8042c9fStephen Hines } else 2019b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(Type::getVoidTy(N->getContext())); 2029b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2039b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2049b044ec938fd56355012851890c63974c8042c9fStephen Hines 2059b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateMetadata(const Value *MD) { 2069b044ec938fd56355012851890c63974c8042c9fStephen Hines assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind"); 2079b044ec938fd56355012851890c63974c8042c9fStephen Hines 2089b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the type of this value. 2099b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(MD->getType()); 2109b044ec938fd56355012851890c63974c8042c9fStephen Hines 2119b044ec938fd56355012851890c63974c8042c9fStephen Hines const MDNode *N = dyn_cast<MDNode>(MD); 2129b044ec938fd56355012851890c63974c8042c9fStephen Hines 2139b044ec938fd56355012851890c63974c8042c9fStephen Hines // In the module-level pass, skip function-local nodes themselves, but 2149b044ec938fd56355012851890c63974c8042c9fStephen Hines // do walk their operands. 2159b044ec938fd56355012851890c63974c8042c9fStephen Hines if (N && N->isFunctionLocal() && N->getFunction()) { 2169b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMDNodeOperands(N); 2179b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 2189b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2199b044ec938fd56355012851890c63974c8042c9fStephen Hines 2209b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if it's already in! 2219b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &MDValueID = MDValueMap[MD]; 2229b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MDValueID) { 2239b044ec938fd56355012851890c63974c8042c9fStephen Hines // Increment use count. 2249b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValues[MDValueID-1].second++; 2259b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 2269b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2279b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValues.push_back(std::make_pair(MD, 1U)); 2289b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValueID = MDValues.size(); 2299b044ec938fd56355012851890c63974c8042c9fStephen Hines 2309b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate all non-function-local operands. 2319b044ec938fd56355012851890c63974c8042c9fStephen Hines if (N) 2329b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMDNodeOperands(N); 2339b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2349b044ec938fd56355012851890c63974c8042c9fStephen Hines 2359b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata 2369b044ec938fd56355012851890c63974c8042c9fStephen Hines/// information reachable from the given MDNode. 2379b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) { 2389b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(N->isFunctionLocal() && N->getFunction() && 2399b044ec938fd56355012851890c63974c8042c9fStephen Hines "EnumerateFunctionLocalMetadata called on non-function-local mdnode!"); 2409b044ec938fd56355012851890c63974c8042c9fStephen Hines 2419b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the type of this value. 2429b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(N->getType()); 2439b044ec938fd56355012851890c63974c8042c9fStephen Hines 2449b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if it's already in! 2459b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &MDValueID = MDValueMap[N]; 2469b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MDValueID) { 2479b044ec938fd56355012851890c63974c8042c9fStephen Hines // Increment use count. 2489b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValues[MDValueID-1].second++; 2499b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 2509b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2519b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValues.push_back(std::make_pair(N, 1U)); 2529b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValueID = MDValues.size(); 2539b044ec938fd56355012851890c63974c8042c9fStephen Hines 2549b044ec938fd56355012851890c63974c8042c9fStephen Hines // To incoroporate function-local information visit all function-local 2559b044ec938fd56355012851890c63974c8042c9fStephen Hines // MDNodes and all function-local values they reference. 2569b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 2579b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Value *V = N->getOperand(i)) { 2589b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MDNode *O = dyn_cast<MDNode>(V)) { 2599b044ec938fd56355012851890c63974c8042c9fStephen Hines if (O->isFunctionLocal() && O->getFunction()) 2609b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateFunctionLocalMetadata(O); 2619b044ec938fd56355012851890c63974c8042c9fStephen Hines } else if (isa<Instruction>(V) || isa<Argument>(V)) 2629b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(V); 2639b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2649b044ec938fd56355012851890c63974c8042c9fStephen Hines 2659b044ec938fd56355012851890c63974c8042c9fStephen Hines // Also, collect all function-local MDNodes for easy access. 2669b044ec938fd56355012851890c63974c8042c9fStephen Hines FunctionLocalMDs.push_back(N); 2679b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2689b044ec938fd56355012851890c63974c8042c9fStephen Hines 2699b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateValue(const Value *V) { 2709b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(!V->getType()->isVoidTy() && "Can't insert void values!"); 2719b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(!isa<MDNode>(V) && !isa<MDString>(V) && 2729b044ec938fd56355012851890c63974c8042c9fStephen Hines "EnumerateValue doesn't handle Metadata!"); 2739b044ec938fd56355012851890c63974c8042c9fStephen Hines 2749b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if it's already in! 2759b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &ValueID = ValueMap[V]; 2769b044ec938fd56355012851890c63974c8042c9fStephen Hines if (ValueID) { 2779b044ec938fd56355012851890c63974c8042c9fStephen Hines // Increment use count. 2789b044ec938fd56355012851890c63974c8042c9fStephen Hines Values[ValueID-1].second++; 2799b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 2809b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2819b044ec938fd56355012851890c63974c8042c9fStephen Hines 2829b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the type of this value. 2839b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(V->getType()); 2849b044ec938fd56355012851890c63974c8042c9fStephen Hines 2859b044ec938fd56355012851890c63974c8042c9fStephen Hines if (const Constant *C = dyn_cast<Constant>(V)) { 2869b044ec938fd56355012851890c63974c8042c9fStephen Hines if (isa<GlobalValue>(C)) { 2879b044ec938fd56355012851890c63974c8042c9fStephen Hines // Initializers for globals are handled explicitly elsewhere. 2880444de0c0e7cfc8d8f8fed6f64cd97812bdd6a41Stephen Hines //} else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) { 2899b044ec938fd56355012851890c63974c8042c9fStephen Hines // Do not enumerate the initializers for an array of simple characters. 2909b044ec938fd56355012851890c63974c8042c9fStephen Hines // The initializers just pollute the value table, and we emit the strings 2919b044ec938fd56355012851890c63974c8042c9fStephen Hines // specially. 2929b044ec938fd56355012851890c63974c8042c9fStephen Hines } else if (C->getNumOperands()) { 2939b044ec938fd56355012851890c63974c8042c9fStephen Hines // If a constant has operands, enumerate them. This makes sure that if a 2949b044ec938fd56355012851890c63974c8042c9fStephen Hines // constant has uses (for example an array of const ints), that they are 2959b044ec938fd56355012851890c63974c8042c9fStephen Hines // inserted also. 2969b044ec938fd56355012851890c63974c8042c9fStephen Hines 2979b044ec938fd56355012851890c63974c8042c9fStephen Hines // We prefer to enumerate them with values before we enumerate the user 2989b044ec938fd56355012851890c63974c8042c9fStephen Hines // itself. This makes it more likely that we can avoid forward references 2999b044ec938fd56355012851890c63974c8042c9fStephen Hines // in the reader. We know that there can be no cycles in the constants 3009b044ec938fd56355012851890c63974c8042c9fStephen Hines // graph that don't go through a global variable. 3019b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator I = C->op_begin(), E = C->op_end(); 3029b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 3039b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress. 3049b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(*I); 3059b044ec938fd56355012851890c63974c8042c9fStephen Hines 3069b044ec938fd56355012851890c63974c8042c9fStephen Hines // Finally, add the value. Doing this could make the ValueID reference be 3079b044ec938fd56355012851890c63974c8042c9fStephen Hines // dangling, don't reuse it. 3089b044ec938fd56355012851890c63974c8042c9fStephen Hines Values.push_back(std::make_pair(V, 1U)); 3099b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap[V] = Values.size(); 3109b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 3119b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3129b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3139b044ec938fd56355012851890c63974c8042c9fStephen Hines 3149b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add the value. 3159b044ec938fd56355012851890c63974c8042c9fStephen Hines Values.push_back(std::make_pair(V, 1U)); 3169b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueID = Values.size(); 3179b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3189b044ec938fd56355012851890c63974c8042c9fStephen Hines 3199b044ec938fd56355012851890c63974c8042c9fStephen Hines 3209b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateType(Type *Ty) { 3219b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned *TypeID = &TypeMap[Ty]; 3229b044ec938fd56355012851890c63974c8042c9fStephen Hines 3239b044ec938fd56355012851890c63974c8042c9fStephen Hines // We've already seen this type. 3249b044ec938fd56355012851890c63974c8042c9fStephen Hines if (*TypeID) 3259b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 3269b044ec938fd56355012851890c63974c8042c9fStephen Hines 3279b044ec938fd56355012851890c63974c8042c9fStephen Hines // If it is a non-anonymous struct, mark the type as being visited so that we 3289b044ec938fd56355012851890c63974c8042c9fStephen Hines // don't recursively visit it. This is safe because we allow forward 3299b044ec938fd56355012851890c63974c8042c9fStephen Hines // references of these in the bitcode reader. 3309b044ec938fd56355012851890c63974c8042c9fStephen Hines if (StructType *STy = dyn_cast<StructType>(Ty)) 3319b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!STy->isLiteral()) 3329b044ec938fd56355012851890c63974c8042c9fStephen Hines *TypeID = ~0U; 3339b044ec938fd56355012851890c63974c8042c9fStephen Hines 3349b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate all of the subtypes before we enumerate this type. This ensures 3359b044ec938fd56355012851890c63974c8042c9fStephen Hines // that the type will be enumerated in an order that can be directly built. 3369b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end(); 3379b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 3389b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(*I); 3399b044ec938fd56355012851890c63974c8042c9fStephen Hines 3409b044ec938fd56355012851890c63974c8042c9fStephen Hines // Refresh the TypeID pointer in case the table rehashed. 3419b044ec938fd56355012851890c63974c8042c9fStephen Hines TypeID = &TypeMap[Ty]; 3429b044ec938fd56355012851890c63974c8042c9fStephen Hines 3439b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if we got the pointer another way. This can happen when 3449b044ec938fd56355012851890c63974c8042c9fStephen Hines // enumerating recursive types that hit the base case deeper than they start. 3459b044ec938fd56355012851890c63974c8042c9fStephen Hines // 3469b044ec938fd56355012851890c63974c8042c9fStephen Hines // If this is actually a struct that we are treating as forward ref'able, 3479b044ec938fd56355012851890c63974c8042c9fStephen Hines // then emit the definition now that all of its contents are available. 3489b044ec938fd56355012851890c63974c8042c9fStephen Hines if (*TypeID && *TypeID != ~0U) 3499b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 3509b044ec938fd56355012851890c63974c8042c9fStephen Hines 3519b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add this type now that its contents are all happily enumerated. 3529b044ec938fd56355012851890c63974c8042c9fStephen Hines Types.push_back(Ty); 3539b044ec938fd56355012851890c63974c8042c9fStephen Hines 3549b044ec938fd56355012851890c63974c8042c9fStephen Hines *TypeID = Types.size(); 3559b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3569b044ec938fd56355012851890c63974c8042c9fStephen Hines 3579b044ec938fd56355012851890c63974c8042c9fStephen Hines// Enumerate the types for the specified value. If the value is a constant, 3589b044ec938fd56355012851890c63974c8042c9fStephen Hines// walk through it, enumerating the types of the constant. 3599b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateOperandType(const Value *V) { 3609b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(V->getType()); 3619b044ec938fd56355012851890c63974c8042c9fStephen Hines 3629b044ec938fd56355012851890c63974c8042c9fStephen Hines if (const Constant *C = dyn_cast<Constant>(V)) { 3639b044ec938fd56355012851890c63974c8042c9fStephen Hines // If this constant is already enumerated, ignore it, we know its type must 3649b044ec938fd56355012851890c63974c8042c9fStephen Hines // be enumerated. 3659b044ec938fd56355012851890c63974c8042c9fStephen Hines if (ValueMap.count(V)) return; 3669b044ec938fd56355012851890c63974c8042c9fStephen Hines 3679b044ec938fd56355012851890c63974c8042c9fStephen Hines // This constant may have operands, make sure to enumerate the types in 3689b044ec938fd56355012851890c63974c8042c9fStephen Hines // them. 3699b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 3709b044ec938fd56355012851890c63974c8042c9fStephen Hines const Value *Op = C->getOperand(i); 3719b044ec938fd56355012851890c63974c8042c9fStephen Hines 3729b044ec938fd56355012851890c63974c8042c9fStephen Hines // Don't enumerate basic blocks here, this happens as operands to 3739b044ec938fd56355012851890c63974c8042c9fStephen Hines // blockaddress. 3749b044ec938fd56355012851890c63974c8042c9fStephen Hines if (isa<BasicBlock>(Op)) continue; 3759b044ec938fd56355012851890c63974c8042c9fStephen Hines 3769b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateOperandType(Op); 3779b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3789b044ec938fd56355012851890c63974c8042c9fStephen Hines 3799b044ec938fd56355012851890c63974c8042c9fStephen Hines if (const MDNode *N = dyn_cast<MDNode>(V)) { 3809b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) 3819b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Value *Elem = N->getOperand(i)) 3829b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateOperandType(Elem); 3839b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3849b044ec938fd56355012851890c63974c8042c9fStephen Hines } else if (isa<MDString>(V) || isa<MDNode>(V)) 3859b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(V); 3869b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3879b044ec938fd56355012851890c63974c8042c9fStephen Hines 3889b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) { 3899b044ec938fd56355012851890c63974c8042c9fStephen Hines if (PAL.isEmpty()) return; // null is always 0. 3909b044ec938fd56355012851890c63974c8042c9fStephen Hines // Do a lookup. 3919b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &Entry = AttributeMap[PAL.getRawPointer()]; 3929b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Entry == 0) { 3939b044ec938fd56355012851890c63974c8042c9fStephen Hines // Never saw this before, add it. 3949b044ec938fd56355012851890c63974c8042c9fStephen Hines Attributes.push_back(PAL); 3959b044ec938fd56355012851890c63974c8042c9fStephen Hines Entry = Attributes.size(); 3969b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3979b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3989b044ec938fd56355012851890c63974c8042c9fStephen Hines 3999b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::incorporateFunction(const Function &F) { 4009b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionCount = 0; 4019b044ec938fd56355012851890c63974c8042c9fStephen Hines NumModuleValues = Values.size(); 4029b044ec938fd56355012851890c63974c8042c9fStephen Hines NumModuleMDValues = MDValues.size(); 4039b044ec938fd56355012851890c63974c8042c9fStephen Hines 4049b044ec938fd56355012851890c63974c8042c9fStephen Hines // Adding function arguments to the value table. 4059b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); 4069b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 4079b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 4089b044ec938fd56355012851890c63974c8042c9fStephen Hines 4099b044ec938fd56355012851890c63974c8042c9fStephen Hines FirstFuncConstantID = Values.size(); 4109b044ec938fd56355012851890c63974c8042c9fStephen Hines 4119b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all function-level constants to the value table. 4129b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 4139b044ec938fd56355012851890c63974c8042c9fStephen Hines for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) 4149b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 4159b044ec938fd56355012851890c63974c8042c9fStephen Hines OI != E; ++OI) { 4169b044ec938fd56355012851890c63974c8042c9fStephen Hines if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || 4179b044ec938fd56355012851890c63974c8042c9fStephen Hines isa<InlineAsm>(*OI)) 4189b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(*OI); 4199b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4209b044ec938fd56355012851890c63974c8042c9fStephen Hines BasicBlocks.push_back(BB); 4219b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap[BB] = BasicBlocks.size(); 4229b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4239b044ec938fd56355012851890c63974c8042c9fStephen Hines 4249b044ec938fd56355012851890c63974c8042c9fStephen Hines // Optimize the constant layout. 4259b044ec938fd56355012851890c63974c8042c9fStephen Hines OptimizeConstants(FirstFuncConstantID, Values.size()); 4269b044ec938fd56355012851890c63974c8042c9fStephen Hines 4279b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add the function's parameter attributes so they are available for use in 4289b044ec938fd56355012851890c63974c8042c9fStephen Hines // the function's instruction. 4299b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(F.getAttributes()); 4309b044ec938fd56355012851890c63974c8042c9fStephen Hines 4319b044ec938fd56355012851890c63974c8042c9fStephen Hines FirstInstID = Values.size(); 4329b044ec938fd56355012851890c63974c8042c9fStephen Hines 4339b044ec938fd56355012851890c63974c8042c9fStephen Hines SmallVector<MDNode *, 8> FnLocalMDVector; 4349b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all of the instructions. 4359b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 4369b044ec938fd56355012851890c63974c8042c9fStephen Hines for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 4379b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 4389b044ec938fd56355012851890c63974c8042c9fStephen Hines OI != E; ++OI) { 4399b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MDNode *MD = dyn_cast<MDNode>(*OI)) 4409b044ec938fd56355012851890c63974c8042c9fStephen Hines if (MD->isFunctionLocal() && MD->getFunction()) 4419b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate metadata after the instructions they might refer to. 4429b044ec938fd56355012851890c63974c8042c9fStephen Hines FnLocalMDVector.push_back(MD); 4439b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4449b044ec938fd56355012851890c63974c8042c9fStephen Hines 4459b044ec938fd56355012851890c63974c8042c9fStephen Hines SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; 4469b044ec938fd56355012851890c63974c8042c9fStephen Hines I->getAllMetadataOtherThanDebugLoc(MDs); 4479b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = MDs.size(); i != e; ++i) { 4489b044ec938fd56355012851890c63974c8042c9fStephen Hines MDNode *N = MDs[i].second; 4499b044ec938fd56355012851890c63974c8042c9fStephen Hines if (N->isFunctionLocal() && N->getFunction()) 4509b044ec938fd56355012851890c63974c8042c9fStephen Hines FnLocalMDVector.push_back(N); 4519b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4529b044ec938fd56355012851890c63974c8042c9fStephen Hines 4539b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!I->getType()->isVoidTy()) 4549b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 4559b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4569b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4579b044ec938fd56355012851890c63974c8042c9fStephen Hines 4589b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all of the function-local metadata. 4599b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i) 4609b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateFunctionLocalMetadata(FnLocalMDVector[i]); 4619b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4629b044ec938fd56355012851890c63974c8042c9fStephen Hines 4639b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::purgeFunction() { 4649b044ec938fd56355012851890c63974c8042c9fStephen Hines /// Remove purged values from the ValueMap. 4659b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i) 4669b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap.erase(Values[i].first); 4679b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i) 4689b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValueMap.erase(MDValues[i].first); 4699b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) 4709b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap.erase(BasicBlocks[i]); 4719b044ec938fd56355012851890c63974c8042c9fStephen Hines 4729b044ec938fd56355012851890c63974c8042c9fStephen Hines Values.resize(NumModuleValues); 4739b044ec938fd56355012851890c63974c8042c9fStephen Hines MDValues.resize(NumModuleMDValues); 4749b044ec938fd56355012851890c63974c8042c9fStephen Hines BasicBlocks.clear(); 4759b044ec938fd56355012851890c63974c8042c9fStephen Hines FunctionLocalMDs.clear(); 4769b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4779b044ec938fd56355012851890c63974c8042c9fStephen Hines 4789b044ec938fd56355012851890c63974c8042c9fStephen Hinesstatic void IncorporateFunctionInfoGlobalBBIDs(const Function *F, 4799b044ec938fd56355012851890c63974c8042c9fStephen Hines DenseMap<const BasicBlock*, unsigned> &IDMap) { 4809b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned Counter = 0; 4819b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 4829b044ec938fd56355012851890c63974c8042c9fStephen Hines IDMap[BB] = ++Counter; 4839b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4849b044ec938fd56355012851890c63974c8042c9fStephen Hines 4859b044ec938fd56355012851890c63974c8042c9fStephen Hines/// getGlobalBasicBlockID - This returns the function-specific ID for the 4869b044ec938fd56355012851890c63974c8042c9fStephen Hines/// specified basic block. This is relatively expensive information, so it 4879b044ec938fd56355012851890c63974c8042c9fStephen Hines/// should only be used by rare constructs such as address-of-label. 4889b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const { 4899b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &Idx = GlobalBasicBlockIDs[BB]; 4909b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Idx != 0) 4919b044ec938fd56355012851890c63974c8042c9fStephen Hines return Idx-1; 4929b044ec938fd56355012851890c63974c8042c9fStephen Hines 4939b044ec938fd56355012851890c63974c8042c9fStephen Hines IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs); 4949b044ec938fd56355012851890c63974c8042c9fStephen Hines return getGlobalBasicBlockID(BB); 4959b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4969b044ec938fd56355012851890c63974c8042c9fStephen Hines 4979937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hines} // end llvm_2_9_func namespace 498