ValueEnumerator.cpp revision c706907a8041faaa882f9bd87f1d1c1669023a62
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/STLExtras.h" 1623c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/ADT/SmallPtrSet.h" 1723c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/IR/Constants.h" 18c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines#include "llvm/IR/DebugInfoMetadata.h" 1923c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/IR/DerivedTypes.h" 2023c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/IR/Instructions.h" 2123c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/IR/Module.h" 2223c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines#include "llvm/IR/ValueSymbolTable.h" 23a44912f8876b6f830a4829286c27ef90c763469eStephen Hines#include "llvm/Support/Debug.h" 24a44912f8876b6f830a4829286c27ef90c763469eStephen Hines#include "llvm/Support/raw_ostream.h" 259b044ec938fd56355012851890c63974c8042c9fStephen Hines#include <algorithm> 269b044ec938fd56355012851890c63974c8042c9fStephen Hinesusing namespace llvm; 279b044ec938fd56355012851890c63974c8042c9fStephen Hines 289937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hinesnamespace llvm_2_9_func { 299937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hines 300da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hinesstatic bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) { 310da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines return V.first->getType()->isIntOrIntVectorTy(); 329b044ec938fd56355012851890c63974c8042c9fStephen Hines} 339b044ec938fd56355012851890c63974c8042c9fStephen Hines 349b044ec938fd56355012851890c63974c8042c9fStephen Hines/// ValueEnumerator - Enumerate module-level information. 35c706907a8041faaa882f9bd87f1d1c1669023a62Stephen HinesValueEnumerator::ValueEnumerator(const llvm::Module &M) 36c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines : HasMDString(false), HasMDLocation(false) { 379b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the global variables. 38c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 39c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines I != E; ++I) 409b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 419b044ec938fd56355012851890c63974c8042c9fStephen Hines 429b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the functions. 43c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 449b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 459b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(cast<Function>(I)->getAttributes()); 469b044ec938fd56355012851890c63974c8042c9fStephen Hines } 479b044ec938fd56355012851890c63974c8042c9fStephen Hines 489b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the aliases. 49c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 509b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 519b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 529b044ec938fd56355012851890c63974c8042c9fStephen Hines 539b044ec938fd56355012851890c63974c8042c9fStephen Hines // Remember what is the cutoff between globalvalue's and other constants. 549b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned FirstConstant = Values.size(); 559b044ec938fd56355012851890c63974c8042c9fStephen Hines 569b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the global variable initializers. 57c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 58c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines I != E; ++I) 599b044ec938fd56355012851890c63974c8042c9fStephen Hines if (I->hasInitializer()) 609b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I->getInitializer()); 619b044ec938fd56355012851890c63974c8042c9fStephen Hines 629b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate the aliasees. 63c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 649b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 659b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I->getAliasee()); 669b044ec938fd56355012851890c63974c8042c9fStephen Hines 67c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Enumerate the metadata type. 68c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // 69c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // TODO: Move this to ValueEnumerator::EnumerateOperandType() once bitcode 70c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // only encodes the metadata type when it's used as a value. 71c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateType(Type::getMetadataTy(M.getContext())); 72c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 73c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Insert constants and metadata that are named at module level into the slot 749b044ec938fd56355012851890c63974c8042c9fStephen Hines // pool so that the module symbol table can refer to them... 75c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateValueSymbolTable(M.getValueSymbolTable()); 769b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateNamedMetadata(M); 779b044ec938fd56355012851890c63974c8042c9fStephen Hines 78c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines SmallVector<std::pair<unsigned, MDNode *>, 8> MDs; 799b044ec938fd56355012851890c63974c8042c9fStephen Hines 809b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate types used by function bodies and argument lists. 81c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const Function &F : M) { 82c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const Argument &A : F.args()) 83c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateType(A.getType()); 84c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 85c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const BasicBlock &BB : F) 86c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const Instruction &I : BB) { 87c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const Use &Op : I.operands()) { 88c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines auto *MD = dyn_cast<MetadataAsValue>(&Op); 89c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (!MD) { 90c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateOperandType(Op); 91c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines continue; 92c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines } 93c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 94c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Local metadata is enumerated during function-incorporation. 95c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (isa<LocalAsMetadata>(MD->getMetadata())) 96c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines continue; 97c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 98c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateMetadata(MD->getMetadata()); 999b044ec938fd56355012851890c63974c8042c9fStephen Hines } 100c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateType(I.getType()); 101c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (const CallInst *CI = dyn_cast<CallInst>(&I)) 1029b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(CI->getAttributes()); 103c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) 1049b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(II->getAttributes()); 1059b044ec938fd56355012851890c63974c8042c9fStephen Hines 1069b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate metadata attached with this instruction. 1079b044ec938fd56355012851890c63974c8042c9fStephen Hines MDs.clear(); 108c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines I.getAllMetadataOtherThanDebugLoc(MDs); 1099b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = MDs.size(); i != e; ++i) 1109b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(MDs[i].second); 11123c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 112c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (!I.getDebugLoc().isUnknown()) { 1139b044ec938fd56355012851890c63974c8042c9fStephen Hines MDNode *Scope, *IA; 114c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines I.getDebugLoc().getScopeAndInlinedAt(Scope, IA, I.getContext()); 1159b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Scope) EnumerateMetadata(Scope); 1169b044ec938fd56355012851890c63974c8042c9fStephen Hines if (IA) EnumerateMetadata(IA); 1179b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1189b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1199b044ec938fd56355012851890c63974c8042c9fStephen Hines } 1209b044ec938fd56355012851890c63974c8042c9fStephen Hines 1219b044ec938fd56355012851890c63974c8042c9fStephen Hines // Optimize constant ordering. 1229b044ec938fd56355012851890c63974c8042c9fStephen Hines OptimizeConstants(FirstConstant, Values.size()); 1239b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1249b044ec938fd56355012851890c63974c8042c9fStephen Hines 1259b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const { 1269b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionMapType::const_iterator I = InstructionMap.find(Inst); 1279b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(I != InstructionMap.end() && "Instruction is not mapped!"); 1289b044ec938fd56355012851890c63974c8042c9fStephen Hines return I->second; 1299b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1309b044ec938fd56355012851890c63974c8042c9fStephen Hines 1319b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::setInstructionID(const Instruction *I) { 1329b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionMap[I] = InstructionCount++; 1339b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1349b044ec938fd56355012851890c63974c8042c9fStephen Hines 1359b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getValueID(const Value *V) const { 136c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (auto *MD = dyn_cast<MetadataAsValue>(V)) 137c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines return getMetadataID(MD->getMetadata()); 1389b044ec938fd56355012851890c63974c8042c9fStephen Hines 1399b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMapType::const_iterator I = ValueMap.find(V); 1409b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(I != ValueMap.end() && "Value not in slotcalculator!"); 1419b044ec938fd56355012851890c63974c8042c9fStephen Hines return I->second-1; 1429b044ec938fd56355012851890c63974c8042c9fStephen Hines} 1439b044ec938fd56355012851890c63974c8042c9fStephen Hines 144a44912f8876b6f830a4829286c27ef90c763469eStephen Hinesvoid ValueEnumerator::dump() const { 145a44912f8876b6f830a4829286c27ef90c763469eStephen Hines print(dbgs(), ValueMap, "Default"); 146a44912f8876b6f830a4829286c27ef90c763469eStephen Hines dbgs() << '\n'; 147a44912f8876b6f830a4829286c27ef90c763469eStephen Hines print(dbgs(), MDValueMap, "MetaData"); 148a44912f8876b6f830a4829286c27ef90c763469eStephen Hines dbgs() << '\n'; 149a44912f8876b6f830a4829286c27ef90c763469eStephen Hines} 150a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 151a44912f8876b6f830a4829286c27ef90c763469eStephen Hinesvoid ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map, 152a44912f8876b6f830a4829286c27ef90c763469eStephen Hines const char *Name) const { 153a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 154a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << "Map Name: " << Name << "\n"; 155a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << "Size: " << Map.size() << "\n"; 156a44912f8876b6f830a4829286c27ef90c763469eStephen Hines for (ValueMapType::const_iterator I = Map.begin(), 157a44912f8876b6f830a4829286c27ef90c763469eStephen Hines E = Map.end(); I != E; ++I) { 158a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 159a44912f8876b6f830a4829286c27ef90c763469eStephen Hines const Value *V = I->first; 160a44912f8876b6f830a4829286c27ef90c763469eStephen Hines if (V->hasName()) 161a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << "Value: " << V->getName(); 162a44912f8876b6f830a4829286c27ef90c763469eStephen Hines else 163a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << "Value: [null]\n"; 164a44912f8876b6f830a4829286c27ef90c763469eStephen Hines V->dump(); 165a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 166a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << " Uses(" << std::distance(V->use_begin(),V->use_end()) << "):"; 167c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (const Use &U : V->uses()) { 168c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (&U != &*V->use_begin()) 169a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << ","; 170c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if(U->hasName()) 171c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines OS << " " << U->getName(); 172a44912f8876b6f830a4829286c27ef90c763469eStephen Hines else 173a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << " [null]"; 174a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 175a44912f8876b6f830a4829286c27ef90c763469eStephen Hines } 176a44912f8876b6f830a4829286c27ef90c763469eStephen Hines OS << "\n\n"; 177a44912f8876b6f830a4829286c27ef90c763469eStephen Hines } 178a44912f8876b6f830a4829286c27ef90c763469eStephen Hines} 179a44912f8876b6f830a4829286c27ef90c763469eStephen Hines 180c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hinesvoid ValueEnumerator::print(llvm::raw_ostream &OS, const MetadataMapType &Map, 181c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines const char *Name) const { 182c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 183c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines OS << "Map Name: " << Name << "\n"; 184c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines OS << "Size: " << Map.size() << "\n"; 185c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (auto I = Map.begin(), E = Map.end(); I != E; ++I) { 186c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines const llvm::Metadata *MD = I->first; 187c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines OS << "Metadata: slot = " << I->second << "\n"; 188c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MD->print(OS); 189c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines } 190c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines} 191c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 192c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 1939b044ec938fd56355012851890c63974c8042c9fStephen Hines// Optimize constant ordering. 1949b044ec938fd56355012851890c63974c8042c9fStephen Hinesnamespace { 1959b044ec938fd56355012851890c63974c8042c9fStephen Hines struct CstSortPredicate { 1969b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueEnumerator &VE; 1979b044ec938fd56355012851890c63974c8042c9fStephen Hines explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {} 1989b044ec938fd56355012851890c63974c8042c9fStephen Hines bool operator()(const std::pair<const Value*, unsigned> &LHS, 1999b044ec938fd56355012851890c63974c8042c9fStephen Hines const std::pair<const Value*, unsigned> &RHS) { 2009b044ec938fd56355012851890c63974c8042c9fStephen Hines // Sort by plane. 2019b044ec938fd56355012851890c63974c8042c9fStephen Hines if (LHS.first->getType() != RHS.first->getType()) 2029b044ec938fd56355012851890c63974c8042c9fStephen Hines return VE.getTypeID(LHS.first->getType()) < 2039b044ec938fd56355012851890c63974c8042c9fStephen Hines VE.getTypeID(RHS.first->getType()); 2049b044ec938fd56355012851890c63974c8042c9fStephen Hines // Then by frequency. 2059b044ec938fd56355012851890c63974c8042c9fStephen Hines return LHS.second > RHS.second; 2069b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2079b044ec938fd56355012851890c63974c8042c9fStephen Hines }; 2089b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2099b044ec938fd56355012851890c63974c8042c9fStephen Hines 2109b044ec938fd56355012851890c63974c8042c9fStephen Hines/// OptimizeConstants - Reorder constant pool for denser encoding. 2119b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) { 2129b044ec938fd56355012851890c63974c8042c9fStephen Hines if (CstStart == CstEnd || CstStart+1 == CstEnd) return; 2139b044ec938fd56355012851890c63974c8042c9fStephen Hines 2149b044ec938fd56355012851890c63974c8042c9fStephen Hines CstSortPredicate P(*this); 2159b044ec938fd56355012851890c63974c8042c9fStephen Hines std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P); 2169b044ec938fd56355012851890c63974c8042c9fStephen Hines 2170da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines // Ensure that integer and vector of integer constants are at the start of the 2180da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines // constant pool. This is important so that GEP structure indices come before 2190da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines // gep constant exprs. 2209b044ec938fd56355012851890c63974c8042c9fStephen Hines std::partition(Values.begin()+CstStart, Values.begin()+CstEnd, 2210da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines isIntOrIntVectorValue); 2229b044ec938fd56355012851890c63974c8042c9fStephen Hines 2239b044ec938fd56355012851890c63974c8042c9fStephen Hines // Rebuild the modified portion of ValueMap. 2249b044ec938fd56355012851890c63974c8042c9fStephen Hines for (; CstStart != CstEnd; ++CstStart) 2259b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap[Values[CstStart].first] = CstStart+1; 2269b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2279b044ec938fd56355012851890c63974c8042c9fStephen Hines 2289b044ec938fd56355012851890c63974c8042c9fStephen Hines 2299b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol 2309b044ec938fd56355012851890c63974c8042c9fStephen Hines/// table into the values table. 2319b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) { 2329b044ec938fd56355012851890c63974c8042c9fStephen Hines for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end(); 2339b044ec938fd56355012851890c63974c8042c9fStephen Hines VI != VE; ++VI) 2349b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(VI->getValue()); 2359b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2369b044ec938fd56355012851890c63974c8042c9fStephen Hines 2379b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateNamedMetadata - Insert all of the values referenced by 2389b044ec938fd56355012851890c63974c8042c9fStephen Hines/// named metadata in the specified module. 239c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hinesvoid ValueEnumerator::EnumerateNamedMetadata(const llvm::Module &M) { 240c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (llvm::Module::const_named_metadata_iterator I = M.named_metadata_begin(), 241c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines E = M.named_metadata_end(); 242c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines I != E; ++I) 2439b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateNamedMDNode(I); 2449b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2459b044ec938fd56355012851890c63974c8042c9fStephen Hines 2469b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) { 2479b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) 2489b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMetadata(MD->getOperand(i)); 2499b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2509b044ec938fd56355012851890c63974c8042c9fStephen Hines 2519b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateMDNodeOperands - Enumerate all non-function-local values 2529b044ec938fd56355012851890c63974c8042c9fStephen Hines/// and types referenced by the given MDNode. 2539b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) { 2549b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { 255c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines Metadata *MD = N->getOperand(i); 256c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (!MD) 257c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines continue; 258c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines assert(!isa<LocalAsMetadata>(MD) && "MDNodes cannot be function-local"); 259c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateMetadata(MD); 2609b044ec938fd56355012851890c63974c8042c9fStephen Hines } 2619b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2629b044ec938fd56355012851890c63974c8042c9fStephen Hines 263c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hinesvoid ValueEnumerator::EnumerateMetadata(const llvm::Metadata *MD) { 264c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines assert( 265c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) && 266c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines "Invalid metadata kind"); 2679b044ec938fd56355012851890c63974c8042c9fStephen Hines 268c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Insert a dummy ID to block the co-recursive call to 269c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // EnumerateMDNodeOperands() from re-visiting MD in a cyclic graph. 270c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // 271c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Return early if there's already an ID. 272c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (!MDValueMap.insert(std::make_pair(MD, 0)).second) 273c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines return; 2749b044ec938fd56355012851890c63974c8042c9fStephen Hines 275c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Visit operands first to minimize RAUW. 276c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (auto *N = dyn_cast<MDNode>(MD)) 2779b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateMDNodeOperands(N); 278c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines else if (auto *C = dyn_cast<ConstantAsMetadata>(MD)) 279c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateValue(C->getValue()); 2809b044ec938fd56355012851890c63974c8042c9fStephen Hines 281c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines HasMDString |= isa<MDString>(MD); 282c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines HasMDLocation |= isa<MDLocation>(MD); 2839b044ec938fd56355012851890c63974c8042c9fStephen Hines 284c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Replace the dummy ID inserted above with the correct one. MDValueMap may 285c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // have changed by inserting operands, so we need a fresh lookup here. 286c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDs.push_back(MD); 287c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDValueMap[MD] = MDs.size(); 2889b044ec938fd56355012851890c63974c8042c9fStephen Hines} 2899b044ec938fd56355012851890c63974c8042c9fStephen Hines 2909b044ec938fd56355012851890c63974c8042c9fStephen Hines/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata 291c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines/// information reachable from the metadata. 292c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hinesvoid ValueEnumerator::EnumerateFunctionLocalMetadata( 293c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines const llvm::LocalAsMetadata *Local) { 2949b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if it's already in! 295c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines unsigned &MDValueID = MDValueMap[Local]; 296c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (MDValueID) 2979b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 2989b044ec938fd56355012851890c63974c8042c9fStephen Hines 299c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDs.push_back(Local); 300c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDValueID = MDs.size(); 301c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 302c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateValue(Local->getValue()); 303c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 304c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Also, collect all function-local metadata for easy access. 305c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines FunctionLocalMDs.push_back(Local); 3069b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3079b044ec938fd56355012851890c63974c8042c9fStephen Hines 3089b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateValue(const Value *V) { 3099b044ec938fd56355012851890c63974c8042c9fStephen Hines assert(!V->getType()->isVoidTy() && "Can't insert void values!"); 310c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines assert(!isa<MetadataAsValue>(V) && "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; 345db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines } else if (const ConstantDataSequential *CDS = 346db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines dyn_cast<ConstantDataSequential>(C)) { 347db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines // For our legacy handling of the new ConstantDataSequential type, we 348db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines // need to enumerate the individual elements, as well as mark the 349db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines // outer constant as used. 350db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) 351db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines EnumerateValue(CDS->getElementAsConstant(i)); 352db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines Values.push_back(std::make_pair(V, 1U)); 353db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines ValueMap[V] = Values.size(); 354db37c900ebe6f0ae62a1f77327dd9e5a469ff11eStephen Hines return; 3559b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3569b044ec938fd56355012851890c63974c8042c9fStephen Hines } 3579b044ec938fd56355012851890c63974c8042c9fStephen Hines 3589b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add the value. 3599b044ec938fd56355012851890c63974c8042c9fStephen Hines Values.push_back(std::make_pair(V, 1U)); 3609b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueID = Values.size(); 3619b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3629b044ec938fd56355012851890c63974c8042c9fStephen Hines 3639b044ec938fd56355012851890c63974c8042c9fStephen Hines 3649b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateType(Type *Ty) { 3659b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned *TypeID = &TypeMap[Ty]; 3669b044ec938fd56355012851890c63974c8042c9fStephen Hines 3679b044ec938fd56355012851890c63974c8042c9fStephen Hines // We've already seen this type. 3689b044ec938fd56355012851890c63974c8042c9fStephen Hines if (*TypeID) 3699b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 3709b044ec938fd56355012851890c63974c8042c9fStephen Hines 3719b044ec938fd56355012851890c63974c8042c9fStephen Hines // If it is a non-anonymous struct, mark the type as being visited so that we 3729b044ec938fd56355012851890c63974c8042c9fStephen Hines // don't recursively visit it. This is safe because we allow forward 3739b044ec938fd56355012851890c63974c8042c9fStephen Hines // references of these in the bitcode reader. 3749b044ec938fd56355012851890c63974c8042c9fStephen Hines if (StructType *STy = dyn_cast<StructType>(Ty)) 3759b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!STy->isLiteral()) 3769b044ec938fd56355012851890c63974c8042c9fStephen Hines *TypeID = ~0U; 37723c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 3789b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate all of the subtypes before we enumerate this type. This ensures 3799b044ec938fd56355012851890c63974c8042c9fStephen Hines // that the type will be enumerated in an order that can be directly built. 380c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (Type *SubTy : Ty->subtypes()) 381c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateType(SubTy); 38223c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 3839b044ec938fd56355012851890c63974c8042c9fStephen Hines // Refresh the TypeID pointer in case the table rehashed. 3849b044ec938fd56355012851890c63974c8042c9fStephen Hines TypeID = &TypeMap[Ty]; 38523c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 3869b044ec938fd56355012851890c63974c8042c9fStephen Hines // Check to see if we got the pointer another way. This can happen when 3879b044ec938fd56355012851890c63974c8042c9fStephen Hines // enumerating recursive types that hit the base case deeper than they start. 3889b044ec938fd56355012851890c63974c8042c9fStephen Hines // 3899b044ec938fd56355012851890c63974c8042c9fStephen Hines // If this is actually a struct that we are treating as forward ref'able, 3909b044ec938fd56355012851890c63974c8042c9fStephen Hines // then emit the definition now that all of its contents are available. 3919b044ec938fd56355012851890c63974c8042c9fStephen Hines if (*TypeID && *TypeID != ~0U) 3929b044ec938fd56355012851890c63974c8042c9fStephen Hines return; 39323c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 3949b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add this type now that its contents are all happily enumerated. 3959b044ec938fd56355012851890c63974c8042c9fStephen Hines Types.push_back(Ty); 39623c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 3979b044ec938fd56355012851890c63974c8042c9fStephen Hines *TypeID = Types.size(); 3989b044ec938fd56355012851890c63974c8042c9fStephen Hines} 3999b044ec938fd56355012851890c63974c8042c9fStephen Hines 4009b044ec938fd56355012851890c63974c8042c9fStephen Hines// Enumerate the types for the specified value. If the value is a constant, 4019b044ec938fd56355012851890c63974c8042c9fStephen Hines// walk through it, enumerating the types of the constant. 4029b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::EnumerateOperandType(const Value *V) { 4039b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateType(V->getType()); 40423c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 405c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (auto *MD = dyn_cast<MetadataAsValue>(V)) { 406c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines assert(!isa<LocalAsMetadata>(MD->getMetadata()) && 407c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines "Function-local metadata should be left for later"); 4089b044ec938fd56355012851890c63974c8042c9fStephen Hines 409c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateMetadata(MD->getMetadata()); 410c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines return; 411c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines } 41223c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 413c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines const Constant *C = dyn_cast<Constant>(V); 414c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (!C) 415c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines return; 41623c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 417c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // If this constant is already enumerated, ignore it, we know its type must 418c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // be enumerated. 419c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (ValueMap.count(C)) 420c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines return; 4219b044ec938fd56355012851890c63974c8042c9fStephen Hines 422c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // This constant may have operands, make sure to enumerate the types in 423c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // them. 424c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 425c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines const Value *Op = C->getOperand(i); 426c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 427c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // Don't enumerate basic blocks here, this happens as operands to 428c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines // blockaddress. 429c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (isa<BasicBlock>(Op)) 430c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines continue; 431c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines 432c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines EnumerateOperandType(Op); 433c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines } 4349b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4359b044ec938fd56355012851890c63974c8042c9fStephen Hines 4360da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hinesvoid ValueEnumerator::EnumerateAttributes(AttributeSet PAL) { 4379b044ec938fd56355012851890c63974c8042c9fStephen Hines if (PAL.isEmpty()) return; // null is always 0. 4380da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines 4399b044ec938fd56355012851890c63974c8042c9fStephen Hines // Do a lookup. 4400da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines unsigned &Entry = AttributeMap[PAL]; 4419b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Entry == 0) { 4429b044ec938fd56355012851890c63974c8042c9fStephen Hines // Never saw this before, add it. 44323c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines Attribute.push_back(PAL); 44423c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines Entry = Attribute.size(); 4459b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4460da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines 4470da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines // Do lookups for all attribute groups. 4480da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) { 4490da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines AttributeSet AS = PAL.getSlotAttributes(i); 4500da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines unsigned &Entry = AttributeGroupMap[AS]; 4510da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines if (Entry == 0) { 4520da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines AttributeGroups.push_back(AS); 4530da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines Entry = AttributeGroups.size(); 4540da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines } 4550da7f6c8201b27938d3b9f048d71fd784cd1df9aStephen Hines } 4569b044ec938fd56355012851890c63974c8042c9fStephen Hines} 4579b044ec938fd56355012851890c63974c8042c9fStephen Hines 4589b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::incorporateFunction(const Function &F) { 4599b044ec938fd56355012851890c63974c8042c9fStephen Hines InstructionCount = 0; 4609b044ec938fd56355012851890c63974c8042c9fStephen Hines NumModuleValues = Values.size(); 461c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines NumModuleMDs = MDs.size(); 4629b044ec938fd56355012851890c63974c8042c9fStephen Hines 4639b044ec938fd56355012851890c63974c8042c9fStephen Hines // Adding function arguments to the value table. 4649b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); 4659b044ec938fd56355012851890c63974c8042c9fStephen Hines I != E; ++I) 4669b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 4679b044ec938fd56355012851890c63974c8042c9fStephen Hines 4689b044ec938fd56355012851890c63974c8042c9fStephen Hines FirstFuncConstantID = Values.size(); 4699b044ec938fd56355012851890c63974c8042c9fStephen Hines 4709b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all function-level constants to the value table. 4719b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 4729b044ec938fd56355012851890c63974c8042c9fStephen Hines for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) 4739b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 4749b044ec938fd56355012851890c63974c8042c9fStephen Hines OI != E; ++OI) { 4759b044ec938fd56355012851890c63974c8042c9fStephen Hines if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || 4769b044ec938fd56355012851890c63974c8042c9fStephen Hines isa<InlineAsm>(*OI)) 4779b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(*OI); 4789b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4799b044ec938fd56355012851890c63974c8042c9fStephen Hines BasicBlocks.push_back(BB); 4809b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap[BB] = BasicBlocks.size(); 4819b044ec938fd56355012851890c63974c8042c9fStephen Hines } 4829b044ec938fd56355012851890c63974c8042c9fStephen Hines 4839b044ec938fd56355012851890c63974c8042c9fStephen Hines // Optimize the constant layout. 4849b044ec938fd56355012851890c63974c8042c9fStephen Hines OptimizeConstants(FirstFuncConstantID, Values.size()); 4859b044ec938fd56355012851890c63974c8042c9fStephen Hines 4869b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add the function's parameter attributes so they are available for use in 4879b044ec938fd56355012851890c63974c8042c9fStephen Hines // the function's instruction. 4889b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateAttributes(F.getAttributes()); 4899b044ec938fd56355012851890c63974c8042c9fStephen Hines 4909b044ec938fd56355012851890c63974c8042c9fStephen Hines FirstInstID = Values.size(); 4919b044ec938fd56355012851890c63974c8042c9fStephen Hines 492c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines SmallVector<llvm::LocalAsMetadata *, 8> FnLocalMDVector; 4939b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all of the instructions. 4949b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 4959b044ec938fd56355012851890c63974c8042c9fStephen Hines for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) { 4969b044ec938fd56355012851890c63974c8042c9fStephen Hines for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); 4979b044ec938fd56355012851890c63974c8042c9fStephen Hines OI != E; ++OI) { 498c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (auto *MD = dyn_cast<llvm::MetadataAsValue>(&*OI)) 499c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines if (auto *Local = dyn_cast<LocalAsMetadata>(MD->getMetadata())) 5009b044ec938fd56355012851890c63974c8042c9fStephen Hines // Enumerate metadata after the instructions they might refer to. 501c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines FnLocalMDVector.push_back(Local); 5029b044ec938fd56355012851890c63974c8042c9fStephen Hines } 50323c4358f12bd9d0ba7166eceebd683db95a41b3fStephen Hines 5049b044ec938fd56355012851890c63974c8042c9fStephen Hines if (!I->getType()->isVoidTy()) 5059b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateValue(I); 5069b044ec938fd56355012851890c63974c8042c9fStephen Hines } 5079b044ec938fd56355012851890c63974c8042c9fStephen Hines } 5089b044ec938fd56355012851890c63974c8042c9fStephen Hines 5099b044ec938fd56355012851890c63974c8042c9fStephen Hines // Add all of the function-local metadata. 5109b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i) 5119b044ec938fd56355012851890c63974c8042c9fStephen Hines EnumerateFunctionLocalMetadata(FnLocalMDVector[i]); 5129b044ec938fd56355012851890c63974c8042c9fStephen Hines} 5139b044ec938fd56355012851890c63974c8042c9fStephen Hines 5149b044ec938fd56355012851890c63974c8042c9fStephen Hinesvoid ValueEnumerator::purgeFunction() { 5159b044ec938fd56355012851890c63974c8042c9fStephen Hines /// Remove purged values from the ValueMap. 5169b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i) 5179b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap.erase(Values[i].first); 518c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines for (unsigned i = NumModuleMDs, e = MDs.size(); i != e; ++i) 519c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDValueMap.erase(MDs[i]); 5209b044ec938fd56355012851890c63974c8042c9fStephen Hines for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) 5219b044ec938fd56355012851890c63974c8042c9fStephen Hines ValueMap.erase(BasicBlocks[i]); 5229b044ec938fd56355012851890c63974c8042c9fStephen Hines 5239b044ec938fd56355012851890c63974c8042c9fStephen Hines Values.resize(NumModuleValues); 524c706907a8041faaa882f9bd87f1d1c1669023a62Stephen Hines MDs.resize(NumModuleMDs); 5259b044ec938fd56355012851890c63974c8042c9fStephen Hines BasicBlocks.clear(); 5269b044ec938fd56355012851890c63974c8042c9fStephen Hines FunctionLocalMDs.clear(); 5279b044ec938fd56355012851890c63974c8042c9fStephen Hines} 5289b044ec938fd56355012851890c63974c8042c9fStephen Hines 5299b044ec938fd56355012851890c63974c8042c9fStephen Hinesstatic void IncorporateFunctionInfoGlobalBBIDs(const Function *F, 5309b044ec938fd56355012851890c63974c8042c9fStephen Hines DenseMap<const BasicBlock*, unsigned> &IDMap) { 5319b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned Counter = 0; 5329b044ec938fd56355012851890c63974c8042c9fStephen Hines for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 5339b044ec938fd56355012851890c63974c8042c9fStephen Hines IDMap[BB] = ++Counter; 5349b044ec938fd56355012851890c63974c8042c9fStephen Hines} 5359b044ec938fd56355012851890c63974c8042c9fStephen Hines 5369b044ec938fd56355012851890c63974c8042c9fStephen Hines/// getGlobalBasicBlockID - This returns the function-specific ID for the 5379b044ec938fd56355012851890c63974c8042c9fStephen Hines/// specified basic block. This is relatively expensive information, so it 5389b044ec938fd56355012851890c63974c8042c9fStephen Hines/// should only be used by rare constructs such as address-of-label. 5399b044ec938fd56355012851890c63974c8042c9fStephen Hinesunsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const { 5409b044ec938fd56355012851890c63974c8042c9fStephen Hines unsigned &Idx = GlobalBasicBlockIDs[BB]; 5419b044ec938fd56355012851890c63974c8042c9fStephen Hines if (Idx != 0) 5429b044ec938fd56355012851890c63974c8042c9fStephen Hines return Idx-1; 5439b044ec938fd56355012851890c63974c8042c9fStephen Hines 5449b044ec938fd56355012851890c63974c8042c9fStephen Hines IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs); 5459b044ec938fd56355012851890c63974c8042c9fStephen Hines return getGlobalBasicBlockID(BB); 5469b044ec938fd56355012851890c63974c8042c9fStephen Hines} 5479b044ec938fd56355012851890c63974c8042c9fStephen Hines 5489937d116e09feb32d46a4c76eca1be6afcd3bed5Stephen Hines} // end llvm_2_9_func namespace 549