diff options
Diffstat (limited to 'llvm/lib')
22 files changed, 21 insertions, 1014 deletions
diff --git a/llvm/lib/Analysis/IPA/InlineCost.cpp b/llvm/lib/Analysis/IPA/InlineCost.cpp index 213644c9b43..c0d2e375cb0 100644 --- a/llvm/lib/Analysis/IPA/InlineCost.cpp +++ b/llvm/lib/Analysis/IPA/InlineCost.cpp @@ -156,8 +156,6 @@ 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: @@ -905,18 +903,6 @@ 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 69c2048aae2..88f359d4fd5 100644 --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -524,7 +524,6 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(undef); KEYWORD(null); KEYWORD(to); - KEYWORD(caller); KEYWORD(tail); KEYWORD(musttail); KEYWORD(target); @@ -749,12 +748,6 @@ 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 05373bf05d9..91a88bc91fd 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -4489,12 +4489,6 @@ 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: @@ -4888,161 +4882,6 @@ 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 terminateblock")) - 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 catchendblock")) - 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 2a39b6d364d..6e57b3e0667 100644 --- a/llvm/lib/AsmParser/LLParser.h +++ b/llvm/lib/AsmParser/LLParser.h @@ -381,9 +381,6 @@ 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); @@ -444,12 +441,6 @@ 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 6e24224978e..2487d120813 100644 --- a/llvm/lib/AsmParser/LLToken.h +++ b/llvm/lib/AsmParser/LLToken.h @@ -51,7 +51,6 @@ namespace lltok { kw_zeroinitializer, kw_undef, kw_null, kw_to, - kw_caller, kw_tail, kw_musttail, kw_target, @@ -177,8 +176,7 @@ 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_cleanupret, kw_catchret, kw_catchblock, - kw_terminateblock, kw_cleanupblock, kw_catchendblock, + kw_unreachable, 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 f13fc0476eb..563e201336a 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -3793,134 +3793,6 @@ 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 c1fd66668f8..622f7eaf078 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -1845,64 +1845,6 @@ 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 05010ecf7e1..2c3c0eb101a 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -1168,30 +1168,6 @@ 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 df85e233b79..700675453fe 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h @@ -734,12 +734,6 @@ 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 b8ddcfe01b7..ecfd6593157 100644 --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp @@ -1546,12 +1546,6 @@ 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 a866828c31b..adc620db897 100644 --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -2848,66 +2848,8 @@ 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 658c5e24216..0a0449434a7 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 (InsertPt->isEHBlock()) ++InsertPt; + if (isa<LandingPadInst>(InsertPt)) ++InsertPt; return InsertPt; } diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp index 2b09e551b79..c57ba16cf6c 100644 --- a/llvm/lib/IR/Instruction.cpp +++ b/llvm/lib/IR/Instruction.cpp @@ -196,11 +196,6 @@ 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"; @@ -261,7 +256,6 @@ 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> "; } @@ -413,8 +407,6 @@ 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(); @@ -435,8 +427,6 @@ 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(); @@ -465,12 +455,6 @@ 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(); - if (const auto *TBI = dyn_cast<TerminateBlockInst>(this)) - return TBI->unwindsToCaller(); return isa<ResumeInst>(this); } diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 02cb1205da9..86c921aeda8 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -671,303 +671,6 @@ 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 //===----------------------------------------------------------------------===// @@ -3915,30 +3618,6 @@ 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 c85be99bc24..647920f23da 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -184,9 +184,6 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport { /// \brief Track unresolved string-based type references. SmallDenseMap<const MDString *, const MDNode *, 32> UnresolvedTypeRefs; - /// \brief The result value from the personality function. - Type *PersonalityFnResultTy; - /// \brief Whether we've seen a call to @llvm.localescape in this function /// already. bool SawFrameEscape; @@ -197,8 +194,7 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport { public: explicit Verifier(raw_ostream &OS) - : VerifierSupport(OS), Context(nullptr), PersonalityFnResultTy(nullptr), - SawFrameEscape(false) {} + : VerifierSupport(OS), Context(nullptr), SawFrameEscape(false) {} bool verify(const Function &F) { M = F.getParent(); @@ -232,7 +228,6 @@ public: // FIXME: We strip const here because the inst visitor strips const. visit(const_cast<Function &>(F)); InstsInThisBlock.clear(); - PersonalityFnResultTy = nullptr; SawFrameEscape = false; return !Broken; @@ -385,11 +380,6 @@ 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 visitCleanupReturnInst(CleanupReturnInst &CRI); - void visitTerminateBlockInst(TerminateBlockInst &TBI); void VerifyCallSite(CallSite CS); void verifyMustTailCall(CallInst &CI); @@ -2414,12 +2404,10 @@ void Verifier::visitCallInst(CallInst &CI) { void Verifier::visitInvokeInst(InvokeInst &II) { VerifyCallSite(&II); - // Verify that the first non-PHI instruction of the unwind destination is an - // exception handling instruction. - Assert( - II.getUnwindDest()->isEHBlock(), - "The unwind destination does not have an exception handling instruction!", - &II); + // Verify that there is a landingpad instruction as the first non-PHI + // instruction of the 'unwind' destination. + Assert(II.getUnwindDest()->isLandingPad(), + "The unwind destination does not have a landingpad instruction!", &II); visitTerminatorInst(II); } @@ -2805,14 +2793,6 @@ void Verifier::visitLandingPadInst(LandingPadInst &LPI) { &LPI); } - if (!PersonalityFnResultTy) - PersonalityFnResultTy = LPI.getType(); - else - Assert(PersonalityFnResultTy == LPI.getType(), - "The personality routine should have a consistent result type " - "inside a function.", - &LPI); - Function *F = LPI.getParent()->getParent(); Assert(F->hasPersonalityFn(), "LandingPadInst needs to be in a function with a personality.", &LPI); @@ -2838,132 +2818,6 @@ void Verifier::visitLandingPadInst(LandingPadInst &LPI) { visitInstruction(LPI); } -void Verifier::visitCatchBlockInst(CatchBlockInst &CBI) { - BasicBlock *BB = CBI.getParent(); - - if (!PersonalityFnResultTy) - PersonalityFnResultTy = CBI.getType(); - else - Assert(PersonalityFnResultTy == CBI.getType(), - "The personality routine should have a consistent result type " - "inside a function.", - &CBI); - - 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); - - BasicBlock *UnwindDest = CBI.getUnwindDest(); - Instruction *I = UnwindDest->getFirstNonPHI(); - Assert( - isa<CatchBlockInst>(I) || isa<CatchEndBlockInst>(I), - "CatchBlockInst must unwind to a CatchBlockInst or a CatchEndBlockInst.", - &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); - - unsigned CatchBlocksSeen = 0; - for (BasicBlock *PredBB : predecessors(BB)) - if (isa<CatchBlockInst>(PredBB->getTerminator())) - ++CatchBlocksSeen; - - Assert(CatchBlocksSeen <= 1, "CatchEndBlockInst must have no more than one " - "CatchBlockInst predecessor.", - &CEBI); - - if (BasicBlock *UnwindDest = CEBI.getUnwindDest()) { - Instruction *I = UnwindDest->getFirstNonPHI(); - Assert( - I->isEHBlock() && !isa<LandingPadInst>(I), - "CatchEndBlock must unwind to an EH block which is not a landingpad.", - &CEBI); - } - - visitTerminatorInst(CEBI); -} - -void Verifier::visitCleanupBlockInst(CleanupBlockInst &CBI) { - BasicBlock *BB = CBI.getParent(); - - if (!PersonalityFnResultTy) - PersonalityFnResultTy = CBI.getType(); - else - Assert(PersonalityFnResultTy == CBI.getType(), - "The personality routine should have a consistent result type " - "inside a function.", - &CBI); - - 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::visitCleanupReturnInst(CleanupReturnInst &CRI) { - if (BasicBlock *UnwindDest = CRI.getUnwindDest()) { - Instruction *I = UnwindDest->getFirstNonPHI(); - Assert(I->isEHBlock() && !isa<LandingPadInst>(I), - "CleanupReturnInst must unwind to an EH block which is not a " - "landingpad.", - &CRI); - } - - visitTerminatorInst(CRI); -} - -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); - - if (BasicBlock *UnwindDest = TBI.getUnwindDest()) { - Instruction *I = UnwindDest->getFirstNonPHI(); - Assert(I->isEHBlock() && !isa<LandingPadInst>(I), - "TerminateBlockInst must unwind to an EH block which is not a " - "landingpad.", - &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 ee77882e7ca..286a5633024 100644 --- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -2653,30 +2653,6 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> { setOrigin(&I, getCleanOrigin()); } - void visitCleanupBlockInst(CleanupBlockInst &I) { - if (!I.getType()->isVoidTy()) { - setShadow(&I, getCleanShadow(&I)); - setOrigin(&I, getCleanOrigin()); - } - } - - void visitCatchBlock(CatchBlockInst &I) { - if (!I.getType()->isVoidTy()) { - setShadow(&I, getCleanShadow(&I)); - setOrigin(&I, getCleanOrigin()); - } - } - - void visitTerminateBlock(TerminateBlockInst &I) { - DEBUG(dbgs() << "TerminateBlock: " << I << "\n"); - // Nothing to do here. - } - - void visitCatchEndBlockInst(CatchEndBlockInst &I) { - DEBUG(dbgs() << "CatchEndBlock: " << I << "\n"); - // Nothing to do here. - } - void visitGetElementPtrInst(GetElementPtrInst &I) { handleShadowOr(I); } @@ -2720,16 +2696,6 @@ 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 0c707c49425..d6fc9164158 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) || I.isEHBlock() || - I.mayHaveSideEffects()) { + if (isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || + isa<LandingPadInst>(I) || 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 e484069f82a..09c605e7673 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) || I->isEHBlock() || - I->mayHaveSideEffects(); + return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) || + isa<LandingPadInst>(I) || 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 e845a7f586b..1130d228acb 100644 --- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp +++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp @@ -669,8 +669,7 @@ 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()) { - const TerminatorInst *TI = SinglePred->getTerminator(); - if (!TI->isExceptional() && TI->getNumSuccessors() == 1 && + if (SinglePred->getTerminator()->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 c625b0f3362..4d3a708fa20 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; } - // Unwinding instructions successors are always executable. - if (TI.isExceptional()) { - Succs.assign(TI.getNumSuccessors(), true); + if (isa<InvokeInst>(TI)) { + // Invoke instructions successors are always executable. + Succs[0] = Succs[1] = true; return; } @@ -605,8 +605,8 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) { return BI->getSuccessor(CI->isZero()) == To; } - // Unwinding instructions successors are always executable. - if (TI->isExceptional()) + // Invoke instructions successors are always executable. + if (isa<InvokeInst>(TI)) 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 c761934162d..53471de6154 100644 --- a/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp +++ b/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp @@ -119,9 +119,8 @@ bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DominatorTree *DT, // Don't break self-loops. if (PredBB == BB) return false; - // Don't break unwinding instructions. - if (PredBB->getTerminator()->isExceptional()) - return false; + // Don't break invokes. + if (isa<InvokeInst>(PredBB->getTerminator())) 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 e1788c9e287..56085579b61 100644 --- a/llvm/lib/Transforms/Utils/Local.cpp +++ b/llvm/lib/Transforms/Utils/Local.cpp @@ -283,9 +283,8 @@ bool llvm::isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI) { if (!I->use_empty() || isa<TerminatorInst>(I)) return false; - // We don't want the landingpad-like instructions removed by anything this - // general. - if (I->isEHBlock()) + // We don't want the landingpad instruction removed by anything this general. + if (isa<LandingPadInst>(I)) return false; // We don't want debug info removed by anything this general, unless |
