void md::incrementFunctionVersion(llvm::Function &fn) { unsigned newVersion = getFunctionVersion(fn) + 1; auto& ctx = fn.getContext(); ConstantInt* cNewVersion = ConstantInt::get(Type::getInt32Ty(ctx), newVersion); MDNode* versionNode = MDNode::get(ctx, ConstantAsMetadata::get(cNewVersion)); fn.setMetadata("fcd.funver", versionNode); }
void emitValidRemarks(const llvm::Function &F, const Region *R) { LLVMContext &Ctx = F.getContext(); DebugLoc Begin, End; getDebugLocations(R, Begin, End); emitOptimizationRemark(Ctx, DEBUG_TYPE, F, Begin, "A valid Scop begins here."); emitOptimizationRemark(Ctx, DEBUG_TYPE, F, End, "A valid Scop ends here."); }
void emitRejectionRemarks(const llvm::Function &F, const RejectLog &Log) { LLVMContext &Ctx = F.getContext(); const Region *R = Log.region(); DebugLoc Begin, End; getDebugLocations(R, Begin, End); emitOptimizationRemarkMissed( Ctx, DEBUG_TYPE, F, Begin, "The following errors keep this region from being a Scop."); for (RejectReasonPtr RR : Log) { if (const DebugLoc &Loc = RR->getDebugLoc()) emitOptimizationRemarkMissed(Ctx, DEBUG_TYPE, F, Loc, RR->getEndUserMessage()); } emitOptimizationRemarkMissed(Ctx, DEBUG_TYPE, F, End, "Invalid Scop candidate ends here."); }
bool NullDerefProtectionTransformer::runOnFunction(llvm::Function &F) { llvm::IRBuilder<> TheBuilder(F.getContext()); Builder = &TheBuilder; std::vector<llvm::Instruction*> WorkList; for (llvm::inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) { llvm::Instruction* I = &*i; if (llvm::isa<llvm::LoadInst>(I)) WorkList.push_back(I); } for (std::vector<llvm::Instruction*>::iterator i = WorkList.begin(), e = WorkList.end(); i != e; ++i) { Inst = *i; llvm::LoadInst* I = llvm::cast<llvm::LoadInst>(*i); // Find all the instructions that uses the instruction I. for (llvm::Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; ++UI) { // Check whether I is used as the first argument for a load instruction. // If it is, then instrument the load instruction. if (llvm::LoadInst* LI = llvm::dyn_cast<llvm::LoadInst>(*UI)) { llvm::Value* Arg = LI->getOperand(0); if (Arg == I) instrumentInst(LI, Arg); } // Check whether I is used as the second argument for a store // instruction. If it is, then instrument the store instruction. else if (llvm::StoreInst* SI = llvm::dyn_cast<llvm::StoreInst>(*UI)) { llvm::Value* Arg = SI->getOperand(1); if (Arg == I) instrumentInst(SI, Arg); } // Check whether I is used as the first argument for a GEP instruction. // If it is, then instrument the GEP instruction. else if (llvm::GetElementPtrInst* GEP = llvm::dyn_cast< llvm::GetElementPtrInst>(*UI)) { llvm::Value* Arg = GEP->getOperand(0); if (Arg == I) instrumentInst(GEP, Arg); } else { // Check whether I is used as the first argument for a call instruction. // If it is, then instrument the call instruction. llvm::CallSite CS(*UI); if (CS) { llvm::CallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end(); if (i != e) { llvm::Value *Arg = *i; if (Arg == I) instrumentInst(CS.getInstruction(), Arg); } } } } } return true; }