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