/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata /// information reachable from the given MDNode. void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) { assert(N->isFunctionLocal() && N->getFunction() && "EnumerateFunctionLocalMetadata called on non-function-local mdnode!"); // Enumerate the type of this value. EnumerateType(N->getType()); // Check to see if it's already in! unsigned &MDValueID = MDValueMap[N]; if (MDValueID) { // Increment use count. MDValues[MDValueID-1].second++; return; } MDValues.push_back(std::make_pair(N, 1U)); MDValueID = MDValues.size(); // To incoroporate function-local information visit all function-local // MDNodes and all function-local values they reference. for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) if (Value *V = N->getOperand(i)) { if (MDNode *O = dyn_cast<MDNode>(V)) { if (O->isFunctionLocal() && O->getFunction()) EnumerateFunctionLocalMetadata(O); } else if (isa<Instruction>(V) || isa<Argument>(V)) EnumerateValue(V); } // Also, collect all function-local MDNodes for easy access. FunctionLocalMDs.push_back(N); }
// Enumerate the types for the specified value. If the value is a constant, // walk through it, enumerating the types of the constant. void ValueEnumerator::EnumerateOperandType(const Value *V) { EnumerateType(V->getType()); if (const Constant *C = dyn_cast<Constant>(V)) { // If this constant is already enumerated, ignore it, we know its type must // be enumerated. if (ValueMap.count(V)) return; // This constant may have operands, make sure to enumerate the types in // them. for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { const Value *Op = C->getOperand(i); // Don't enumerate basic blocks here, this happens as operands to // blockaddress. if (isa<BasicBlock>(Op)) continue; EnumerateOperandType(Op); } if (const MDNode *N = dyn_cast<MDNode>(V)) { for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) if (Value *Elem = N->getOperand(i)) EnumerateOperandType(Elem); } } else if (isa<MDString>(V) || isa<MDNode>(V)) EnumerateMetadata(V); }
void ValueEnumerator::EnumerateMetadata(const Value *MD) { assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind"); // Enumerate the type of this value. EnumerateType(MD->getType()); const MDNode *N = dyn_cast<MDNode>(MD); // In the module-level pass, skip function-local nodes themselves, but // do walk their operands. if (N && N->isFunctionLocal() && N->getFunction()) { EnumerateMDNodeOperands(N); return; } // Check to see if it's already in! unsigned &MDValueID = MDValueMap[MD]; if (MDValueID) { // Increment use count. MDValues[MDValueID-1].second++; return; } MDValues.push_back(std::make_pair(MD, 1U)); MDValueID = MDValues.size(); // Enumerate all non-function-local operands. if (N) EnumerateMDNodeOperands(N); }
// Enumerate the types for the specified value. If the value is a constant, // walk through it, enumerating the types of the constant. void ValueEnumerator::EnumerateOperandType(const Value *V) { EnumerateType(V->getType()); if (auto *MD = dyn_cast<MetadataAsValue>(V)) { assert(!isa<LocalAsMetadata>(MD->getMetadata()) && "Function-local metadata should be left for later"); EnumerateMetadata(MD->getMetadata()); return; } const Constant *C = dyn_cast<Constant>(V); if (!C) return; // If this constant is already enumerated, ignore it, we know its type must // be enumerated. if (ValueMap.count(C)) return; // This constant may have operands, make sure to enumerate the types in // them. for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { const Value *Op = C->getOperand(i); // Don't enumerate basic blocks here, this happens as operands to // blockaddress. if (isa<BasicBlock>(Op)) continue; EnumerateOperandType(Op); } }
void ValueEnumerator::EnumerateType(Type *Ty) { unsigned *TypeID = &TypeMap[Ty]; // We've already seen this type. if (*TypeID) return; // If it is a non-anonymous struct, mark the type as being visited so that we // don't recursively visit it. This is safe because we allow forward // references of these in the bitcode reader. if (StructType *STy = dyn_cast<StructType>(Ty)) if (!STy->isLiteral()) *TypeID = ~0U; // Enumerate all of the subtypes before we enumerate this type. This ensures // that the type will be enumerated in an order that can be directly built. for (Type *SubTy : Ty->subtypes()) EnumerateType(SubTy); // Refresh the TypeID pointer in case the table rehashed. TypeID = &TypeMap[Ty]; // Check to see if we got the pointer another way. This can happen when // enumerating recursive types that hit the base case deeper than they start. // // If this is actually a struct that we are treating as forward ref'able, // then emit the definition now that all of its contents are available. if (*TypeID && *TypeID != ~0U) return; // Add this type now that its contents are all happily enumerated. Types.push_back(Ty); *TypeID = Types.size(); }
void ValueEnumerator::EnumerateValue(const Value *V) { assert(!V->getType()->isVoidTy() && "Can't insert void values!"); assert(!isa<MDNode>(V) && !isa<MDString>(V) && "EnumerateValue doesn't handle Metadata!"); // Check to see if it's already in! unsigned &ValueID = ValueMap[V]; if (ValueID) { // Increment use count. Values[ValueID-1].second++; return; } // Enumerate the type of this value. EnumerateType(V->getType()); if (const Constant *C = dyn_cast<Constant>(V)) { if (isa<GlobalValue>(C)) { // Initializers for globals are handled explicitly elsewhere. } else if (C->getNumOperands()) { // If a constant has operands, enumerate them. This makes sure that if a // constant has uses (for example an array of const ints), that they are // inserted also. // We prefer to enumerate them with values before we enumerate the user // itself. This makes it more likely that we can avoid forward references // in the reader. We know that there can be no cycles in the constants // graph that don't go through a global variable. for (User::const_op_iterator I = C->op_begin(), E = C->op_end(); I != E; ++I) if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress. EnumerateValue(*I); // Finally, add the value. Doing this could make the ValueID reference be // dangling, don't reuse it. Values.push_back(std::make_pair(V, 1U)); ValueMap[V] = Values.size(); return; } else if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) { // For our legacy handling of the new ConstantDataSequential type, we // need to enumerate the individual elements, as well as mark the // outer constant as used. for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) EnumerateValue(CDS->getElementAsConstant(i)); Values.push_back(std::make_pair(V, 1U)); ValueMap[V] = Values.size(); return; } } // Add the value. Values.push_back(std::make_pair(V, 1U)); ValueID = Values.size(); }
/// EnumerateMDNodeOperands - Enumerate all non-function-local values /// and types referenced by the given MDNode. void ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) { for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) { if (Value *V = N->getOperand(i)) { if (isa<MDNode>(V) || isa<MDString>(V)) EnumerateMetadata(V); else if (!isa<Instruction>(V) && !isa<Argument>(V)) EnumerateValue(V); } else EnumerateType(Type::getVoidTy(N->getContext())); } }
/// ValueEnumerator - Enumerate module-level information. ValueEnumerator::ValueEnumerator(const Module *M) { // Enumerate the global variables. for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) EnumerateValue(I); // Enumerate the functions. for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { EnumerateValue(I); EnumerateAttributes(cast<Function>(I)->getAttributes()); } // Enumerate the aliases. for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) EnumerateValue(I); // Remember what is the cutoff between globalvalue's and other constants. unsigned FirstConstant = Values.size(); // Enumerate the global variable initializers. for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I) if (I->hasInitializer()) EnumerateValue(I->getInitializer()); // Enumerate the aliasees. for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); I != E; ++I) EnumerateValue(I->getAliasee()); // Insert constants and metadata that are named at module level into the slot // pool so that the module symbol table can refer to them... EnumerateValueSymbolTable(M->getValueSymbolTable()); EnumerateNamedMetadata(M); SmallVector<std::pair<unsigned, MDNode*>, 8> MDs; // Enumerate types used by function bodies and argument lists. for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) { for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) EnumerateType(I->getType()); for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){ for (User::const_op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) { if (MDNode *MD = dyn_cast<MDNode>(*OI)) if (MD->isFunctionLocal() && MD->getFunction()) // These will get enumerated during function-incorporation. continue; EnumerateOperandType(*OI); } EnumerateType(I->getType()); if (const CallInst *CI = dyn_cast<CallInst>(I)) EnumerateAttributes(CI->getAttributes()); else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) EnumerateAttributes(II->getAttributes()); // Enumerate metadata attached with this instruction. MDs.clear(); I->getAllMetadataOtherThanDebugLoc(MDs); for (unsigned i = 0, e = MDs.size(); i != e; ++i) EnumerateMetadata(MDs[i].second); if (!I->getDebugLoc().isUnknown()) { MDNode *Scope, *IA; I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext()); if (Scope) EnumerateMetadata(Scope); if (IA) EnumerateMetadata(IA); } } } // Optimize constant ordering. OptimizeConstants(FirstConstant, Values.size()); }
/// ValueEnumerator - Enumerate module-level information. ValueEnumerator::ValueEnumerator(const llvm::Module &M, bool ShouldPreserveUseListOrder) : HasMDString(false), HasDILocation(false), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) { assert(!ShouldPreserveUseListOrder && "not supported UseListOrders = predictUseListOrder(M)"); // Enumerate the global variables. for (llvm::Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) EnumerateValue(I); // Enumerate the functions. for (llvm::Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { EnumerateValue(I); EnumerateAttributes(cast<Function>(I)->getAttributes()); } // Enumerate the aliases. for (llvm::Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); I != E; ++I) EnumerateValue(I); // Remember what is the cutoff between globalvalue's and other constants. unsigned FirstConstant = Values.size(); // Enumerate the global variable initializers. for (llvm::Module::const_global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) if (I->hasInitializer()) EnumerateValue(I->getInitializer()); // Enumerate the aliasees. for (llvm::Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); I != E; ++I) EnumerateValue(I->getAliasee()); // Enumerate the metadata type. // // TODO: Move this to ValueEnumerator::EnumerateOperandType() once bitcode // only encodes the metadata type when it's used as a value. EnumerateType(Type::getMetadataTy(M.getContext())); // Insert constants and metadata that are named at module level into the slot // pool so that the module symbol table can refer to them... EnumerateValueSymbolTable(M.getValueSymbolTable()); EnumerateNamedMetadata(M); SmallVector<std::pair<unsigned, MDNode *>, 8> MDs; // Enumerate types used by function bodies and argument lists. for (const Function &F : M) { for (const Argument &A : F.args()) EnumerateType(A.getType()); for (const BasicBlock &BB : F) for (const Instruction &I : BB) { for (const Use &Op : I.operands()) { auto *MD = dyn_cast<MetadataAsValue>(&Op); if (!MD) { EnumerateOperandType(Op); continue; } // Local metadata is enumerated during function-incorporation. if (isa<LocalAsMetadata>(MD->getMetadata())) continue; EnumerateMetadata(MD->getMetadata()); } EnumerateType(I.getType()); if (const CallInst *CI = dyn_cast<CallInst>(&I)) EnumerateAttributes(CI->getAttributes()); else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) EnumerateAttributes(II->getAttributes()); // Enumerate metadata attached with this instruction. MDs.clear(); I.getAllMetadataOtherThanDebugLoc(MDs); for (unsigned i = 0, e = MDs.size(); i != e; ++i) EnumerateMetadata(MDs[i].second); #if LLVM_VERSION >= 37 if (I.getDebugLoc()) { MDNode* Scope = I.getDebugLoc().getScope(); if (Scope) EnumerateMetadata(Scope); DILocation *IA = I.getDebugLoc().getInlinedAt(); if (IA) EnumerateMetadata(IA); } #else if (!I.getDebugLoc().isUnknown()) { MDNode *Scope, *IA; I.getDebugLoc().getScopeAndInlinedAt(Scope, IA, I.getContext()); if (Scope) EnumerateMetadata(Scope); if (IA) EnumerateMetadata(IA); } #endif } } // Optimize constant ordering. OptimizeConstants(FirstConstant, Values.size()); }