/// 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); }
void ValueEnumerator::incorporateFunction(const Function &F) { InstructionCount = 0; NumModuleValues = Values.size(); NumModuleMDs = MDs.size(); // Adding function arguments to the value table. for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) EnumerateValue(I); FirstFuncConstantID = Values.size(); // Add all function-level constants to the value table. 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 ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) || isa<InlineAsm>(*OI)) EnumerateValue(*OI); } BasicBlocks.push_back(BB); ValueMap[BB] = BasicBlocks.size(); } // Optimize the constant layout. OptimizeConstants(FirstFuncConstantID, Values.size()); // Add the function's parameter attributes so they are available for use in // the function's instruction. EnumerateAttributes(F.getAttributes()); FirstInstID = Values.size(); SmallVector<llvm::LocalAsMetadata *, 8> FnLocalMDVector; // Add all of the instructions. 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 (auto *MD = dyn_cast<llvm::MetadataAsValue>(&*OI)) if (auto *Local = dyn_cast<LocalAsMetadata>(MD->getMetadata())) // Enumerate metadata after the instructions they might refer to. FnLocalMDVector.push_back(Local); } if (!I->getType()->isVoidTy()) EnumerateValue(I); } } // Add all of the function-local metadata. for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i) EnumerateFunctionLocalMetadata(FnLocalMDVector[i]); }