/// buildCFICheck - emits __cfi_check for the current module. void CrossDSOCFI::buildCFICheck() { // FIXME: verify that __cfi_check ends up near the end of the code section, // but before the jump slots created in LowerBitSets. llvm::DenseSet<uint64_t> BitSetIds; NamedMDNode *BitSetNM = M->getNamedMetadata("llvm.bitsets"); if (BitSetNM) for (unsigned I = 0, E = BitSetNM->getNumOperands(); I != E; ++I) if (ConstantInt *TypeId = extractBitSetTypeId(BitSetNM->getOperand(I))) BitSetIds.insert(TypeId->getZExtValue()); LLVMContext &Ctx = M->getContext(); Constant *C = M->getOrInsertFunction( "__cfi_check", FunctionType::get( Type::getVoidTy(Ctx), {Type::getInt64Ty(Ctx), PointerType::getUnqual(Type::getInt8Ty(Ctx))}, false)); Function *F = dyn_cast<Function>(C); F->setAlignment(4096); auto args = F->arg_begin(); Argument &CallSiteTypeId = *(args++); CallSiteTypeId.setName("CallSiteTypeId"); Argument &Addr = *(args++); Addr.setName("Addr"); assert(args == F->arg_end()); BasicBlock *BB = BasicBlock::Create(Ctx, "entry", F); BasicBlock *TrapBB = BasicBlock::Create(Ctx, "trap", F); IRBuilder<> IRBTrap(TrapBB); Function *TrapFn = Intrinsic::getDeclaration(M, Intrinsic::trap); llvm::CallInst *TrapCall = IRBTrap.CreateCall(TrapFn); TrapCall->setDoesNotReturn(); TrapCall->setDoesNotThrow(); IRBTrap.CreateUnreachable(); BasicBlock *ExitBB = BasicBlock::Create(Ctx, "exit", F); IRBuilder<> IRBExit(ExitBB); IRBExit.CreateRetVoid(); IRBuilder<> IRB(BB); SwitchInst *SI = IRB.CreateSwitch(&CallSiteTypeId, TrapBB, BitSetIds.size()); for (uint64_t TypeId : BitSetIds) { ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId); BasicBlock *TestBB = BasicBlock::Create(Ctx, "test", F); IRBuilder<> IRBTest(TestBB); Function *BitsetTestFn = Intrinsic::getDeclaration(M, Intrinsic::bitset_test); Value *Test = IRBTest.CreateCall( BitsetTestFn, {&Addr, MetadataAsValue::get( Ctx, ConstantAsMetadata::get(CaseTypeId))}); BranchInst *BI = IRBTest.CreateCondBr(Test, ExitBB, TrapBB); BI->setMetadata(LLVMContext::MD_prof, VeryLikelyWeights); SI->addCase(CaseTypeId, TestBB); ++TypeIds; } }
/// processModule - Process entire module and collect debug info. void DebugInfoFinder::processModule(Module &M) { MetadataContext &TheMetadata = M.getContext().getMetadata(); unsigned MDDbgKind = TheMetadata.getMDKind("dbg"); for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI) for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE; ++BI) { if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI)) processDeclare(DDI); else if (MDDbgKind) if (MDNode *L = TheMetadata.getMD(MDDbgKind, BI)) processLocation(DILocation(L)); } NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv"); if (!NMD) return; for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) { DIGlobalVariable DIG(cast<MDNode>(NMD->getElement(i))); if (addGlobalVariable(DIG)) { addCompileUnit(DIG.getCompileUnit()); processType(DIG.getType()); } } }
DICompileUnit *DIBuilder::createCompileUnit( unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer, bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName, DebugEmissionKind Kind, uint64_t DWOId, bool EmitDebugInfo) { assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) || (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) && "Invalid Language tag"); assert(!Filename.empty() && "Unable to create compile unit without filename"); assert(!CUNode && "Can only make one compile unit per DIBuilder instance"); CUNode = DICompileUnit::getDistinct( VMContext, Lang, DIFile::get(VMContext, Filename, Directory), Producer, isOptimized, Flags, RunTimeVer, SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId); // Create a named metadata so that it is easier to find cu in a module. // Note that we only generate this when the caller wants to actually // emit debug information. When we are only interested in tracking // source line locations throughout the backend, we prevent codegen from // emitting debug info in the final output by not generating llvm.dbg.cu. if (EmitDebugInfo) { NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); NMD->addOperand(CUNode); } trackIfUnresolved(CUNode); return CUNode; }
bool llvm::StripDebugInfo(Module &M) { bool Changed = false; for (Module::named_metadata_iterator NMI = M.named_metadata_begin(), NME = M.named_metadata_end(); NMI != NME;) { NamedMDNode *NMD = &*NMI; ++NMI; // We're stripping debug info, and without them, coverage information // doesn't quite make sense. if (NMD->getName().startswith("llvm.dbg.") || NMD->getName() == "llvm.gcov") { NMD->eraseFromParent(); Changed = true; } } for (Function &F : M) Changed |= stripDebugInfo(F); for (auto &GV : M.globals()) { SmallVector<MDNode *, 1> MDs; GV.getMetadata(LLVMContext::MD_dbg, MDs); if (!MDs.empty()) { GV.eraseMetadata(LLVMContext::MD_dbg); Changed = true; } } if (GVMaterializer *Materializer = M.getMaterializer()) Materializer->setStripDebugInfo(); return Changed; }
map<string, Variable*>* IRParser::parseParameters(Module* module){ map<string, Variable*>* parameters = new map<string, Variable*>(); NamedMDNode* inputsMD = module->getNamedMetadata(IRConstant::KEY_PARAMETERS); if (inputsMD != NULL){ for (unsigned i = 0, e = inputsMD->getNumOperands(); i != e; ++i) { //Parse a parameter MDNode* parameterNode = cast<MDNode>(inputsMD->getOperand(i)); MDNode* details = cast<MDNode>(parameterNode->getOperand(0)); MDString* nameMD = cast<MDString>(details->getOperand(0)); Type* type = parseType(cast<MDNode>(parameterNode->getOperand(1))); GlobalVariable* variable = cast<GlobalVariable>(parameterNode->getOperand(2)); //Parse create parameter StateVar* parameter = new StateVar(type, nameMD->getString(), false, variable); parameters->insert(pair<string, Variable*>(nameMD->getString(), parameter)); } } return parameters; }
/// createVariable - Create a new descriptor for the specified variable. DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNo, DIType Ty, bool AlwaysPreserve, unsigned Flags, unsigned ArgNo) { Value *Elts[] = { GetTagConstant(VMContext, Tag), getNonCompileUnitScope(Scope), MDString::get(VMContext, Name), File, ConstantInt::get(Type::getInt32Ty(VMContext), (LineNo | (ArgNo << 24))), Ty, ConstantInt::get(Type::getInt32Ty(VMContext), Flags), Constant::getNullValue(Type::getInt32Ty(VMContext)) }; MDNode *Node = MDNode::get(VMContext, Elts); if (AlwaysPreserve) { // The optimizer may remove local variable. If there is an interest // to preserve variable info in such situation then stash it in a // named mdnode. DISubprogram Fn(getDISubprogram(Scope)); NamedMDNode *FnLocals = getOrInsertFnSpecificMDNode(M, Fn); FnLocals->addOperand(Node); } return DIVariable(Node); }
ActionScheduler* IRParser::parseActionScheduler(Module* module){ NamedMDNode* inputsMD = module->getNamedMetadata(IRConstant::KEY_ACTION_SCHED); MDNode* actionSchedulerMD = cast<MDNode>(inputsMD->getOperand(0)); list<Action*>* actions = new list<Action*>(); FSM* fsm = NULL; //Get actions outside fsm if present Value* actionsValue = actionSchedulerMD->getOperand(0); if (actionsValue != NULL){ MDNode* actionsNode = cast<MDNode>(actionsValue); for (unsigned i = 0, e = actionsNode->getNumOperands(); i != e; ++i) { actions->push_back(getAction(cast<MDNode>(actionsNode->getOperand(i)))); } } //Get fsm if present Value* fsmValue = actionSchedulerMD->getOperand(1); if (fsmValue != NULL){ fsm = parseFSM(cast<MDNode>(fsmValue)); } return new ActionScheduler(actions, fsm); }
MoC* IRParser::parseMoC(Module* module){ NamedMDNode* mocKeyMD = module->getNamedMetadata(IRConstant::KEY_MOC); if (mocKeyMD == NULL) { return new DPNMoC(actor); } //Parse MoC type MDNode* node = mocKeyMD->getOperand(0); MDString* name = cast<MDString>(node->getOperand(0)); StringRef nameStr = name->getString(); if (nameStr == "SDF"){ return parseCSDF(cast<MDNode>(node->getOperand(1))); }else if(nameStr == "CSDF"){ return parseCSDF(cast<MDNode>(node->getOperand(1))); }else if(nameStr == "QuasiStatic"){ return parseQSDF(node); }else if(nameStr == "KPN"){ return new KPNMoC(actor); }else if(nameStr == "DPN"){ return new DPNMoC(actor); } cerr << "Unsupported type of MoC" << endl; exit(1); }
/// CreateGlobalVariable - Create a new descriptor for the specified global. DIGlobalVariable DIFactory::CreateGlobalVariable(DIDescriptor Context, const char * Name, const char * DisplayName, const char * LinkageName, DICompileUnit CompileUnit, unsigned LineNo, DIType Type,bool isLocalToUnit, bool isDefinition, llvm::GlobalVariable *Val) { Value *Elts[] = { GetTagConstant(dwarf::DW_TAG_variable), llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)), Context.getNode(), MDString::get(VMContext, Name), MDString::get(VMContext, DisplayName), MDString::get(VMContext, LinkageName), CompileUnit.getNode(), ConstantInt::get(Type::getInt32Ty(VMContext), LineNo), Type.getNode(), ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit), ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition), Val }; Value *const *Vs = &Elts[0]; MDNode *Node = MDNode::get(VMContext,Vs, 12); // Create a named metadata so that we do not lose this mdnode. NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.gv"); NMD->addElement(Node); return DIGlobalVariable(Node); }
void LLVMAddNamedMetadataOperand2(LLVMModuleRef M, const char *name, LLVMMetadataRef Val) { NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name); if (!N) return; if (!Val) return; N->addOperand(unwrap<MDNode>(Val)); }
static void ModuleMetaSet(Module *module, StringRef MetaName, StringRef ValueStr) { NamedMDNode *node = module->getNamedMetadata(MetaName); if (node) module->eraseNamedMetadata(node); node = module->getOrInsertNamedMetadata(MetaName); MDString *value = MDString::get(module->getContext(), ValueStr); node->addOperand(MDNode::get(module->getContext(), makeArrayRef(static_cast<Value*>(value)))); }
void SpecializationTable::initialize(Module* m) { assert(this->module == NULL); this->module = m; #ifdef RECORD_IN_METADATA // Parse the module metadata to populate the table NamedMDNode* specs = m->getNamedMetadata("previrt::specializations"); if (specs == NULL) return; errs() << "Specialization Count: " << specs->getNumOperands() << "\n"; for (unsigned int i = 0; i < specs->getNumOperands(); ++i) { MDNode* funNode = specs->getOperand(i); if (funNode == NULL) { continue; } assert (funNode->getNumOperands() > 2); MDString* prinName = dyn_cast_or_null<MDString>(funNode->getOperand(0)); MDString* specName = dyn_cast_or_null<MDString>(funNode->getOperand(1)); if (prinName == NULL || specName == NULL) { errs() << "must skip " << (prinName == NULL ? "?" : prinName->getString()) << "\n"; continue; } Function* prin = m->getFunction(prinName->getString()); Function* spec = m->getFunction(specName->getString()); if (prin == NULL || spec == NULL) { errs() << "must skip " << (prin == NULL ? "?" : prin->getName()) << "\n"; continue; } const unsigned int arg_count = prin->getArgumentList().size(); if (funNode->getNumOperands() != 2 + arg_count) { continue; } SpecScheme scheme = new Value*[arg_count]; for (unsigned int i = 0; i < arg_count; i++) { Value* opr = funNode->getOperand(2 + i); if (opr == NULL) { scheme[i] = NULL; } else { assert (dyn_cast<Constant>(opr) != NULL); scheme[i] = opr; } } this->addSpecialization(prin, scheme, spec, false); errs() << "recording specialization of '" << prin->getName() << "' to '" << spec->getName() << "'\n"; } #endif /* RECORD_IN_METADATA */ }
/// Insert all of the named MDNodes in Src into the Dest module. void IRLinker::linkNamedMDNodes() { const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); for (const NamedMDNode &NMD : SrcM->named_metadata()) { // Don't link module flags here. Do them separately. if (&NMD == SrcModFlags) continue; NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName()); // Add Src elements into Dest node. for (const MDNode *Op : NMD.operands()) DestNMD->addOperand(Mapper.mapMDNode(*Op)); } }
static std::string ModuleMetaGet(const Module *module, StringRef MetaName) { NamedMDNode *node = module->getNamedMetadata(MetaName); if (node == NULL) return ""; assert(node->getNumOperands() == 1); MDNode *subnode = node->getOperand(0); assert(subnode->getNumOperands() == 1); MDString *value = dyn_cast<MDString>(subnode->getOperand(0)); assert(value != NULL); return value->getString(); }
Actor* IRParser::parseActor(string classz){ //Get file and package of the actor string file = PackageMng::getSimpleName(classz); string packageName = PackageMng::getPackagesName(classz); Package* package = PackageMng::getPackage(packageName); //Parse the bitcode Module* module = parser->loadModule(package, file); if (module == 0){ //Module not found cerr << "Error when parsing bytecode"; exit(1); } //Empty action list actions.clear(); untaggedActions.clear(); // Parse name NamedMDNode* nameNMD = module->getNamedMetadata(IRConstant::KEY_NAME); MDNode* nameMD = cast<MDNode>(nameNMD->getOperand(0)); MDString* name = cast<MDString>(nameMD->getOperand(0)); // Create the new actor actor = new Actor(name->getString(), module, classz); // Parse actor elements inputs = parsePorts(IRConstant::KEY_INPUTS, module); outputs = parsePorts(IRConstant::KEY_OUTPUTS, module); map<string, Variable*>* parameters = parseParameters(module); map<string, StateVar*>* stateVars = parseStateVars(module); map<string, Procedure*>* procs = parseProcs(module); list<Action*>* initializes = parseActions(IRConstant::KEY_INITIALIZES, module); list<Action*>* actions = parseActions(IRConstant::KEY_ACTIONS, module); ActionScheduler* actionScheduler = parseActionScheduler(module); MoC* moc = parseMoC(module); //Set parameters of the actor actor->setInputs(inputs); actor->setOutputs(outputs); actor->setParameters(parameters); actor->setActions(actions); actor->setStateVars(stateVars); actor->setProcs(procs); actor->setActions(actions); actor->setInitializes(initializes); actor->setActionScheduler(actionScheduler); actor->setMoC(moc); return actor; }
/// linkNamedMDNodes - Insert all of the named mdnodes in Src into the Dest /// module. void ModuleLinker::linkNamedMDNodes() { const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(), E = SrcM->named_metadata_end(); I != E; ++I) { // Don't link module flags here. Do them separately. if (&*I == SrcModFlags) continue; NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName()); // Add Src elements into Dest node. for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) DestNMD->addOperand(MapValue(I->getOperand(i), ValueMap, RF_None, &TypeMap)); } }
DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer, bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName, DebugEmissionKind Kind, bool EmitDebugInfo) { assert(((Lang <= dwarf::DW_LANG_OCaml && Lang >= dwarf::DW_LANG_C89) || (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) && "Invalid Language tag"); assert(!Filename.empty() && "Unable to create compile unit without filename"); Value *TElts[] = {HeaderBuilder::get(DW_TAG_base_type).get(VMContext)}; TempEnumTypes = MDNode::getTemporary(VMContext, TElts); TempRetainTypes = MDNode::getTemporary(VMContext, TElts); TempSubprograms = MDNode::getTemporary(VMContext, TElts); TempGVs = MDNode::getTemporary(VMContext, TElts); TempImportedModules = MDNode::getTemporary(VMContext, TElts); Value *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit) .concat(Lang) .concat(Producer) .concat(isOptimized) .concat(Flags) .concat(RunTimeVer) .concat(SplitName) .concat(Kind) .get(VMContext), createFilePathPair(VMContext, Filename, Directory), TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs, TempImportedModules}; MDNode *CUNode = MDNode::get(VMContext, Elts); // Create a named metadata so that it is easier to find cu in a module. // Note that we only generate this when the caller wants to actually // emit debug information. When we are only interested in tracking // source line locations throughout the backend, we prevent codegen from // emitting debug info in the final output by not generating llvm.dbg.cu. if (EmitDebugInfo) { NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); NMD->addOperand(CUNode); } return DICompileUnit(CUNode); }
/// Insert all of the named MDNodes in Src into the Dest module. void IRLinker::linkNamedMDNodes() { const NamedMDNode *SrcModFlags = SrcM.getModuleFlagsMetadata(); for (const NamedMDNode &NMD : SrcM.named_metadata()) { // Don't link module flags here. Do them separately. if (&NMD == SrcModFlags) continue; NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName()); // Add Src elements into Dest node. for (const MDNode *op : NMD.operands()) DestNMD->addOperand(MapMetadata( op, ValueMap, RF_MoveDistinctMDs | RF_NullMapMissingGlobalValues, &TypeMap, &GValMaterializer)); } }
/// createCompileUnit - A CompileUnit provides an anchor for all debugging /// information generated during this instance of compilation. void DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer, bool isOptimized, StringRef Flags, unsigned RunTimeVer) { assert(((Lang <= dwarf::DW_LANG_Python && Lang >= dwarf::DW_LANG_C89) || (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) && "Invalid Language tag"); assert(!Filename.empty() && "Unable to create compile unit without filename"); Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) }; TempEnumTypes = MDNode::getTemporary(VMContext, TElts); Value *THElts[] = { TempEnumTypes }; MDNode *EnumHolder = MDNode::get(VMContext, THElts); TempRetainTypes = MDNode::getTemporary(VMContext, TElts); Value *TRElts[] = { TempRetainTypes }; MDNode *RetainHolder = MDNode::get(VMContext, TRElts); TempSubprograms = MDNode::getTemporary(VMContext, TElts); Value *TSElts[] = { TempSubprograms }; MDNode *SPHolder = MDNode::get(VMContext, TSElts); TempGVs = MDNode::getTemporary(VMContext, TElts); Value *TVElts[] = { TempGVs }; MDNode *GVHolder = MDNode::get(VMContext, TVElts); Value *Elts[] = { GetTagConstant(VMContext, dwarf::DW_TAG_compile_unit), Constant::getNullValue(Type::getInt32Ty(VMContext)), ConstantInt::get(Type::getInt32Ty(VMContext), Lang), MDString::get(VMContext, Filename), MDString::get(VMContext, Directory), MDString::get(VMContext, Producer), // Deprecate isMain field. ConstantInt::get(Type::getInt1Ty(VMContext), true), // isMain ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized), MDString::get(VMContext, Flags), ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer), EnumHolder, RetainHolder, SPHolder, GVHolder }; TheCU = DICompileUnit(MDNode::get(VMContext, Elts)); // Create a named metadata so that it is easier to find cu in a module. NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); NMD->addOperand(TheCU); }
/// Find the debug info descriptor corresponding to this function. static Value *findDbgSubprogramDeclare(Function *V) { const Module *M = V->getParent(); NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"); if (!NMD) return 0; for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { DIDescriptor DIG(cast<MDNode>(NMD->getOperand(i))); if (!DIG.isSubprogram()) continue; if (DISubprogram(DIG).getFunction() == V) return DIG; } return 0; }
/// Find the debug info descriptor corresponding to this global variable. static Value *findDbgGlobalDeclare(GlobalVariable *V) { const Module *M = V->getParent(); NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"); if (!NMD) return 0; for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { DIDescriptor DIG(cast<MDNode>(NMD->getOperand(i))); if (!DIG.isGlobalVariable()) continue; if (DIGlobalVariable(DIG).getGlobal() == V) return DIG; } return 0; }
Value *findDbgGlobalDeclare(GlobalVariable *V) { const Module *M = V->getParent(); NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"); if (!NMD) return 0; for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) { DIGlobalVariable DIG(cast_or_null<MDNode>(NMD->getElement(i))); if (DIG.isNull()) continue; if (DIG.getGlobal() == V) return DIG.getNode(); } return 0; }
void Module::convertLibraryListToMetadata() const { if (LibraryList.size() == 0) return; // Get the DepLib node NamedMDNode *Node = getNamedMetadata("DepLibs"); assert(Node && "DepLibs metadata node missing"); // Erase all existing operands Node->dropAllReferences(); // Add all libraries from the library list for (Module::lib_iterator I = lib_begin(), E = lib_end(); I != E; ++I) { MDString *value = MDString::get(getContext(), *I); Node->addOperand(MDNode::get(getContext(), makeArrayRef(static_cast<Value*>(value)))); } }
// @LOCALMOD-BEGIN void Module::convertMetadataToLibraryList() { LibraryList.clear(); // Get the DepLib node NamedMDNode *Node = getNamedMetadata("DepLibs"); if (!Node) return; for (unsigned i = 0; i < Node->getNumOperands(); i++) { MDString* Mds = dyn_cast_or_null<MDString>( Node->getOperand(i)->getOperand(0)); assert(Mds && "Bad NamedMetadata operand"); LibraryList.push_back(Mds->getString()); } // Clear the metadata so the linker won't try to merge it Node->dropAllReferences(); }
CopyConnectedComponent(Module * dest_, Module * src_, llvmutil_Property copyGlobal_, void * data_, ValueToValueMapTy & VMap_) : dest(dest_), src(src_), copyGlobal(copyGlobal_), data(data_), VMap(VMap_), DI(NULL) { if(NamedMDNode * NMD = src->getNamedMetadata("llvm.module.flags")) { NamedMDNode * New = dest->getOrInsertNamedMetadata(NMD->getName()); for (unsigned i = 0; i < NMD->getNumOperands(); i++) { New->addOperand(MapValue(NMD->getOperand(i), VMap)); } } if(NamedMDNode * CUN = src->getNamedMetadata("llvm.dbg.cu")) { DI = new DIBuilder(*dest); DICompileUnit CU(CUN->getOperand(0)); NCU = DI->createCompileUnit(CU.getLanguage(), CU.getFilename(), CU.getDirectory(), CU.getProducer(), CU.isOptimized(), CU.getFlags(), CU.getRunTimeVersion()); } }
bool ReduceCrashingNamedMDOps::TestNamedMDOps( std::vector<const MDNode *> &NamedMDOps) { // Convert list to set for fast lookup... SmallPtrSet<const MDNode *, 32> OldMDNodeOps; for (unsigned i = 0, e = NamedMDOps.size(); i != e; ++i) { OldMDNodeOps.insert(NamedMDOps[i]); } outs() << "Checking for crash with only " << OldMDNodeOps.size(); if (OldMDNodeOps.size() == 1) outs() << " named metadata operand: "; else outs() << " named metadata operands: "; ValueToValueMapTy VMap; Module *M = CloneModule(BD.getProgram(), VMap).release(); // This is a little wasteful. In the future it might be good if we could have // these dropped during cloning. for (auto &NamedMD : BD.getProgram()->named_metadata()) { // Drop the old one and create a new one M->eraseNamedMetadata(M->getNamedMetadata(NamedMD.getName())); NamedMDNode *NewNamedMDNode = M->getOrInsertNamedMetadata(NamedMD.getName()); for (MDNode *op : NamedMD.operands()) if (OldMDNodeOps.count(op)) NewNamedMDNode->addOperand(cast<MDNode>(MapMetadata(op, VMap))); } // Verify that this is still valid. legacy::PassManager Passes; Passes.add(createVerifierPass(/*FatalErrors=*/false)); Passes.run(*M); // Try running on the hacked up program... if (TestFn(BD, M)) { // Make sure to use instruction pointers that point into the now-current // module, and that they don't include any deleted blocks. NamedMDOps.clear(); for (const MDNode *Node : OldMDNodeOps) NamedMDOps.push_back(cast<MDNode>(*VMap.getMappedMD(Node))); BD.setNewProgram(M); // It crashed, keep the trimmed version... return true; } delete M; // It didn't crash, try something else. return false; }
map<string, StateVar*>* IRParser::parseStateVars(Module* module){ map<string, StateVar*>* stateVars = new map<string, StateVar*>(); NamedMDNode* stateVarsMD = module->getNamedMetadata(IRConstant::KEY_STATE_VARS); if (stateVarsMD == NULL) { return stateVars; } for (unsigned i = 0, e = stateVarsMD->getNumOperands(); i != e; ++i) { StateVar* var = parseStateVar(stateVarsMD->getOperand(i)); stateVars->insert(pair<string, StateVar*>(var->getName(), var)); } return stateVars; }
list<Action*>* IRParser::parseActions(string key, Module* module){ list<Action*>* actions = new list<Action*>(); NamedMDNode* inputsMD = module->getNamedMetadata(key); if (inputsMD == NULL) { return actions; } for (unsigned i = 0, e = inputsMD->getNumOperands(); i != e; ++i) { Action* action = parseAction(inputsMD->getOperand(i)); actions->push_back(action); } return actions; }
// StripDebugInfo - Strip debug info in the module if it exists. // To do this, we remove llvm.dbg.func.start, llvm.dbg.stoppoint, and // llvm.dbg.region.end calls, and any globals they point to if now dead. static bool StripDebugInfo(Module &M) { bool Changed = false; // Remove all of the calls to the debugger intrinsics, and remove them from // the module. if (Function *Declare = M.getFunction("llvm.dbg.declare")) { while (!Declare->use_empty()) { CallInst *CI = cast<CallInst>(Declare->use_back()); CI->eraseFromParent(); } Declare->eraseFromParent(); Changed = true; } if (Function *DbgVal = M.getFunction("llvm.dbg.value")) { while (!DbgVal->use_empty()) { CallInst *CI = cast<CallInst>(DbgVal->use_back()); CI->eraseFromParent(); } DbgVal->eraseFromParent(); Changed = true; } for (Module::named_metadata_iterator NMI = M.named_metadata_begin(), NME = M.named_metadata_end(); NMI != NME;) { NamedMDNode *NMD = NMI; ++NMI; if (NMD->getName().startswith("llvm.dbg.")) { NMD->eraseFromParent(); Changed = true; } } for (Module::iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI) for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI) for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI) { if (!BI->getDebugLoc().isUnknown()) { Changed = true; BI->setDebugLoc(DebugLoc()); } } return Changed; }
bool SpecializationTable::addSpecialization(Function* parent, ConstSpecScheme scheme, Function* specialization, bool record) { assert(parent != NULL); assert(specialization != NULL); SpecTable::iterator cursor = this->specialized.find(specialization); //Specialization* spec = this->specialized.lookup(specialization->getName()); if (cursor != this->specialized.end()) { return false; } Specialization* parentSpec = this->getSpecialization(parent); Specialization* spec = new Specialization(); spec->handle = specialization; spec->parent = parentSpec; spec->args = scheme; this->specialized[specialization] = spec; //.GetOrCreateValue(specialization->getName(), spec); parentSpec->children.push_back(spec); #if RECORD_IN_METADATA // Add the meta-data if (record) { NamedMDNode* md = this->module->getOrInsertNamedMetadata( "previrt::specializations"); const unsigned int arg_count = parent->getArgumentList().size(); Value** vals = new Value*[2 + arg_count]; vals[0] = MDString::get(parent->getContext(), parent->getName()); vals[1] = MDString::get(parent->getContext(), specialization->getName()); for (unsigned int i = 0; i < parent->getArgumentList().size(); ++i) { vals[i+2] = scheme[i]; } ArrayRef<Value*> ar_vals(vals, vals+2+arg_count); MDNode* nde = MDNode::get(this->module->getContext(), ar_vals); md->addOperand(nde); } #endif /* RECORD_IN_METADATA */ return true; }