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