diff options
Diffstat (limited to 'llvm/lib')
22 files changed, 932 insertions, 19 deletions
diff --git a/llvm/lib/Analysis/IPA/InlineCost.cpp b/llvm/lib/Analysis/IPA/InlineCost.cpp index c0d2e375cb0..213644c9b43 100644 --- a/llvm/lib/Analysis/IPA/InlineCost.cpp +++ b/llvm/lib/Analysis/IPA/InlineCost.cpp @@ -156,6 +156,8 @@ class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> { bool visitSwitchInst(SwitchInst &SI); bool visitIndirectBrInst(IndirectBrInst &IBI); bool visitResumeInst(ResumeInst &RI); + bool visitCleanupReturnInst(CleanupReturnInst &RI); + bool visitCatchReturnInst(CatchReturnInst &RI); bool visitUnreachableInst(UnreachableInst &I); public: @@ -903,6 +905,18 @@ bool CallAnalyzer::visitResumeInst(ResumeInst &RI) { return false; } +bool CallAnalyzer::visitCleanupReturnInst(CleanupReturnInst &CRI) { + // FIXME: It's not clear that a single instruction is an accurate model for + // the inline cost of a cleanupret instruction. + return false; +} + +bool CallAnalyzer::visitCatchReturnInst(CatchReturnInst &CRI) { + // FIXME: It's not clear that a single instruction is an accurate model for + // the inline cost of a cleanupret instruction. + return false; +} + bool CallAnalyzer::visitUnreachableInst(UnreachableInst &I) { // FIXME: It might be reasonably to discount the cost of instructions leading // to unreachable as they have the lowest possible impact on both runtime and diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp index 88f359d4fd5..69c2048aae2 100644 --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -524,6 +524,7 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(undef); KEYWORD(null); KEYWORD(to); + KEYWORD(caller); KEYWORD(tail); KEYWORD(musttail); KEYWORD(target); @@ -748,6 +749,12 @@ lltok::Kind LLLexer::LexIdentifier() { INSTKEYWORD(extractvalue, ExtractValue); INSTKEYWORD(insertvalue, InsertValue); INSTKEYWORD(landingpad, LandingPad); + INSTKEYWORD(cleanupret, CleanupRet); + INSTKEYWORD(catchret, CatchRet); + INSTKEYWORD(catchblock, CatchBlock); + INSTKEYWORD(terminateblock, TerminateBlock); + INSTKEYWORD(cleanupblock, CleanupBlock); + INSTKEYWORD(catchendblock, CatchEndBlock); #undef INSTKEYWORD #define DWKEYWORD(TYPE, TOKEN) \ diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index 91a88bc91fd..4e28410abdc 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -4489,6 +4489,12 @@ int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); case lltok::kw_invoke: return ParseInvoke(Inst, PFS); case lltok::kw_resume: return ParseResume(Inst, PFS); + case lltok::kw_cleanupret: return ParseCleanupRet(Inst, PFS); + case lltok::kw_catchret: return ParseCatchRet(Inst, PFS); + case lltok::kw_catchblock: return ParseCatchBlock(Inst, PFS); + case lltok::kw_terminateblock: return ParseTerminateBlock(Inst, PFS); + case lltok::kw_cleanupblock: return ParseCleanupBlock(Inst, PFS); + case lltok::kw_catchendblock: return ParseCatchEndBlock(Inst, PFS); // Binary Operators. case lltok::kw_add: case lltok::kw_sub: @@ -4882,6 +4888,161 @@ bool LLParser::ParseResume(Instruction *&Inst, PerFunctionState &PFS) { return false; } +bool LLParser::ParseExceptionArgs(SmallVectorImpl<Value *> &Args, + PerFunctionState &PFS) { + if (ParseToken(lltok::lsquare, "expected '[' in cleanupblock")) + return true; + + while (Lex.getKind() != lltok::rsquare) { + // If this isn't the first argument, we need a comma. + if (!Args.empty() && + ParseToken(lltok::comma, "expected ',' in argument list")) + return true; + + // Parse the argument. + LocTy ArgLoc; + Type *ArgTy = nullptr; + if (ParseType(ArgTy, ArgLoc)) + return true; + + Value *V; + if (ArgTy->isMetadataTy()) { + if (ParseMetadataAsValue(V, PFS)) + return true; + } else { + if (ParseValue(ArgTy, V, PFS)) + return true; + } + Args.push_back(V); + } + + Lex.Lex(); // Lex the ']'. + return false; +} + +/// ParseCleanupRet +/// ::= 'cleanupret' ('void' | TypeAndValue) unwind ('to' 'caller' | TypeAndValue) +bool LLParser::ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) { + Type *RetTy = nullptr; + Value *RetVal = nullptr; + if (ParseType(RetTy, /*AllowVoid=*/true)) + return true; + + if (!RetTy->isVoidTy()) + if (ParseValue(RetTy, RetVal, PFS)) + return true; + + if (ParseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret")) + return true; + + BasicBlock *UnwindBB = nullptr; + if (Lex.getKind() == lltok::kw_to) { + Lex.Lex(); + if (ParseToken(lltok::kw_caller, "expected 'caller' in cleanupret")) + return true; + } else { + if (ParseTypeAndBasicBlock(UnwindBB, PFS)) { + return true; + } + } + + Inst = CleanupReturnInst::Create(Context, RetVal, UnwindBB); + return false; +} + +/// ParseCatchRet +/// ::= 'catchret' TypeAndValue +bool LLParser::ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS) { + BasicBlock *BB; + if (ParseTypeAndBasicBlock(BB, PFS)) + return true; + + Inst = CatchReturnInst::Create(BB); + return false; +} + +/// ParseCatchBlock +/// ::= 'catchblock' Type ParamList 'to' TypeAndValue 'unwind' TypeAndValue +bool LLParser::ParseCatchBlock(Instruction *&Inst, PerFunctionState &PFS) { + Type *RetType = nullptr; + + SmallVector<Value *, 8> Args; + if (ParseType(RetType, /*AllowVoid=*/true) || ParseExceptionArgs(Args, PFS)) + return true; + + BasicBlock *NormalBB, *UnwindBB; + if (ParseToken(lltok::kw_to, "expected 'to' in catchblock") || + ParseTypeAndBasicBlock(NormalBB, PFS) || + ParseToken(lltok::kw_unwind, "expected 'unwind' in catchblock") || + ParseTypeAndBasicBlock(UnwindBB, PFS)) + return true; + + Inst = CatchBlockInst::Create(RetType, NormalBB, UnwindBB, Args); + return false; +} + +/// ParseTerminateBlock +/// ::= 'terminateblock' ParamList 'to' TypeAndValue +bool LLParser::ParseTerminateBlock(Instruction *&Inst, PerFunctionState &PFS) { + SmallVector<Value *, 8> Args; + if (ParseExceptionArgs(Args, PFS)) + return true; + + if (ParseToken(lltok::kw_unwind, "expected 'unwind' in terminateblock")) + return true; + + BasicBlock *UnwindBB = nullptr; + if (Lex.getKind() == lltok::kw_to) { + Lex.Lex(); + if (ParseToken(lltok::kw_caller, "expected 'caller' in cleanupret")) + return true; + } else { + if (ParseTypeAndBasicBlock(UnwindBB, PFS)) { + return true; + } + } + + Inst = TerminateBlockInst::Create(Context, UnwindBB, Args); + return false; +} + +/// ParseCleanupBlock +/// ::= 'cleanupblock' ParamList +bool LLParser::ParseCleanupBlock(Instruction *&Inst, PerFunctionState &PFS) { + Type *RetType = nullptr; + + SmallVector<Value *, 8> Args; + if (ParseType(RetType, /*AllowVoid=*/true) || ParseExceptionArgs(Args, PFS)) + return true; + + Inst = CleanupBlockInst::Create(RetType, Args); + return false; +} + +/// ParseCatchEndBlock +/// ::= 'catchendblock' unwind ('to' 'caller' | TypeAndValue) +bool LLParser::ParseCatchEndBlock(Instruction *&Inst, PerFunctionState &PFS) { + if (ParseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret")) + return true; + + BasicBlock *UnwindBB = nullptr; + if (Lex.getKind() == lltok::kw_to) { + Lex.Lex(); + if (Lex.getKind() == lltok::kw_caller) { + Lex.Lex(); + } else { + return true; + } + } else { + if (ParseTypeAndBasicBlock(UnwindBB, PFS)) { + return true; + } + } + + Inst = CatchEndBlockInst::Create(Context, UnwindBB); + return false; +} + //===----------------------------------------------------------------------===// // Binary Operators. //===----------------------------------------------------------------------===// diff --git a/llvm/lib/AsmParser/LLParser.h b/llvm/lib/AsmParser/LLParser.h index 6e57b3e0667..2a39b6d364d 100644 --- a/llvm/lib/AsmParser/LLParser.h +++ b/llvm/lib/AsmParser/LLParser.h @@ -381,6 +381,9 @@ namespace llvm { bool IsMustTailCall = false, bool InVarArgsFunc = false); + bool ParseExceptionArgs(SmallVectorImpl<Value *> &Args, + PerFunctionState &PFS); + // Constant Parsing. bool ParseValID(ValID &ID, PerFunctionState *PFS = nullptr); bool ParseGlobalValue(Type *Ty, Constant *&V); @@ -441,6 +444,12 @@ namespace llvm { bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS); bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS); bool ParseResume(Instruction *&Inst, PerFunctionState &PFS); + bool ParseCleanupRet(Instruction *&Inst, PerFunctionState &PFS); + bool ParseCatchRet(Instruction *&Inst, PerFunctionState &PFS); + bool ParseCatchBlock(Instruction *&Inst, PerFunctionState &PFS); + bool ParseTerminateBlock(Instruction *&Inst, PerFunctionState &PFS); + bool ParseCleanupBlock(Instruction *&Inst, PerFunctionState &PFS); + bool ParseCatchEndBlock(Instruction *&Inst, PerFunctionState &PFS); bool ParseArithmetic(Instruction *&I, PerFunctionState &PFS, unsigned Opc, unsigned OperandType); diff --git a/llvm/lib/AsmParser/LLToken.h b/llvm/lib/AsmParser/LLToken.h index 2487d120813..6e24224978e 100644 --- a/llvm/lib/AsmParser/LLToken.h +++ b/llvm/lib/AsmParser/LLToken.h @@ -51,6 +51,7 @@ namespace lltok { kw_zeroinitializer, kw_undef, kw_null, kw_to, + kw_caller, kw_tail, kw_musttail, kw_target, @@ -176,7 +177,8 @@ namespace lltok { kw_landingpad, kw_personality, kw_cleanup, kw_catch, kw_filter, kw_ret, kw_br, kw_switch, kw_indirectbr, kw_invoke, kw_resume, - kw_unreachable, + kw_unreachable, kw_cleanupret, kw_catchret, kw_catchblock, + kw_terminateblock, kw_cleanupblock, kw_catchendblock, kw_alloca, kw_load, kw_store, kw_fence, kw_cmpxchg, kw_atomicrmw, kw_getelementptr, diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 563e201336a..f13fc0476eb 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -3793,6 +3793,134 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) { } break; } + // CLEANUPRET: [] or [ty,val] or [bb#] or [ty,val,bb#] + case bitc::FUNC_CODE_INST_CLEANUPRET: { + if (Record.size() < 2) + return error("Invalid record"); + unsigned Idx = 0; + bool HasReturnValue = !!Record[Idx++]; + bool HasUnwindDest = !!Record[Idx++]; + Value *RetVal = nullptr; + BasicBlock *UnwindDest = nullptr; + + if (HasReturnValue && getValueTypePair(Record, Idx, NextValueNo, RetVal)) + return error("Invalid record"); + if (HasUnwindDest) { + if (Idx == Record.size()) + return error("Invalid record"); + UnwindDest = getBasicBlock(Record[Idx++]); + if (!UnwindDest) + return error("Invalid record"); + } + + if (Record.size() != Idx) + return error("Invalid record"); + + I = CleanupReturnInst::Create(Context, RetVal, UnwindDest); + InstructionList.push_back(I); + break; + } + case bitc::FUNC_CODE_INST_CATCHRET: { // CATCHRET: [bb#] + if (Record.size() != 1) + return error("Invalid record"); + BasicBlock *BB = getBasicBlock(Record[0]); + if (!BB) + return error("Invalid record"); + I = CatchReturnInst::Create(BB); + InstructionList.push_back(I); + break; + } + case bitc::FUNC_CODE_INST_CATCHBLOCK: { // CATCHBLOCK: [ty,bb#,bb#,num,(ty,val)*] + if (Record.size() < 4) + return error("Invalid record"); + unsigned Idx = 0; + Type *Ty = getTypeByID(Record[Idx++]); + if (!Ty) + return error("Invalid record"); + BasicBlock *NormalBB = getBasicBlock(Record[Idx++]); + if (!NormalBB) + return error("Invalid record"); + BasicBlock *UnwindBB = getBasicBlock(Record[Idx++]); + if (!UnwindBB) + return error("Invalid record"); + unsigned NumArgOperands = Record[Idx++]; + SmallVector<Value *, 2> Args; + for (unsigned Op = 0; Op != NumArgOperands; ++Op) { + Value *Val; + if (getValueTypePair(Record, Idx, NextValueNo, Val)) + return error("Invalid record"); + Args.push_back(Val); + } + if (Record.size() != Idx) + return error("Invalid record"); + + I = CatchBlockInst::Create(Ty, NormalBB, UnwindBB, Args); + InstructionList.push_back(I); + break; + } + case bitc::FUNC_CODE_INST_TERMINATEBLOCK: { // TERMINATEBLOCK: [bb#,num,(ty,val)*] + if (Record.size() < 1) + return error("Invalid record"); + unsigned Idx = 0; + bool HasUnwindDest = !!Record[Idx++]; + BasicBlock *UnwindDest = nullptr; + if (HasUnwindDest) { + if (Idx == Record.size()) + return error("Invalid record"); + UnwindDest = getBasicBlock(Record[Idx++]); + if (!UnwindDest) + return error("Invalid record"); + } + unsigned NumArgOperands = Record[Idx++]; + SmallVector<Value *, 2> Args; + for (unsigned Op = 0; Op != NumArgOperands; ++Op) { + Value *Val; + if (getValueTypePair(Record, Idx, NextValueNo, Val)) + return error("Invalid record"); + Args.push_back(Val); + } + if (Record.size() != Idx) + return error("Invalid record"); + + I = TerminateBlockInst::Create(Context, UnwindDest, Args); + InstructionList.push_back(I); + break; + } + case bitc::FUNC_CODE_INST_CLEANUPBLOCK: { // CLEANUPBLOCK: [ty, num,(ty,val)*] + if (Record.size() < 2) + return error("Invalid record"); + unsigned Idx = 0; + Type *Ty = getTypeByID(Record[Idx++]); + if (!Ty) + return error("Invalid record"); + unsigned NumArgOperands = Record[Idx++]; + SmallVector<Value *, 2> Args; + for (unsigned Op = 0; Op != NumArgOperands; ++Op) { + Value *Val; + if (getValueTypePair(Record, Idx, NextValueNo, Val)) + return error("Invalid record"); + Args.push_back(Val); + } + if (Record.size() != Idx) + return error("Invalid record"); + + I = CleanupBlockInst::Create(Ty, Args); + InstructionList.push_back(I); + break; + } + case bitc::FUNC_CODE_INST_CATCHENDBLOCK: { // CATCHENDBLOCKINST: [bb#] or [] + if (Record.size() > 1) + return error("Invalid record"); + BasicBlock *BB = nullptr; + if (Record.size() == 1) { + BB = getBasicBlock(Record[0]); + if (!BB) + return error("Invalid record"); + } + I = CatchEndBlockInst::Create(Context, BB); + InstructionList.push_back(I); + break; + } case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] // Check magic if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 622f7eaf078..c1fd66668f8 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -1845,6 +1845,64 @@ static void WriteInstruction(const Instruction &I, unsigned InstID, Code = bitc::FUNC_CODE_INST_RESUME; PushValueAndType(I.getOperand(0), InstID, Vals, VE); break; + case Instruction::CleanupRet: { + Code = bitc::FUNC_CODE_INST_CLEANUPRET; + const auto &CRI = cast<CleanupReturnInst>(I); + Vals.push_back(CRI.hasReturnValue()); + Vals.push_back(CRI.hasUnwindDest()); + if (CRI.hasReturnValue()) + PushValueAndType(CRI.getReturnValue(), InstID, Vals, VE); + if (CRI.hasUnwindDest()) + Vals.push_back(VE.getValueID(CRI.getUnwindDest())); + break; + } + case Instruction::CatchRet: { + Code = bitc::FUNC_CODE_INST_CATCHRET; + const auto &CRI = cast<CatchReturnInst>(I); + Vals.push_back(VE.getValueID(CRI.getSuccessor())); + break; + } + case Instruction::CatchBlock: { + Code = bitc::FUNC_CODE_INST_CATCHBLOCK; + const auto &CBI = cast<CatchBlockInst>(I); + Vals.push_back(VE.getTypeID(CBI.getType())); + Vals.push_back(VE.getValueID(CBI.getNormalDest())); + Vals.push_back(VE.getValueID(CBI.getUnwindDest())); + unsigned NumArgOperands = CBI.getNumArgOperands(); + Vals.push_back(NumArgOperands); + for (unsigned Op = 0; Op != NumArgOperands; ++Op) + PushValueAndType(CBI.getArgOperand(Op), InstID, Vals, VE); + break; + } + case Instruction::TerminateBlock: { + Code = bitc::FUNC_CODE_INST_TERMINATEBLOCK; + const auto &TBI = cast<TerminateBlockInst>(I); + Vals.push_back(TBI.hasUnwindDest()); + if (TBI.hasUnwindDest()) + Vals.push_back(VE.getValueID(TBI.getUnwindDest())); + unsigned NumArgOperands = TBI.getNumArgOperands(); + Vals.push_back(NumArgOperands); + for (unsigned Op = 0; Op != NumArgOperands; ++Op) + PushValueAndType(TBI.getArgOperand(Op), InstID, Vals, VE); + break; + } + case Instruction::CleanupBlock: { + Code = bitc::FUNC_CODE_INST_CLEANUPBLOCK; + const auto &CBI = cast<CleanupBlockInst>(I); + Vals.push_back(VE.getTypeID(CBI.getType())); + unsigned NumOperands = CBI.getNumOperands(); + Vals.push_back(NumOperands); + for (unsigned Op = 0; Op != NumOperands; ++Op) + PushValueAndType(CBI.getOperand(Op), InstID, Vals, VE); + break; + } + case Instruction::CatchEndBlock: { + Code = bitc::FUNC_CODE_INST_CATCHENDBLOCK; + const auto &CEBI = cast<CatchEndBlockInst>(I); + if (CEBI.hasUnwindDest()) + Vals.push_back(VE.getValueID(CEBI.getUnwindDest())); + break; + } case Instruction::Unreachable: Code = bitc::FUNC_CODE_INST_UNREACHABLE; AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV; diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 2c3c0eb101a..05010ecf7e1 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -1168,6 +1168,30 @@ SDValue SelectionDAGBuilder::getValueImpl(const Value *V) { llvm_unreachable("Can't get register for value!"); } +void SelectionDAGBuilder::visitCleanupRet(const CleanupReturnInst &I) { + report_fatal_error("visitCleanupRet not yet implemented!"); +} + +void SelectionDAGBuilder::visitCatchEndBlock(const CatchEndBlockInst &I) { + report_fatal_error("visitCatchEndBlock not yet implemented!"); +} + +void SelectionDAGBuilder::visitCatchRet(const CatchReturnInst &I) { + report_fatal_error("visitCatchRet not yet implemented!"); +} + +void SelectionDAGBuilder::visitCatchBlock(const CatchBlockInst &I) { + report_fatal_error("visitCatchBlock not yet implemented!"); +} + +void SelectionDAGBuilder::visitTerminateBlock(const TerminateBlockInst &TBI) { + report_fatal_error("visitTerminateBlock not yet implemented!"); +} + +void SelectionDAGBuilder::visitCleanupBlock(const CleanupBlockInst &TBI) { + report_fatal_error("visitCleanupBlock not yet implemented!"); +} + void SelectionDAGBuilder::visitRet(const ReturnInst &I) { const TargetLowering &TLI = DAG.getTargetLoweringInfo(); auto &DL = DAG.getDataLayout(); diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h index 700675453fe..df85e233b79 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h @@ -734,6 +734,12 @@ private: void visitSwitch(const SwitchInst &I); void visitIndirectBr(const IndirectBrInst &I); void visitUnreachable(const UnreachableInst &I); + void visitCleanupRet(const CleanupReturnInst &I); + void visitCatchEndBlock(const CatchEndBlockInst &I); + void visitCatchRet(const CatchReturnInst &I); + void visitCatchBlock(const CatchBlockInst &I); + void visitTerminateBlock(const TerminateBlockInst &TBI); + void visitCleanupBlock(const CleanupBlockInst &CBI); uint32_t getEdgeWeight(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const; diff --git a/llvm/lib/CodeGen/TargetLoweringBase.cpp b/llvm/lib/CodeGen/TargetLoweringBase.cpp index ecfd6593157..b8ddcfe01b7 100644 --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp @@ -1546,6 +1546,12 @@ int TargetLoweringBase::InstructionOpcodeToISD(unsigned Opcode) const { case Invoke: return 0; case Resume: return 0; case Unreachable: return 0; + case CleanupRet: return 0; + case CatchEndBlock: return 0; + case CatchRet: return 0; + case CatchBlock: return 0; + case TerminateBlock: return 0; + case CleanupBlock: return 0; case Add: return ISD::ADD; case FAdd: return ISD::FADD; case Sub: return ISD::SUB; diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp index adc620db897..a866828c31b 100644 --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -2848,8 +2848,66 @@ void AssemblyWriter::printInstruction(const Instruction &I) { writeOperand(LPI->getClause(i), true); } + } else if (const auto *CBI = dyn_cast<CatchBlockInst>(&I)) { + Out << ' '; + TypePrinter.print(I.getType(), Out); + + Out << " ["; + for (unsigned Op = 0, NumOps = CBI->getNumArgOperands(); Op < NumOps; + ++Op) { + if (Op > 0) + Out << ", "; + writeOperand(CBI->getArgOperand(Op), /*PrintType=*/true); + } + Out << "] to "; + writeOperand(CBI->getNormalDest(), /*PrintType=*/true); + Out << " unwind "; + writeOperand(CBI->getUnwindDest(), /*PrintType=*/true); + } else if (const auto *TBI = dyn_cast<TerminateBlockInst>(&I)) { + Out << " ["; + for (unsigned Op = 0, NumOps = TBI->getNumArgOperands(); Op < NumOps; + ++Op) { + if (Op > 0) + Out << ", "; + writeOperand(TBI->getArgOperand(Op), /*PrintType=*/true); + } + Out << "] unwind "; + if (TBI->hasUnwindDest()) + writeOperand(TBI->getUnwindDest(), /*PrintType=*/true); + else + Out << "to caller"; + } else if (const auto *CBI = dyn_cast<CleanupBlockInst>(&I)) { + Out << ' '; + TypePrinter.print(I.getType(), Out); + + Out << " ["; + for (unsigned Op = 0, NumOps = CBI->getNumOperands(); Op < NumOps; ++Op) { + if (Op > 0) + Out << ", "; + writeOperand(CBI->getOperand(Op), /*PrintType=*/true); + } + Out << "]"; } else if (isa<ReturnInst>(I) && !Operand) { Out << " void"; + } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) { + if (CRI->hasReturnValue()) { + Out << ' '; + writeOperand(CRI->getReturnValue(), /*PrintType=*/true); + } else { + Out << " void"; + } + + Out << " unwind "; + if (CRI->hasUnwindDest()) + writeOperand(CRI->getUnwindDest(), /*PrintType=*/true); + else + Out << "to caller"; + } else if (const auto *CEBI = dyn_cast<CatchEndBlockInst>(&I)) { + Out << " unwind "; + if (CEBI->hasUnwindDest()) + writeOperand(CEBI->getUnwindDest(), /*PrintType=*/true); + else + Out << "to caller"; } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) { // Print the calling convention being used. if (CI->getCallingConv() != CallingConv::C) { diff --git a/llvm/lib/IR/BasicBlock.cpp b/llvm/lib/IR/BasicBlock.cpp index 0a0449434a7..658c5e24216 100644 --- a/llvm/lib/IR/BasicBlock.cpp +++ b/llvm/lib/IR/BasicBlock.cpp @@ -197,7 +197,7 @@ BasicBlock::iterator BasicBlock::getFirstInsertionPt() { return end(); iterator InsertPt = FirstNonPHI; - if (isa<LandingPadInst>(InsertPt)) ++InsertPt; + if (InsertPt->isEHBlock()) ++InsertPt; return InsertPt; } diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp index c57ba16cf6c..124bf089321 100644 --- a/llvm/lib/IR/Instruction.cpp +++ b/llvm/lib/IR/Instruction.cpp @@ -196,6 +196,11 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case Invoke: return "invoke"; case Resume: return "resume"; case Unreachable: return "unreachable"; + case CleanupRet: return "cleanupret"; + case CatchEndBlock: return "catchendblock"; + case CatchRet: return "catchret"; + case CatchBlock: return "catchblock"; + case TerminateBlock: return "terminateblock"; // Standard binary operators... case Add: return "add"; @@ -256,6 +261,7 @@ const char *Instruction::getOpcodeName(unsigned OpCode) { case ExtractValue: return "extractvalue"; case InsertValue: return "insertvalue"; case LandingPad: return "landingpad"; + case CleanupBlock: return "cleanupblock"; default: return "<Invalid operator> "; } @@ -407,6 +413,8 @@ bool Instruction::mayReadFromMemory() const { case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory case Instruction::AtomicCmpXchg: case Instruction::AtomicRMW: + case Instruction::CatchRet: + case Instruction::TerminateBlock: return true; case Instruction::Call: return !cast<CallInst>(this)->doesNotAccessMemory(); @@ -427,6 +435,8 @@ bool Instruction::mayWriteToMemory() const { case Instruction::VAArg: case Instruction::AtomicCmpXchg: case Instruction::AtomicRMW: + case Instruction::CatchRet: + case Instruction::TerminateBlock: return true; case Instruction::Call: return !cast<CallInst>(this)->onlyReadsMemory(); @@ -455,6 +465,10 @@ bool Instruction::isAtomic() const { bool Instruction::mayThrow() const { if (const CallInst *CI = dyn_cast<CallInst>(this)) return !CI->doesNotThrow(); + if (const auto *CRI = dyn_cast<CleanupReturnInst>(this)) + return CRI->unwindsToCaller(); + if (const auto *CEBI = dyn_cast<CatchEndBlockInst>(this)) + return CEBI->unwindsToCaller(); return isa<ResumeInst>(this); } diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 86c921aeda8..02cb1205da9 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -671,6 +671,303 @@ BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const { } //===----------------------------------------------------------------------===// +// CleanupReturnInst Implementation +//===----------------------------------------------------------------------===// + +CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI) + : TerminatorInst(CRI.getType(), Instruction::CleanupRet, + OperandTraits<CleanupReturnInst>::op_end(this) - + CRI.getNumOperands(), + CRI.getNumOperands()) { + SubclassOptionalData = CRI.SubclassOptionalData; + if (Value *RetVal = CRI.getReturnValue()) + setReturnValue(RetVal); + if (BasicBlock *UnwindDest = CRI.getUnwindDest()) + setUnwindDest(UnwindDest); +} + +void CleanupReturnInst::init(Value *RetVal, BasicBlock *UnwindBB) { + SubclassOptionalData = 0; + if (UnwindBB) + setInstructionSubclassData(getSubclassDataFromInstruction() | 1); + if (RetVal) + setInstructionSubclassData(getSubclassDataFromInstruction() | 2); + + if (UnwindBB) + setUnwindDest(UnwindBB); + if (RetVal) + setReturnValue(RetVal); +} + +CleanupReturnInst::CleanupReturnInst(LLVMContext &C, Value *RetVal, + BasicBlock *UnwindBB, unsigned Values, + Instruction *InsertBefore) + : TerminatorInst(Type::getVoidTy(C), Instruction::CleanupRet, + OperandTraits<CleanupReturnInst>::op_end(this) - Values, + Values, InsertBefore) { + init(RetVal, UnwindBB); +} + +CleanupReturnInst::CleanupReturnInst(LLVMContext &C, Value *RetVal, + BasicBlock *UnwindBB, unsigned Values, + BasicBlock *InsertAtEnd) + : TerminatorInst(Type::getVoidTy(C), Instruction::CleanupRet, + OperandTraits<CleanupReturnInst>::op_end(this) - Values, + Values, InsertAtEnd) { + init(RetVal, UnwindBB); +} + +BasicBlock *CleanupReturnInst::getUnwindDest() const { + if (hasUnwindDest()) + return cast<BasicBlock>(getOperand(getUnwindLabelOpIdx())); + return nullptr; +} +void CleanupReturnInst::setUnwindDest(BasicBlock *NewDest) { + assert(NewDest); + setOperand(getUnwindLabelOpIdx(), NewDest); +} + +BasicBlock *CleanupReturnInst::getSuccessorV(unsigned Idx) const { + assert(Idx == 0); + return getUnwindDest(); +} +unsigned CleanupReturnInst::getNumSuccessorsV() const { + return getNumSuccessors(); +} +void CleanupReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) { + assert(Idx == 0); + setUnwindDest(B); +} + +//===----------------------------------------------------------------------===// +// CatchEndBlockInst Implementation +//===----------------------------------------------------------------------===// + +CatchEndBlockInst::CatchEndBlockInst(const CatchEndBlockInst &CRI) + : TerminatorInst(CRI.getType(), Instruction::CatchEndBlock, + OperandTraits<CatchEndBlockInst>::op_end(this) - + CRI.getNumOperands(), + CRI.getNumOperands()) { + SubclassOptionalData = CRI.SubclassOptionalData; + if (BasicBlock *UnwindDest = CRI.getUnwindDest()) + setUnwindDest(UnwindDest); +} + +void CatchEndBlockInst::init(BasicBlock *UnwindBB) { + SubclassOptionalData = 0; + if (UnwindBB) { + setInstructionSubclassData(getSubclassDataFromInstruction() | 1); + setUnwindDest(UnwindBB); + } +} + +CatchEndBlockInst::CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB, + unsigned Values, Instruction *InsertBefore) + : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndBlock, + OperandTraits<CatchEndBlockInst>::op_end(this) - Values, + Values, InsertBefore) { + init(UnwindBB); +} + +CatchEndBlockInst::CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB, + unsigned Values, BasicBlock *InsertAtEnd) + : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndBlock, + OperandTraits<CatchEndBlockInst>::op_end(this) - Values, + Values, InsertAtEnd) { + init(UnwindBB); +} + +BasicBlock *CatchEndBlockInst::getSuccessorV(unsigned Idx) const { + assert(Idx == 0); + return getUnwindDest(); +} +unsigned CatchEndBlockInst::getNumSuccessorsV() const { + return getNumSuccessors(); +} +void CatchEndBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) { + assert(Idx == 0); + setUnwindDest(B); +} + +//===----------------------------------------------------------------------===// +// CatchReturnInst Implementation +//===----------------------------------------------------------------------===// + +CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI) + : TerminatorInst(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet, + OperandTraits<CatchReturnInst>::op_end(this) - + CRI.getNumOperands(), + CRI.getNumOperands()) { + Op<0>() = CRI.Op<0>(); +} + +CatchReturnInst::CatchReturnInst(BasicBlock *BB, Instruction *InsertBefore) + : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, + OperandTraits<CatchReturnInst>::op_begin(this), 1, + InsertBefore) { + Op<0>() = BB; +} + +CatchReturnInst::CatchReturnInst(BasicBlock *BB, BasicBlock *InsertAtEnd) + : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, + OperandTraits<CatchReturnInst>::op_begin(this), 1, + InsertAtEnd) { + Op<0>() = BB; +} + +BasicBlock *CatchReturnInst::getSuccessorV(unsigned Idx) const { + assert(Idx == 0); + return getSuccessor(); +} +unsigned CatchReturnInst::getNumSuccessorsV() const { + return getNumSuccessors(); +} +void CatchReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) { + assert(Idx == 0); + setSuccessor(B); +} + +//===----------------------------------------------------------------------===// +// CatchBlockInst Implementation +//===----------------------------------------------------------------------===// +void CatchBlockInst::init(BasicBlock *IfNormal, BasicBlock *IfException, + ArrayRef<Value *> Args, const Twine &NameStr) { + assert(getNumOperands() == 2 + Args.size() && "NumOperands not set up?"); + Op<-2>() = IfNormal; + Op<-1>() = IfException; + std::copy(Args.begin(), Args.end(), op_begin()); + setName(NameStr); +} + +CatchBlockInst::CatchBlockInst(const CatchBlockInst &CBI) + : TerminatorInst(CBI.getType(), Instruction::CatchBlock, + OperandTraits<CatchBlockInst>::op_end(this) - + CBI.getNumOperands(), + CBI.getNumOperands()) { + std::copy(CBI.op_begin(), CBI.op_end(), op_begin()); +} + +CatchBlockInst::CatchBlockInst(Type *RetTy, BasicBlock *IfNormal, + BasicBlock *IfException, ArrayRef<Value *> Args, + unsigned Values, const Twine &NameStr, + Instruction *InsertBefore) + : TerminatorInst(RetTy, Instruction::CatchBlock, + OperandTraits<CatchBlockInst>::op_end(this) - Values, + Values, InsertBefore) { + init(IfNormal, IfException, Args, NameStr); +} + +CatchBlockInst::CatchBlockInst(Type *RetTy, BasicBlock *IfNormal, + BasicBlock *IfException, ArrayRef<Value *> Args, + unsigned Values, const Twine &NameStr, + BasicBlock *InsertAtEnd) + : TerminatorInst(RetTy, Instruction::CatchBlock, + OperandTraits<CatchBlockInst>::op_end(this) - Values, + Values, InsertAtEnd) { + init(IfNormal, IfException, Args, NameStr); +} + +BasicBlock *CatchBlockInst::getSuccessorV(unsigned Idx) const { + return getSuccessor(Idx); +} +unsigned CatchBlockInst::getNumSuccessorsV() const { + return getNumSuccessors(); +} +void CatchBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) { + return setSuccessor(Idx, B); +} + +//===----------------------------------------------------------------------===// +// TerminateBlockInst Implementation +//===----------------------------------------------------------------------===// +void TerminateBlockInst::init(BasicBlock *BB, ArrayRef<Value *> Args, + const Twine &NameStr) { + SubclassOptionalData = 0; + if (BB) + setInstructionSubclassData(getSubclassDataFromInstruction() | 1); + if (BB) + Op<-1>() = BB; + std::copy(Args.begin(), Args.end(), op_begin()); + setName(NameStr); +} + +TerminateBlockInst::TerminateBlockInst(const TerminateBlockInst &TBI) + : TerminatorInst(TBI.getType(), Instruction::TerminateBlock, + OperandTraits<TerminateBlockInst>::op_end(this) - + TBI.getNumOperands(), + TBI.getNumOperands()) { + SubclassOptionalData = TBI.SubclassOptionalData; + std::copy(TBI.op_begin(), TBI.op_end(), op_begin()); +} + +TerminateBlockInst::TerminateBlockInst(LLVMContext &C, BasicBlock *BB, + ArrayRef<Value *> Args, unsigned Values, + const Twine &NameStr, + Instruction *InsertBefore) + : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock, + OperandTraits<TerminateBlockInst>::op_end(this) - Values, + Values, InsertBefore) { + init(BB, Args, NameStr); +} + +TerminateBlockInst::TerminateBlockInst(LLVMContext &C, BasicBlock *BB, + ArrayRef<Value *> Args, unsigned Values, + const Twine &NameStr, + BasicBlock *InsertAtEnd) + : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock, + OperandTraits<TerminateBlockInst>::op_end(this) - Values, + Values, InsertAtEnd) { + init(BB, Args, NameStr); +} + +BasicBlock *TerminateBlockInst::getSuccessorV(unsigned Idx) const { + assert(Idx == 0); + return getUnwindDest(); +} +unsigned TerminateBlockInst::getNumSuccessorsV() const { + return getNumSuccessors(); +} +void TerminateBlockInst::setSuccessorV(unsigned Idx, BasicBlock *B) { + assert(Idx == 0); + return setUnwindDest(B); +} + +//===----------------------------------------------------------------------===// +// CleanupBlockInst Implementation +//===----------------------------------------------------------------------===// +void CleanupBlockInst::init(ArrayRef<Value *> Args, const Twine &NameStr) { + assert(getNumOperands() == Args.size() && "NumOperands not set up?"); + std::copy(Args.begin(), Args.end(), op_begin()); + setName(NameStr); +} + +CleanupBlockInst::CleanupBlockInst(const CleanupBlockInst &CBI) + : Instruction(CBI.getType(), Instruction::CleanupBlock, + OperandTraits<CleanupBlockInst>::op_end(this) - + CBI.getNumOperands(), + CBI.getNumOperands()) { + std::copy(CBI.op_begin(), CBI.op_end(), op_begin()); +} + +CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef<Value *> Args, + const Twine &NameStr, + Instruction *InsertBefore) + : Instruction(RetTy, Instruction::CleanupBlock, + OperandTraits<CleanupBlockInst>::op_end(this) - Args.size(), + Args.size(), InsertBefore) { + init(Args, NameStr); +} + +CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef<Value *> Args, + const Twine &NameStr, + BasicBlock *InsertAtEnd) + : Instruction(RetTy, Instruction::CleanupBlock, + OperandTraits<CleanupBlockInst>::op_end(this) - Args.size(), + Args.size(), InsertAtEnd) { + init(Args, NameStr); +} + +//===----------------------------------------------------------------------===// // UnreachableInst Implementation //===----------------------------------------------------------------------===// @@ -3618,6 +3915,30 @@ InvokeInst *InvokeInst::cloneImpl() const { ResumeInst *ResumeInst::cloneImpl() const { return new (1) ResumeInst(*this); } +CleanupReturnInst *CleanupReturnInst::cloneImpl() const { + return new (getNumOperands()) CleanupReturnInst(*this); +} + +CatchEndBlockInst *CatchEndBlockInst::cloneImpl() const { + return new (getNumOperands()) CatchEndBlockInst(*this); +} + +CatchReturnInst *CatchReturnInst::cloneImpl() const { + return new (1) CatchReturnInst(*this); +} + +CatchBlockInst *CatchBlockInst::cloneImpl() const { + return new (getNumOperands()) CatchBlockInst(*this); +} + +TerminateBlockInst *TerminateBlockInst::cloneImpl() const { + return new (getNumOperands()) TerminateBlockInst(*this); +} + +CleanupBlockInst *CleanupBlockInst::cloneImpl() const { + return new (getNumOperands()) CleanupBlockInst(*this); +} + UnreachableInst *UnreachableInst::cloneImpl() const { LLVMContext &Context = getContext(); return new UnreachableInst(Context); diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index 647920f23da..b6df70869b5 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -380,6 +380,10 @@ private: void visitExtractValueInst(ExtractValueInst &EVI); void visitInsertValueInst(InsertValueInst &IVI); void visitLandingPadInst(LandingPadInst &LPI); + void visitCatchBlockInst(CatchBlockInst &CBI); + void visitCatchEndBlockInst(CatchEndBlockInst &CEBI); + void visitCleanupBlockInst(CleanupBlockInst &CBI); + void visitTerminateBlockInst(TerminateBlockInst &TBI); void VerifyCallSite(CallSite CS); void verifyMustTailCall(CallInst &CI); @@ -2404,10 +2408,12 @@ void Verifier::visitCallInst(CallInst &CI) { void Verifier::visitInvokeInst(InvokeInst &II) { VerifyCallSite(&II); - // Verify that there is a landingpad instruction as the first non-PHI + // Verify that there is an exception block instruction is the first non-PHI // instruction of the 'unwind' destination. - Assert(II.getUnwindDest()->isLandingPad(), - "The unwind destination does not have a landingpad instruction!", &II); + Assert( + II.getUnwindDest()->isEHBlock(), + "The unwind destination does not have an exception handling instruction!", + &II); visitTerminatorInst(II); } @@ -2818,6 +2824,72 @@ void Verifier::visitLandingPadInst(LandingPadInst &LPI) { visitInstruction(LPI); } +void Verifier::visitCatchBlockInst(CatchBlockInst &CBI) { + BasicBlock *BB = CBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CatchBlockInst needs to be in a function with a personality.", &CBI); + + // The catchblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CBI, + "CatchBlockInst not the first non-PHI instruction in the block.", + &CBI); + + visitTerminatorInst(CBI); +} + +void Verifier::visitCatchEndBlockInst(CatchEndBlockInst &CEBI) { + BasicBlock *BB = CEBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CatchEndBlockInst needs to be in a function with a personality.", + &CEBI); + + // The catchendblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CEBI, + "CatchEndBlockInst not the first non-PHI instruction in the block.", + &CEBI); + + visitTerminatorInst(CEBI); +} + +void Verifier::visitCleanupBlockInst(CleanupBlockInst &CBI) { + BasicBlock *BB = CBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CleanupBlockInst needs to be in a function with a personality.", &CBI); + + // The cleanupblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CBI, + "CleanupBlockInst not the first non-PHI instruction in the block.", + &CBI); + + visitInstruction(CBI); +} + +void Verifier::visitTerminateBlockInst(TerminateBlockInst &TBI) { + BasicBlock *BB = TBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "TerminateBlockInst needs to be in a function with a personality.", + &TBI); + + // The terminateblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &TBI, + "TerminateBlockInst not the first non-PHI instruction in the block.", + &TBI); + + visitTerminatorInst(TBI); +} + void Verifier::verifyDominatesUse(Instruction &I, unsigned i) { Instruction *Op = cast<Instruction>(I.getOperand(i)); // If the we have an invalid invoke, don't try to compute the dominance. diff --git a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp index 286a5633024..bcc39ef9fba 100644 --- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -2653,6 +2653,26 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> { setOrigin(&I, getCleanOrigin()); } + void visitCleanupBlockInst(CleanupBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitCatchBlock(CatchBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitTerminateBlock(TerminateBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitCatchEndBlockInst(CatchEndBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + void visitGetElementPtrInst(GetElementPtrInst &I) { handleShadowOr(I); } @@ -2696,6 +2716,16 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> { // Nothing to do here. } + void visitCleanupReturnInst(CleanupReturnInst &CRI) { + DEBUG(dbgs() << "CleanupReturn: " << CRI << "\n"); + // Nothing to do here. + } + + void visitCatchReturnInst(CatchReturnInst &CRI) { + DEBUG(dbgs() << "CatchReturn: " << CRI << "\n"); + // Nothing to do here. + } + void visitInstruction(Instruction &I) { // Everything else: stop propagating and check for poisoned shadow. if (ClDumpStrictInstructions) diff --git a/llvm/lib/Transforms/Scalar/ADCE.cpp b/llvm/lib/Transforms/Scalar/ADCE.cpp index d6fc9164158..0c707c49425 100644 --- a/llvm/lib/Transforms/Scalar/ADCE.cpp +++ b/llvm/lib/Transforms/Scalar/ADCE.cpp @@ -58,8 +58,8 @@ bool ADCE::runOnFunction(Function& F) { // Collect the set of "root" instructions that are known live. for (Instruction &I : inst_range(F)) { - if (isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || - isa<LandingPadInst>(I) || I.mayHaveSideEffects()) { + if (isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || I.isEHBlock() || + I.mayHaveSideEffects()) { Alive.insert(&I); Worklist.push_back(&I); } diff --git a/llvm/lib/Transforms/Scalar/BDCE.cpp b/llvm/lib/Transforms/Scalar/BDCE.cpp index 09c605e7673..e484069f82a 100644 --- a/llvm/lib/Transforms/Scalar/BDCE.cpp +++ b/llvm/lib/Transforms/Scalar/BDCE.cpp @@ -77,8 +77,8 @@ INITIALIZE_PASS_END(BDCE, "bdce", "Bit-Tracking Dead Code Elimination", false, false) static bool isAlwaysLive(Instruction *I) { - return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || - isa<LandingPadInst>(I) || I->mayHaveSideEffects(); + return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || I->isEHBlock() || + I->mayHaveSideEffects(); } void BDCE::determineLiveOperandBits(const Instruction *UserI, diff --git a/llvm/lib/Transforms/Scalar/JumpThreading.cpp b/llvm/lib/Transforms/Scalar/JumpThreading.cpp index 1130d228acb..e845a7f586b 100644 --- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp +++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp @@ -669,7 +669,8 @@ bool JumpThreading::ProcessBlock(BasicBlock *BB) { // because now the condition in this block can be threaded through // predecessors of our predecessor block. if (BasicBlock *SinglePred = BB->getSinglePredecessor()) { - if (SinglePred->getTerminator()->getNumSuccessors() == 1 && + const TerminatorInst *TI = SinglePred->getTerminator(); + if (!TI->isExceptional() && TI->getNumSuccessors() == 1 && SinglePred != BB && !hasAddressTakenAndUsed(BB)) { // If SinglePred was a loop header, BB becomes one. if (LoopHeaders.erase(SinglePred)) diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp index 4d3a708fa20..c625b0f3362 100644 --- a/llvm/lib/Transforms/Scalar/SCCP.cpp +++ b/llvm/lib/Transforms/Scalar/SCCP.cpp @@ -539,9 +539,9 @@ void SCCPSolver::getFeasibleSuccessors(TerminatorInst &TI, return; } - if (isa<InvokeInst>(TI)) { - // Invoke instructions successors are always executable. - Succs[0] = Succs[1] = true; + // Unwinding instructions successors are always executable. + if (TI.isExceptional()) { + Succs.assign(TI.getNumSuccessors(), true); return; } @@ -605,8 +605,8 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) { return BI->getSuccessor(CI->isZero()) == To; } - // Invoke instructions successors are always executable. - if (isa<InvokeInst>(TI)) + // Unwinding instructions successors are always executable. + if (TI->isExceptional()) return true; if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { diff --git a/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp b/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp index 53471de6154..c761934162d 100644 --- a/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp +++ b/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -119,8 +119,9 @@ bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DominatorTree *DT, // Don't break self-loops. if (PredBB == BB) return false; - // Don't break invokes. - if (isa<InvokeInst>(PredBB->getTerminator())) return false; + // Don't break unwinding instructions. + if (PredBB->getTerminator()->isExceptional()) + return false; succ_iterator SI(succ_begin(PredBB)), SE(succ_end(PredBB)); BasicBlock *OnlySucc = BB; diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp index 56085579b61..e1788c9e287 100644 --- a/llvm/lib/Transforms/Utils/Local.cpp +++ b/llvm/lib/Transforms/Utils/Local.cpp @@ -283,8 +283,9 @@ bool llvm::isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI) { if (!I->use_empty() || isa<TerminatorInst>(I)) return false; - // We don't want the landingpad instruction removed by anything this general. - if (isa<LandingPadInst>(I)) + // We don't want the landingpad-like instructions removed by anything this + // general. + if (I->isEHBlock()) return false; // We don't want debug info removed by anything this general, unless |
