From eddf9e2057790c86191878efd57217117435471f Mon Sep 17 00:00:00 2001 From: David Majnemer Date: Fri, 10 Jul 2015 07:15:17 +0000 Subject: [PATCH] Revert the new EH instructions This reverts commits r241888-r241891, I didn't mean to commit them. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241893 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/LangRef.rst | 356 +----------- include/llvm-c/Core.h | 14 +- include/llvm/Bitcode/LLVMBitCodes.h | 6 - include/llvm/IR/BasicBlock.h | 3 - include/llvm/IR/IRBuilder.h | 32 -- include/llvm/IR/InstVisitor.h | 6 - include/llvm/IR/InstrTypes.h | 16 - include/llvm/IR/Instruction.def | 142 +++-- include/llvm/IR/Instruction.h | 14 - include/llvm/IR/Instructions.h | 520 ------------------ lib/Analysis/IPA/InlineCost.cpp | 14 - lib/AsmParser/LLLexer.cpp | 7 - lib/AsmParser/LLParser.cpp | 161 ------ lib/AsmParser/LLParser.h | 9 - lib/AsmParser/LLToken.h | 4 +- lib/Bitcode/Reader/BitcodeReader.cpp | 128 ----- lib/Bitcode/Writer/BitcodeWriter.cpp | 58 -- .../SelectionDAG/SelectionDAGBuilder.cpp | 24 - .../SelectionDAG/SelectionDAGBuilder.h | 6 - lib/CodeGen/TargetLoweringBase.cpp | 6 - lib/IR/AsmWriter.cpp | 58 -- lib/IR/BasicBlock.cpp | 2 +- lib/IR/Instruction.cpp | 16 - lib/IR/Instructions.cpp | 321 ----------- lib/IR/Verifier.cpp | 156 +----- .../Instrumentation/MemorySanitizer.cpp | 34 -- lib/Transforms/Scalar/ADCE.cpp | 4 +- lib/Transforms/Scalar/BDCE.cpp | 4 +- lib/Transforms/Scalar/JumpThreading.cpp | 3 +- lib/Transforms/Scalar/SCCP.cpp | 10 +- lib/Transforms/Utils/BasicBlockUtils.cpp | 5 +- lib/Transforms/Utils/Local.cpp | 5 +- test/Feature/exception.ll | 69 --- test/Verifier/invoke.ll | 4 +- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp | 5 - 35 files changed, 93 insertions(+), 2129 deletions(-) diff --git a/docs/LangRef.rst b/docs/LangRef.rst index 86a5a135b28..ca5c16c0f49 100644 --- a/docs/LangRef.rst +++ b/docs/LangRef.rst @@ -4727,12 +4727,7 @@ control flow, not values (the one exception being the The terminator instructions are: ':ref:`ret `', ':ref:`br `', ':ref:`switch `', ':ref:`indirectbr `', ':ref:`invoke `', -':ref:`resume `', ':ref:`catchblock `', -':ref:`catchendblock `', -':ref:`catchret `', -':ref:`cleanupret `', -':ref:`terminateblock `', -and ':ref:`unreachable `'. +':ref:`resume `', and ':ref:`unreachable `'. .. _i_ret: @@ -5086,294 +5081,6 @@ Example: resume { i8*, i32 } %exn -.. _i_catchblock: - -'``catchblock``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - = catchblock [*] - to label unwind label - -Overview: -""""""""" - -The '``catchblock``' instruction is used by `LLVM's exception handling -system `_ to specify that a basic block -is a catch block --- one where a personality routine attempts to transfer -control to catch an exception. -The ``args`` correspond to whatever information the personality -routine requires to know if this is an appropriate place to catch the -exception. Control is tranfered to the ``exception`` label if the -``catchblock`` is not an appropriate handler for the in-flight exception. -The ``normal`` label should contain the code found in the ``catch`` -portion of a ``try``/``catch`` sequence. It defines values supplied by -the :ref:`personality function ` upon re-entry to the -function. The ``resultval`` has the type ``resultty``. - -Arguments: -"""""""""" - -The instruction takes a list of arbitrary values which are interpreted -by the :ref:`personality function `. - -The ``catchblock`` must be provided a ``normal`` label to transfer control -to if the ``catchblock`` matches the exception and an ``exception`` -label to transfer control to if it doesn't. - -Semantics: -"""""""""" - -The '``catchblock``' instruction defines the values which are set by the -:ref:`personality function ` upon re-entry to the function, and -therefore the "result type" of the ``catchblock`` instruction. As with -calling conventions, how the personality function results are -represented in LLVM IR is target specific. - -When the call stack is being unwound due to an exception being thrown, -the exception is compared against the ``args``. If it doesn't match, -then control is transfered to the ``exception`` basic block. - -The ``catchblock`` instruction has several restrictions: - -- A catch block is a basic block which is the unwind destination of - an exceptional instruction. -- A catch block must have a '``catchblock``' instruction as its - first non-PHI instruction. -- A catch block's ``exception`` edge must refer to a catch block or a - catch-end block. -- There can be only one '``catchblock``' instruction within the - catch block. -- A basic block that is not a catch block may not include a - '``catchblock``' instruction. - -Example: -"""""""" - -.. code-block:: llvm - - ;; A catch block which can catch an integer. - %res = catchblock { i8*, i32 } [i8** @_ZTIi] - to label %int.handler unwind label %terminate - -.. _i_catchendblock: - -'``catchendblock``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - catchendblock unwind label - catchendblock unwind to caller - -Overview: -""""""""" - -The '``catchendblock``' instruction is used by `LLVM's exception handling -system `_ to communicate to the -:ref:`personality function ` which invokes are associated -with a chain of :ref:`catchblock ` instructions. - -The ``nextaction`` label indicates where control should transfer to if -none of the ``catchblock`` instructions are suitable for catching the -in-flight exception. - -If a ``nextaction`` label is not present, the instruction unwinds out of -its parent function. The -:ref:`personality function ` will continue processing -exception handling actions in the caller. - -Arguments: -"""""""""" - -The instruction optionally takes a label, ``nextaction``, indicating -where control should transfer to if none of the preceding -``catchblock`` instructions are suitable for the in-flight exception. - -Semantics: -"""""""""" - -When the call stack is being unwound due to an exception being thrown -and none of the constituent ``catchblock`` instructions match, then -control is transfered to ``nextaction`` if it is present. If it is not -present, control is transfered to the caller. - -The ``catchendblock`` instruction has several restrictions: - -- A catch-end block is a basic block which is the unwind destination of - an exceptional instruction. -- A catch-end block must have a '``catchendblock``' instruction as its - first non-PHI instruction. -- There can be only one '``catchendblock``' instruction within the - catch block. -- A basic block that is not a catch-end block may not include a - '``catchendblock``' instruction. -- Exactly one catch block may unwind to a ``catchendblock``. - -Example: -"""""""" - -.. code-block:: llvm - - catchendblock unwind label %terminate - catchendblock unwind to caller - -.. _i_catchret: - -'``catchret``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - catchret label - -Overview: -""""""""" - -The '``catchret``' instruction is a terminator instruction that has a -single successor. - - -Arguments: -"""""""""" - -The '``catchret``' instruction requires one argument which specifies -where control will transfer to next. - -Semantics: -"""""""""" - -The '``catchret``' instruction ends the existing (in-flight) exception -whose unwinding was interrupted with a -:ref:`catchblock ` instruction. -The :ref:`personality function ` gets a chance to execute -arbitrary code to, for example, run a C++ destructor. -Control then transfers to ``normal``. - -Example: -"""""""" - -.. code-block:: llvm - - catchret label %continue - -.. _i_cleanupret: - -'``cleanupret``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - cleanupret unwind label - cleanupret unwind to caller - -Overview: -""""""""" - -The '``cleanupret``' instruction is a terminator instruction that has -an optional successor. - - -Arguments: -"""""""""" - -The '``cleanupret``' instruction requires one argument, which must have the -same type as the result of any '``cleanupblock``' instruction in the same -function. It also has an optional successor, ``continue``. - -Semantics: -"""""""""" - -The '``cleanupret``' instruction indicates to the -:ref:`personality function ` that one -:ref:`cleanupblock ` it transferred control to has ended. -It transfers control to ``continue`` or unwinds out of the function. - -Example: -"""""""" - -.. code-block:: llvm - - cleanupret void unwind to caller - cleanupret { i8*, i32 } %exn unwind label %continue - -.. _i_terminateblock: - -'``terminateblock``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - terminateblock [*] unwind label - terminateblock [*] unwind to caller - -Overview: -""""""""" - -The '``terminateblock``' instruction is used by `LLVM's exception handling -system `_ to specify that a basic block -is a terminate block --- one where a personality routine may decide to -terminate the program. -The ``args`` correspond to whatever information the personality -routine requires to know if this is an appropriate place to terminate the -program. Control is transferred to the ``exception`` label if the -personality routine decides not to terminate the program for the -in-flight exception. - -Arguments: -"""""""""" - -The instruction takes a list of arbitrary values which are interpreted -by the :ref:`personality function `. - -The ``terminateblock`` may be given an ``exception`` label to -transfer control to if the in-flight exception matches the ``args``. - -Semantics: -"""""""""" - -When the call stack is being unwound due to an exception being thrown, -the exception is compared against the ``args``. If it matches, -then control is transfered to the ``exception`` basic block. Otherwise, -the program is terminated via personality-specific means. Typically, -the first argument to ``terminateblock`` specifies what function the -personality should defer to in order to terminate the program. - -The ``terminateblock`` instruction has several restrictions: - -- A terminate block is a basic block which is the unwind destination of - an exceptional instruction. -- A terminate block must have a '``terminateblock``' instruction as its - first non-PHI instruction. -- There can be only one '``terminateblock``' instruction within the - terminate block. -- A basic block that is not a terminate block may not include a - '``terminateblock``' instruction. - -Example: -"""""""" - -.. code-block:: llvm - - ;; A terminate block which only permits integers. - terminateblock [i8** @_ZTIi] unwind label %continue - .. _i_unreachable: '``unreachable``' Instruction @@ -8322,67 +8029,6 @@ Example: catch i8** @_ZTIi filter [1 x i8**] [@_ZTId] -.. _i_cleanupblock: - -'``cleanupblock``' Instruction -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Syntax: -""""""" - -:: - - = cleanupblock [*] - -Overview: -""""""""" - -The '``cleanupblock``' instruction is used by `LLVM's exception handling -system `_ to specify that a basic block -is a cleanup block --- one where a personality routine attempts to -transfer control to run cleanup actions. -The ``args`` correspond to whatever additional -information the :ref:`personality function ` requires to -execute the cleanup. -The ``resultval`` has the type ``resultty``. - -Arguments: -"""""""""" - -The instruction takes a list of arbitrary values which are interpreted -by the :ref:`personality function `. - -Semantics: -"""""""""" - -The '``cleanupblock``' instruction defines the values which are set by the -:ref:`personality function ` upon re-entry to the function, and -therefore the "result type" of the ``cleanupblock`` instruction. As with -calling conventions, how the personality function results are -represented in LLVM IR is target specific. - -When the call stack is being unwound due to an exception being thrown, -the :ref:`personality function ` transfers control to the -``cleanupblock`` with the aid of the personality-specific arguments. - -The ``cleanupblock`` instruction has several restrictions: - -- A cleanup block is a basic block which is the unwind destination of - an exceptional instruction. -- A cleanup block must have a '``cleanupblock``' instruction as its - first non-PHI instruction. -- There can be only one '``cleanupblock``' instruction within the - cleanup block. -- A basic block that is not a cleanup block may not include a - '``cleanupblock``' instruction. - -Example: -"""""""" - -.. code-block:: llvm - - %res = cleanupblock { i8*, i32 } [label %nextaction] - .. _intrinsics: Intrinsic Functions diff --git a/include/llvm-c/Core.h b/include/llvm-c/Core.h index 48ae289f966..713894f5763 100644 --- a/include/llvm-c/Core.h +++ b/include/llvm-c/Core.h @@ -248,13 +248,7 @@ typedef enum { /* Exception Handling Operators */ LLVMResume = 58, - LLVMLandingPad = 59, - LLVMCleanupRet = 61, - LLVMCatchRet = 62, - LLVMCatchBlock = 63, - LLVMTerminateBlock = 64, - LLVMCleanupBlock = 65, - LLVMCatchEndBlock = 66 + LLVMLandingPad = 59 } LLVMOpcode; @@ -1209,7 +1203,6 @@ LLVMTypeRef LLVMX86MMXType(void); macro(InsertElementInst) \ macro(InsertValueInst) \ macro(LandingPadInst) \ - macro(CleanupBlockInst) \ macro(PHINode) \ macro(SelectInst) \ macro(ShuffleVectorInst) \ @@ -1222,11 +1215,6 @@ LLVMTypeRef LLVMX86MMXType(void); macro(SwitchInst) \ macro(UnreachableInst) \ macro(ResumeInst) \ - macro(CleanupReturnInst) \ - macro(CatchReturnInst) \ - macro(CatchBlockInst) \ - macro(TerminateBlockInst) \ - macro(CatchEndBlockInst) \ macro(UnaryInstruction) \ macro(AllocaInst) \ macro(CastInst) \ diff --git a/include/llvm/Bitcode/LLVMBitCodes.h b/include/llvm/Bitcode/LLVMBitCodes.h index 28452757fb2..605c4172dd8 100644 --- a/include/llvm/Bitcode/LLVMBitCodes.h +++ b/include/llvm/Bitcode/LLVMBitCodes.h @@ -354,12 +354,6 @@ namespace bitc { FUNC_CODE_INST_CMPXCHG = 46, // CMPXCHG: [ptrty,ptr,valty,cmp,new, align, // vol,ordering,synchscope] FUNC_CODE_INST_LANDINGPAD = 47, // LANDINGPAD: [ty,val,num,id0,val0...] - FUNC_CODE_INST_CLEANUPRET = 48, // CLEANUPRET: [] or [val] or [bb#] or [val,bb#] - FUNC_CODE_INST_CATCHRET = 49, // CATCHRET: [bb#] - FUNC_CODE_INST_CATCHBLOCK = 50, // CATCHBLOCK: [ty,val,val,num,args...] - FUNC_CODE_INST_TERMINATEBLOCK = 51, // TERMINATEBLOCK: [bb#,num,args...] - FUNC_CODE_INST_CLEANUPBLOCK = 52, // CLEANUPBLOCK: [num,args...] - FUNC_CODE_INST_CATCHENDBLOCK = 53, // CATCHENDBLOCK: [] or [bb#] }; enum UseListCodes { diff --git a/include/llvm/IR/BasicBlock.h b/include/llvm/IR/BasicBlock.h index 5189d8f6a46..66581bfedbe 100644 --- a/include/llvm/IR/BasicBlock.h +++ b/include/llvm/IR/BasicBlock.h @@ -309,9 +309,6 @@ public: /// basic block \p New instead of to it. void replaceSuccessorsPhiUsesWith(BasicBlock *New); - /// \brief Return true if this basic block is an exception handling block. - bool isEHBlock() const { return getFirstNonPHI()->isEHBlock(); } - /// \brief Return true if this basic block is a landing pad. /// /// Being a ``landing pad'' means that the basic block is the destination of diff --git a/include/llvm/IR/IRBuilder.h b/include/llvm/IR/IRBuilder.h index 9f6fd3453fd..e6b5393c339 100644 --- a/include/llvm/IR/IRBuilder.h +++ b/include/llvm/IR/IRBuilder.h @@ -672,38 +672,6 @@ public: return Insert(ResumeInst::Create(Exn)); } - CleanupReturnInst *CreateCleanupRet(BasicBlock *UnwindBB = nullptr, - Value *RetVal = nullptr) { - return Insert(CleanupReturnInst::Create(Context, RetVal, UnwindBB)); - } - - CatchBlockInst *CreateCatchBlock(Type *Ty, BasicBlock *NormalDest, - BasicBlock *UnwindDest, - ArrayRef Args, - const Twine &Name = "") { - return Insert(CatchBlockInst::Create(Ty, NormalDest, UnwindDest, Args), - Name); - } - - CatchEndBlockInst *CreateCatchEndBlock(BasicBlock *UnwindBB = nullptr) { - return Insert(CatchEndBlockInst::Create(Context, UnwindBB)); - } - - TerminateBlockInst *CreateTerminateBlock(BasicBlock *NormalDest = nullptr, - ArrayRef Args = {}, - const Twine &Name = "") { - return Insert(TerminateBlockInst::Create(Context, NormalDest, Args), Name); - } - - CleanupBlockInst *CreateCleanupBlock(Type *Ty, ArrayRef Args, - const Twine &Name = "") { - return Insert(CleanupBlockInst::Create(Ty, Args), Name); - } - - CatchReturnInst *CreateCatchRet(BasicBlock *BB) { - return Insert(CatchReturnInst::Create(BB)); - } - UnreachableInst *CreateUnreachable() { return Insert(new UnreachableInst(Context)); } diff --git a/include/llvm/IR/InstVisitor.h b/include/llvm/IR/InstVisitor.h index 37841c77162..581e860b838 100644 --- a/include/llvm/IR/InstVisitor.h +++ b/include/llvm/IR/InstVisitor.h @@ -169,11 +169,6 @@ public: RetTy visitIndirectBrInst(IndirectBrInst &I) { DELEGATE(TerminatorInst);} RetTy visitResumeInst(ResumeInst &I) { DELEGATE(TerminatorInst);} RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);} - RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);} - RetTy visitCatchReturnInst(CatchReturnInst &I) { DELEGATE(TerminatorInst);} - RetTy visitCatchBlockInst(CatchBlockInst &I) { DELEGATE(TerminatorInst);} - RetTy visitCatchEndBlockInst(CatchEndBlockInst &I) { DELEGATE(TerminatorInst); } - RetTy visitTerminateBlockInst(TerminateBlockInst &I) { DELEGATE(TerminatorInst);} RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);} RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);} RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(UnaryInstruction);} @@ -205,7 +200,6 @@ public: RetTy visitExtractValueInst(ExtractValueInst &I){ DELEGATE(UnaryInstruction);} RetTy visitInsertValueInst(InsertValueInst &I) { DELEGATE(Instruction); } RetTy visitLandingPadInst(LandingPadInst &I) { DELEGATE(Instruction); } - RetTy visitCleanupBlockInst(CleanupBlockInst &I) { DELEGATE(Instruction); } // Handle the special instrinsic instruction classes. RetTy visitDbgDeclareInst(DbgDeclareInst &I) { DELEGATE(DbgInfoIntrinsic);} diff --git a/include/llvm/IR/InstrTypes.h b/include/llvm/IR/InstrTypes.h index 318fb2ef0bf..b791ded0e19 100644 --- a/include/llvm/IR/InstrTypes.h +++ b/include/llvm/IR/InstrTypes.h @@ -75,22 +75,6 @@ public: static inline bool classof(const Value *V) { return isa(V) && classof(cast(V)); } - - // \brief Returns true if this terminator relates to exception handling. - bool isExceptional() const { - switch (getOpcode()) { - case Instruction::CatchBlock: - case Instruction::CatchEndBlock: - case Instruction::CatchRet: - case Instruction::CleanupRet: - case Instruction::Invoke: - case Instruction::Resume: - case Instruction::TerminateBlock: - return true; - default: - return false; - } - } }; diff --git a/include/llvm/IR/Instruction.def b/include/llvm/IR/Instruction.def index 801cc44a86e..d46314cc761 100644 --- a/include/llvm/IR/Instruction.def +++ b/include/llvm/IR/Instruction.def @@ -94,92 +94,86 @@ // instructions for it to be a well formed basic block. // FIRST_TERM_INST ( 1) -HANDLE_TERM_INST ( 1, Ret , ReturnInst) -HANDLE_TERM_INST ( 2, Br , BranchInst) -HANDLE_TERM_INST ( 3, Switch , SwitchInst) -HANDLE_TERM_INST ( 4, IndirectBr , IndirectBrInst) -HANDLE_TERM_INST ( 5, Invoke , InvokeInst) -HANDLE_TERM_INST ( 6, Resume , ResumeInst) -HANDLE_TERM_INST ( 7, Unreachable , UnreachableInst) -HANDLE_TERM_INST ( 8, CleanupRet , CleanupReturnInst) -HANDLE_TERM_INST ( 9, CatchRet , CatchReturnInst) -HANDLE_TERM_INST (10, CatchBlock , CatchBlockInst) -HANDLE_TERM_INST (11, TerminateBlock, TerminateBlockInst) -HANDLE_TERM_INST (12, CatchEndBlock , CatchEndBlockInst) - LAST_TERM_INST (12) +HANDLE_TERM_INST ( 1, Ret , ReturnInst) +HANDLE_TERM_INST ( 2, Br , BranchInst) +HANDLE_TERM_INST ( 3, Switch , SwitchInst) +HANDLE_TERM_INST ( 4, IndirectBr , IndirectBrInst) +HANDLE_TERM_INST ( 5, Invoke , InvokeInst) +HANDLE_TERM_INST ( 6, Resume , ResumeInst) +HANDLE_TERM_INST ( 7, Unreachable, UnreachableInst) + LAST_TERM_INST ( 7) // Standard binary operators... - FIRST_BINARY_INST(13) -HANDLE_BINARY_INST(13, Add , BinaryOperator) -HANDLE_BINARY_INST(14, FAdd , BinaryOperator) -HANDLE_BINARY_INST(15, Sub , BinaryOperator) -HANDLE_BINARY_INST(16, FSub , BinaryOperator) -HANDLE_BINARY_INST(17, Mul , BinaryOperator) -HANDLE_BINARY_INST(18, FMul , BinaryOperator) -HANDLE_BINARY_INST(19, UDiv , BinaryOperator) -HANDLE_BINARY_INST(20, SDiv , BinaryOperator) -HANDLE_BINARY_INST(21, FDiv , BinaryOperator) -HANDLE_BINARY_INST(22, URem , BinaryOperator) -HANDLE_BINARY_INST(23, SRem , BinaryOperator) -HANDLE_BINARY_INST(24, FRem , BinaryOperator) + FIRST_BINARY_INST( 8) +HANDLE_BINARY_INST( 8, Add , BinaryOperator) +HANDLE_BINARY_INST( 9, FAdd , BinaryOperator) +HANDLE_BINARY_INST(10, Sub , BinaryOperator) +HANDLE_BINARY_INST(11, FSub , BinaryOperator) +HANDLE_BINARY_INST(12, Mul , BinaryOperator) +HANDLE_BINARY_INST(13, FMul , BinaryOperator) +HANDLE_BINARY_INST(14, UDiv , BinaryOperator) +HANDLE_BINARY_INST(15, SDiv , BinaryOperator) +HANDLE_BINARY_INST(16, FDiv , BinaryOperator) +HANDLE_BINARY_INST(17, URem , BinaryOperator) +HANDLE_BINARY_INST(18, SRem , BinaryOperator) +HANDLE_BINARY_INST(19, FRem , BinaryOperator) // Logical operators (integer operands) -HANDLE_BINARY_INST(25, Shl , BinaryOperator) // Shift left (logical) -HANDLE_BINARY_INST(26, LShr , BinaryOperator) // Shift right (logical) -HANDLE_BINARY_INST(27, AShr , BinaryOperator) // Shift right (arithmetic) -HANDLE_BINARY_INST(28, And , BinaryOperator) -HANDLE_BINARY_INST(29, Or , BinaryOperator) -HANDLE_BINARY_INST(30, Xor , BinaryOperator) - LAST_BINARY_INST(30) +HANDLE_BINARY_INST(20, Shl , BinaryOperator) // Shift left (logical) +HANDLE_BINARY_INST(21, LShr , BinaryOperator) // Shift right (logical) +HANDLE_BINARY_INST(22, AShr , BinaryOperator) // Shift right (arithmetic) +HANDLE_BINARY_INST(23, And , BinaryOperator) +HANDLE_BINARY_INST(24, Or , BinaryOperator) +HANDLE_BINARY_INST(25, Xor , BinaryOperator) + LAST_BINARY_INST(25) // Memory operators... - FIRST_MEMORY_INST(31) -HANDLE_MEMORY_INST(31, Alloca, AllocaInst) // Stack management -HANDLE_MEMORY_INST(32, Load , LoadInst ) // Memory manipulation instrs -HANDLE_MEMORY_INST(33, Store , StoreInst ) -HANDLE_MEMORY_INST(34, GetElementPtr, GetElementPtrInst) -HANDLE_MEMORY_INST(35, Fence , FenceInst ) -HANDLE_MEMORY_INST(36, AtomicCmpXchg , AtomicCmpXchgInst ) -HANDLE_MEMORY_INST(37, AtomicRMW , AtomicRMWInst ) - LAST_MEMORY_INST(37) + FIRST_MEMORY_INST(26) +HANDLE_MEMORY_INST(26, Alloca, AllocaInst) // Stack management +HANDLE_MEMORY_INST(27, Load , LoadInst ) // Memory manipulation instrs +HANDLE_MEMORY_INST(28, Store , StoreInst ) +HANDLE_MEMORY_INST(29, GetElementPtr, GetElementPtrInst) +HANDLE_MEMORY_INST(30, Fence , FenceInst ) +HANDLE_MEMORY_INST(31, AtomicCmpXchg , AtomicCmpXchgInst ) +HANDLE_MEMORY_INST(32, AtomicRMW , AtomicRMWInst ) + LAST_MEMORY_INST(32) // Cast operators ... // NOTE: The order matters here because CastInst::isEliminableCastPair // NOTE: (see Instructions.cpp) encodes a table based on this ordering. - FIRST_CAST_INST(38) -HANDLE_CAST_INST(38, Trunc , TruncInst ) // Truncate integers -HANDLE_CAST_INST(39, ZExt , ZExtInst ) // Zero extend integers -HANDLE_CAST_INST(40, SExt , SExtInst ) // Sign extend integers -HANDLE_CAST_INST(41, FPToUI , FPToUIInst ) // floating point -> UInt -HANDLE_CAST_INST(42, FPToSI , FPToSIInst ) // floating point -> SInt -HANDLE_CAST_INST(43, UIToFP , UIToFPInst ) // UInt -> floating point -HANDLE_CAST_INST(44, SIToFP , SIToFPInst ) // SInt -> floating point -HANDLE_CAST_INST(45, FPTrunc , FPTruncInst ) // Truncate floating point -HANDLE_CAST_INST(46, FPExt , FPExtInst ) // Extend floating point -HANDLE_CAST_INST(47, PtrToInt, PtrToIntInst) // Pointer -> Integer -HANDLE_CAST_INST(48, IntToPtr, IntToPtrInst) // Integer -> Pointer -HANDLE_CAST_INST(49, BitCast , BitCastInst ) // Type cast -HANDLE_CAST_INST(50, AddrSpaceCast, AddrSpaceCastInst) // addrspace cast - LAST_CAST_INST(50) + FIRST_CAST_INST(33) +HANDLE_CAST_INST(33, Trunc , TruncInst ) // Truncate integers +HANDLE_CAST_INST(34, ZExt , ZExtInst ) // Zero extend integers +HANDLE_CAST_INST(35, SExt , SExtInst ) // Sign extend integers +HANDLE_CAST_INST(36, FPToUI , FPToUIInst ) // floating point -> UInt +HANDLE_CAST_INST(37, FPToSI , FPToSIInst ) // floating point -> SInt +HANDLE_CAST_INST(38, UIToFP , UIToFPInst ) // UInt -> floating point +HANDLE_CAST_INST(39, SIToFP , SIToFPInst ) // SInt -> floating point +HANDLE_CAST_INST(40, FPTrunc , FPTruncInst ) // Truncate floating point +HANDLE_CAST_INST(41, FPExt , FPExtInst ) // Extend floating point +HANDLE_CAST_INST(42, PtrToInt, PtrToIntInst) // Pointer -> Integer +HANDLE_CAST_INST(43, IntToPtr, IntToPtrInst) // Integer -> Pointer +HANDLE_CAST_INST(44, BitCast , BitCastInst ) // Type cast +HANDLE_CAST_INST(45, AddrSpaceCast, AddrSpaceCastInst) // addrspace cast + LAST_CAST_INST(45) // Other operators... - FIRST_OTHER_INST(51) -HANDLE_OTHER_INST(51, ICmp , ICmpInst ) // Integer comparison instruction -HANDLE_OTHER_INST(52, FCmp , FCmpInst ) // Floating point comparison instr. -HANDLE_OTHER_INST(53, PHI , PHINode ) // PHI node instruction -HANDLE_OTHER_INST(54, Call , CallInst ) // Call a function -HANDLE_OTHER_INST(55, Select , SelectInst ) // select instruction -HANDLE_OTHER_INST(56, UserOp1, Instruction) // May be used internally in a pass -HANDLE_OTHER_INST(57, UserOp2, Instruction) // Internal to passes only -HANDLE_OTHER_INST(58, VAArg , VAArgInst ) // vaarg instruction -HANDLE_OTHER_INST(59, ExtractElement, ExtractElementInst)// extract from vector -HANDLE_OTHER_INST(60, InsertElement, InsertElementInst) // insert into vector -HANDLE_OTHER_INST(61, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. -HANDLE_OTHER_INST(62, ExtractValue, ExtractValueInst)// extract from aggregate -HANDLE_OTHER_INST(63, InsertValue, InsertValueInst) // insert into aggregate -HANDLE_OTHER_INST(64, LandingPad, LandingPadInst) // Landing pad instruction. -HANDLE_OTHER_INST(65, CleanupBlock, CleanupBlockInst) - LAST_OTHER_INST(65) + FIRST_OTHER_INST(46) +HANDLE_OTHER_INST(46, ICmp , ICmpInst ) // Integer comparison instruction +HANDLE_OTHER_INST(47, FCmp , FCmpInst ) // Floating point comparison instr. +HANDLE_OTHER_INST(48, PHI , PHINode ) // PHI node instruction +HANDLE_OTHER_INST(49, Call , CallInst ) // Call a function +HANDLE_OTHER_INST(50, Select , SelectInst ) // select instruction +HANDLE_OTHER_INST(51, UserOp1, Instruction) // May be used internally in a pass +HANDLE_OTHER_INST(52, UserOp2, Instruction) // Internal to passes only +HANDLE_OTHER_INST(53, VAArg , VAArgInst ) // vaarg instruction +HANDLE_OTHER_INST(54, ExtractElement, ExtractElementInst)// extract from vector +HANDLE_OTHER_INST(55, InsertElement, InsertElementInst) // insert into vector +HANDLE_OTHER_INST(56, ShuffleVector, ShuffleVectorInst) // shuffle two vectors. +HANDLE_OTHER_INST(57, ExtractValue, ExtractValueInst)// extract from aggregate +HANDLE_OTHER_INST(58, InsertValue, InsertValueInst) // insert into aggregate +HANDLE_OTHER_INST(59, LandingPad, LandingPadInst) // Landing pad instruction. + LAST_OTHER_INST(59) #undef FIRST_TERM_INST #undef HANDLE_TERM_INST diff --git a/include/llvm/IR/Instruction.h b/include/llvm/IR/Instruction.h index a81c97db96e..31f363f70a5 100644 --- a/include/llvm/IR/Instruction.h +++ b/include/llvm/IR/Instruction.h @@ -388,20 +388,6 @@ public: return mayWriteToMemory() || mayThrow() || !mayReturn(); } - /// \brief Return true if the instruction is a variety of EH-block. - bool isEHBlock() const { - switch (getOpcode()) { - case Instruction::CatchBlock: - case Instruction::CatchEndBlock: - case Instruction::CleanupBlock: - case Instruction::LandingPad: - case Instruction::TerminateBlock: - return true; - default: - return false; - } - } - /// clone() - Create a copy of 'this' instruction that is identical in all /// ways except the following: /// * The instruction has no parent diff --git a/include/llvm/IR/Instructions.h b/include/llvm/IR/Instructions.h index 60ead82e0e2..62723e44c0c 100644 --- a/include/llvm/IR/Instructions.h +++ b/include/llvm/IR/Instructions.h @@ -3551,526 +3551,6 @@ struct OperandTraits : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value) -//===----------------------------------------------------------------------===// -// CleanupReturnInst Class -//===----------------------------------------------------------------------===// - -class CleanupReturnInst : public TerminatorInst { - CleanupReturnInst(const CleanupReturnInst &RI); - -private: - void init(Value *RetVal, BasicBlock *UnwindBB); - CleanupReturnInst(LLVMContext &C, Value *RetVal, BasicBlock *UnwindBB, - unsigned Values, Instruction *InsertBefore = nullptr); - CleanupReturnInst(LLVMContext &C, Value *RetVal, BasicBlock *UnwindBB, - unsigned Values, BasicBlock *InsertAtEnd); - - int getUnwindLabelOpIdx() const { - assert(hasUnwindDest()); - return 0; - } - - int getRetValOpIdx() const { - assert(hasReturnValue()); - if (hasUnwindDest()) - return 1; - return 0; - } - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - CleanupReturnInst *cloneImpl() const; - -public: - static CleanupReturnInst *Create(LLVMContext &C, - Value *RetVal = nullptr, - BasicBlock *UnwindBB = nullptr, - Instruction *InsertBefore = nullptr) { - unsigned Values = 0; - if (RetVal) - ++Values; - if (UnwindBB) - ++Values; - return new (Values) - CleanupReturnInst(C, RetVal, UnwindBB, Values, InsertBefore); - } - static CleanupReturnInst *Create(LLVMContext &C, Value *RetVal, - BasicBlock *UnwindBB, - BasicBlock *InsertAtEnd) { - unsigned Values = 0; - if (RetVal) - ++Values; - if (UnwindBB) - ++Values; - return new (Values) - CleanupReturnInst(C, RetVal, UnwindBB, Values, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; } - bool unwindsToCaller() const { return !hasUnwindDest(); } - bool hasReturnValue() const { return getSubclassDataFromInstruction() & 2; } - - /// Convenience accessor. Returns null if there is no return value. - Value *getReturnValue() const { - if (!hasReturnValue()) - return nullptr; - return getOperand(getRetValOpIdx()); - } - void setReturnValue(Value *RetVal) { - assert(hasReturnValue()); - setOperand(getRetValOpIdx(), RetVal); - } - - unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; } - - BasicBlock *getUnwindDest() const; - void setUnwindDest(BasicBlock *NewDest); - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::CleanupRet); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - -private: - BasicBlock *getSuccessorV(unsigned Idx) const override; - unsigned getNumSuccessorsV() const override; - void setSuccessorV(unsigned Idx, BasicBlock *B) override; - - // Shadow Instruction::setInstructionSubclassData with a private forwarding - // method so that subclasses cannot accidentally use it. - void setInstructionSubclassData(unsigned short D) { - Instruction::setInstructionSubclassData(D); - } -}; - -template <> -struct OperandTraits - : public VariadicOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupReturnInst, Value) - -//===----------------------------------------------------------------------===// -// CatchEndBlockInst Class -//===----------------------------------------------------------------------===// - -class CatchEndBlockInst : public TerminatorInst { - CatchEndBlockInst(const CatchEndBlockInst &RI); - -private: - void init(BasicBlock *UnwindBB); - CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values, - Instruction *InsertBefore = nullptr); - CatchEndBlockInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values, - BasicBlock *InsertAtEnd); - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - CatchEndBlockInst *cloneImpl() const; - -public: - static CatchEndBlockInst *Create(LLVMContext &C, - BasicBlock *UnwindBB = nullptr, - Instruction *InsertBefore = nullptr) { - unsigned Values = UnwindBB ? 1 : 0; - return new (Values) CatchEndBlockInst(C, UnwindBB, Values, InsertBefore); - } - static CatchEndBlockInst *Create(LLVMContext &C, BasicBlock *UnwindBB, - BasicBlock *InsertAtEnd) { - unsigned Values = UnwindBB ? 1 : 0; - return new (Values) CatchEndBlockInst(C, UnwindBB, Values, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; } - bool unwindsToCaller() const { return !hasUnwindDest(); } - - /// Convenience accessor. Returns null if there is no return value. - unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; } - - BasicBlock *getUnwindDest() const { return cast(Op<-1>()); } - void setUnwindDest(BasicBlock *NewDest) { - assert(NewDest); - Op<-1>() = NewDest; - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::CatchEndBlock); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - -private: - BasicBlock *getSuccessorV(unsigned Idx) const override; - unsigned getNumSuccessorsV() const override; - void setSuccessorV(unsigned Idx, BasicBlock *B) override; - -private: - // Shadow Instruction::setInstructionSubclassData with a private forwarding - // method so that subclasses cannot accidentally use it. - void setInstructionSubclassData(unsigned short D) { - Instruction::setInstructionSubclassData(D); - } -}; - -template <> -struct OperandTraits - : public VariadicOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchEndBlockInst, Value) - -//===----------------------------------------------------------------------===// -// CatchBlockInst Class -//===----------------------------------------------------------------------===// - -class CatchBlockInst : public TerminatorInst { -private: - void init(BasicBlock *IfNormal, BasicBlock *IfException, - ArrayRef Args, const Twine &NameStr); - - CatchBlockInst(const CatchBlockInst &CBI); - - explicit CatchBlockInst(Type *RetTy, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - unsigned Values, const Twine &NameStr, - Instruction *InsertBefore); - explicit CatchBlockInst(Type *RetTy, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - unsigned Values, const Twine &NameStr, - BasicBlock *InsertAtEnd); - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - CatchBlockInst *cloneImpl() const; - -public: - static CatchBlockInst *Create(Type *RetTy, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { - unsigned Values = unsigned(Args.size()) + 2; - return new (Values) CatchBlockInst(RetTy, IfNormal, IfException, Args, - Values, NameStr, InsertBefore); - } - static CatchBlockInst *Create(Type *RetTy, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - unsigned Values = unsigned(Args.size()) + 2; - return new (Values) CatchBlockInst(RetTy, IfNormal, IfException, Args, - Values, NameStr, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - /// getNumArgOperands - Return the number of catchblock arguments. - /// - unsigned getNumArgOperands() const { return getNumOperands() - 2; } - - /// getArgOperand/setArgOperand - Return/set the i-th catchblock argument. - /// - Value *getArgOperand(unsigned i) const { return getOperand(i); } - void setArgOperand(unsigned i, Value *v) { setOperand(i, v); } - - /// arg_operands - iteration adapter for range-for loops. - iterator_range arg_operands() { - return iterator_range(op_begin(), op_end() - 2); - } - - /// arg_operands - iteration adapter for range-for loops. - iterator_range arg_operands() const { - return iterator_range(op_begin(), op_end() - 2); - } - - /// \brief Wrappers for getting the \c Use of a catchblock argument. - const Use &getArgOperandUse(unsigned i) const { return getOperandUse(i); } - Use &getArgOperandUse(unsigned i) { return getOperandUse(i); } - - // get*Dest - Return the destination basic blocks... - BasicBlock *getNormalDest() const { return cast(Op<-2>()); } - BasicBlock *getUnwindDest() const { return cast(Op<-1>()); } - void setNormalDest(BasicBlock *B) { Op<-2>() = reinterpret_cast(B); } - void setUnwindDest(BasicBlock *B) { Op<-1>() = reinterpret_cast(B); } - - BasicBlock *getSuccessor(unsigned i) const { - assert(i < 2 && "Successor # out of range for catchblock!"); - return i == 0 ? getNormalDest() : getUnwindDest(); - } - - void setSuccessor(unsigned idx, BasicBlock *NewSucc) { - assert(idx < 2 && "Successor # out of range for catchblock!"); - *(&Op<-2>() + idx) = reinterpret_cast(NewSucc); - } - - unsigned getNumSuccessors() const { return 2; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::CatchBlock; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - -private: - BasicBlock *getSuccessorV(unsigned idx) const override; - unsigned getNumSuccessorsV() const override; - void setSuccessorV(unsigned idx, BasicBlock *B) override; -}; - -template <> -struct OperandTraits - : public VariadicOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchBlockInst, Value) - -//===----------------------------------------------------------------------===// -// TerminateBlockInst Class -//===----------------------------------------------------------------------===// - -class TerminateBlockInst : public TerminatorInst { -private: - void init(BasicBlock *BB, ArrayRef Args, const Twine &NameStr); - - TerminateBlockInst(const TerminateBlockInst &TBI); - - explicit TerminateBlockInst(LLVMContext &C, BasicBlock *BB, - ArrayRef Args, unsigned Values, - const Twine &NameStr, Instruction *InsertBefore); - explicit TerminateBlockInst(LLVMContext &C, BasicBlock *BB, - ArrayRef Args, unsigned Values, - const Twine &NameStr, BasicBlock *InsertAtEnd); - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - TerminateBlockInst *cloneImpl() const; - -public: - static TerminateBlockInst *Create(LLVMContext &C, BasicBlock *BB = nullptr, - ArrayRef Args = {}, - const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { - unsigned Values = unsigned(Args.size()); - if (BB) - ++Values; - return new (Values) - TerminateBlockInst(C, BB, Args, Values, NameStr, InsertBefore); - } - static TerminateBlockInst *Create(LLVMContext &C, BasicBlock *BB, - ArrayRef Args, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - unsigned Values = unsigned(Args.size()); - if (BB) - ++Values; - return new (Values) - TerminateBlockInst(C, BB, Args, Values, NameStr, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; } - bool unwindsToCaller() const { return !hasUnwindDest(); } - - /// getNumArgOperands - Return the number of terminateblock arguments. - /// - unsigned getNumArgOperands() const { - unsigned NumOperands = getNumOperands(); - if (hasUnwindDest()) - return NumOperands - 1; - return NumOperands; - } - - /// getArgOperand/setArgOperand - Return/set the i-th terminateblock argument. - /// - Value *getArgOperand(unsigned i) const { return getOperand(i); } - void setArgOperand(unsigned i, Value *v) { setOperand(i, v); } - - const_op_iterator arg_end() const { - if (hasUnwindDest()) - return op_end() - 1; - return op_end(); - } - - op_iterator arg_end() { - if (hasUnwindDest()) - return op_end() - 1; - return op_end(); - } - - /// arg_operands - iteration adapter for range-for loops. - iterator_range arg_operands() { - return iterator_range(op_begin(), arg_end()); - } - - /// arg_operands - iteration adapter for range-for loops. - iterator_range arg_operands() const { - return iterator_range(op_begin(), arg_end()); - } - - /// \brief Wrappers for getting the \c Use of a terminateblock argument. - const Use &getArgOperandUse(unsigned i) const { return getOperandUse(i); } - Use &getArgOperandUse(unsigned i) { return getOperandUse(i); } - - // get*Dest - Return the destination basic blocks... - BasicBlock *getUnwindDest() const { - if (!hasUnwindDest()) - return nullptr; - return cast(Op<-1>()); - } - void setUnwindDest(BasicBlock *B) { - assert(B && hasUnwindDest()); - Op<-1>() = reinterpret_cast(B); - } - - unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::TerminateBlock; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - -private: - BasicBlock *getSuccessorV(unsigned idx) const override; - unsigned getNumSuccessorsV() const override; - void setSuccessorV(unsigned idx, BasicBlock *B) override; - - // Shadow Instruction::setInstructionSubclassData with a private forwarding - // method so that subclasses cannot accidentally use it. - void setInstructionSubclassData(unsigned short D) { - Instruction::setInstructionSubclassData(D); - } -}; - -template <> -struct OperandTraits - : public VariadicOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(TerminateBlockInst, Value) - -//===----------------------------------------------------------------------===// -// CleanupBlockInst Class -//===----------------------------------------------------------------------===// - -class CleanupBlockInst : public Instruction { -private: - void init(ArrayRef Args, const Twine &NameStr); - - CleanupBlockInst(const CleanupBlockInst &TBI); - - explicit CleanupBlockInst(Type *RetTy, ArrayRef Args, - const Twine &NameStr, Instruction *InsertBefore); - explicit CleanupBlockInst(Type *RetTy, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd); - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - CleanupBlockInst *cloneImpl() const; - -public: - static CleanupBlockInst *Create(Type *RetTy, ArrayRef Args, - const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { - return new (Args.size()) - CleanupBlockInst(RetTy, Args, NameStr, InsertBefore); - } - static CleanupBlockInst *Create(Type *RetTy, ArrayRef Args, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new (Args.size()) - CleanupBlockInst(RetTy, Args, NameStr, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::CleanupBlock; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -template <> -struct OperandTraits - : public VariadicOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupBlockInst, Value) - -//===----------------------------------------------------------------------===// -// CatchReturnInst Class -//===----------------------------------------------------------------------===// - -class CatchReturnInst : public TerminatorInst { - CatchReturnInst(const CatchReturnInst &RI); - -private: - void init(Value *RetVal, BasicBlock *UnwindBB); - CatchReturnInst(BasicBlock *BB, Instruction *InsertBefore = nullptr); - CatchReturnInst(BasicBlock *BB, BasicBlock *InsertAtEnd); - -protected: - // Note: Instruction needs to be a friend here to call cloneImpl. - friend class Instruction; - CatchReturnInst *cloneImpl() const; - -public: - static CatchReturnInst *Create(BasicBlock *BB, - Instruction *InsertBefore = nullptr) { - return new (1) CatchReturnInst(BB, InsertBefore); - } - static CatchReturnInst *Create(BasicBlock *BB, BasicBlock *InsertAtEnd) { - return new (1) CatchReturnInst(BB, InsertAtEnd); - } - - /// Provide fast operand accessors - DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); - - /// Convenience accessors. - BasicBlock *getSuccessor() const { return cast(Op<0>()); } - void setSuccessor(BasicBlock *NewSucc) { Op<0>() = (Value *)NewSucc; } - unsigned getNumSuccessors() const { return 1; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::CatchRet); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } - -private: - BasicBlock *getSuccessorV(unsigned Idx) const override; - unsigned getNumSuccessorsV() const override; - void setSuccessorV(unsigned Idx, BasicBlock *B) override; -}; - -template <> -struct OperandTraits - : public FixedNumOperandTraits {}; - -DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value) - //===----------------------------------------------------------------------===// // UnreachableInst Class //===----------------------------------------------------------------------===// diff --git a/lib/Analysis/IPA/InlineCost.cpp b/lib/Analysis/IPA/InlineCost.cpp index 213644c9b43..c0d2e375cb0 100644 --- a/lib/Analysis/IPA/InlineCost.cpp +++ b/lib/Analysis/IPA/InlineCost.cpp @@ -156,8 +156,6 @@ class CallAnalyzer : public InstVisitor { 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/lib/AsmParser/LLLexer.cpp b/lib/AsmParser/LLLexer.cpp index 69c2048aae2..88f359d4fd5 100644 --- a/lib/AsmParser/LLLexer.cpp +++ b/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/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index 05373bf05d9..91a88bc91fd 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/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 &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 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 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 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/lib/AsmParser/LLParser.h b/lib/AsmParser/LLParser.h index 2a39b6d364d..6e57b3e0667 100644 --- a/lib/AsmParser/LLParser.h +++ b/lib/AsmParser/LLParser.h @@ -381,9 +381,6 @@ namespace llvm { bool IsMustTailCall = false, bool InVarArgsFunc = false); - bool ParseExceptionArgs(SmallVectorImpl &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/lib/AsmParser/LLToken.h b/lib/AsmParser/LLToken.h index 6e24224978e..2487d120813 100644 --- a/lib/AsmParser/LLToken.h +++ b/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/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index f13fc0476eb..563e201336a 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/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 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 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 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/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index c1fd66668f8..622f7eaf078 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/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(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(I); - Vals.push_back(VE.getValueID(CRI.getSuccessor())); - break; - } - case Instruction::CatchBlock: { - Code = bitc::FUNC_CODE_INST_CATCHBLOCK; - const auto &CBI = cast(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(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(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(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/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 05010ecf7e1..2c3c0eb101a 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/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/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h index df85e233b79..700675453fe 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h +++ b/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/lib/CodeGen/TargetLoweringBase.cpp b/lib/CodeGen/TargetLoweringBase.cpp index b8ddcfe01b7..ecfd6593157 100644 --- a/lib/CodeGen/TargetLoweringBase.cpp +++ b/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/lib/IR/AsmWriter.cpp b/lib/IR/AsmWriter.cpp index a866828c31b..adc620db897 100644 --- a/lib/IR/AsmWriter.cpp +++ b/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(&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(&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(&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(I) && !Operand) { Out << " void"; - } else if (const auto *CRI = dyn_cast(&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(&I)) { - Out << " unwind "; - if (CEBI->hasUnwindDest()) - writeOperand(CEBI->getUnwindDest(), /*PrintType=*/true); - else - Out << "to caller"; } else if (const CallInst *CI = dyn_cast(&I)) { // Print the calling convention being used. if (CI->getCallingConv() != CallingConv::C) { diff --git a/lib/IR/BasicBlock.cpp b/lib/IR/BasicBlock.cpp index 658c5e24216..0a0449434a7 100644 --- a/lib/IR/BasicBlock.cpp +++ b/lib/IR/BasicBlock.cpp @@ -197,7 +197,7 @@ BasicBlock::iterator BasicBlock::getFirstInsertionPt() { return end(); iterator InsertPt = FirstNonPHI; - if (InsertPt->isEHBlock()) ++InsertPt; + if (isa(InsertPt)) ++InsertPt; return InsertPt; } diff --git a/lib/IR/Instruction.cpp b/lib/IR/Instruction.cpp index 2b09e551b79..c57ba16cf6c 100644 --- a/lib/IR/Instruction.cpp +++ b/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 " "; } @@ -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(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(this)->onlyReadsMemory(); @@ -465,12 +455,6 @@ bool Instruction::isAtomic() const { bool Instruction::mayThrow() const { if (const CallInst *CI = dyn_cast(this)) return !CI->doesNotThrow(); - if (const auto *CRI = dyn_cast(this)) - return CRI->unwindsToCaller(); - if (const auto *CEBI = dyn_cast(this)) - return CEBI->unwindsToCaller(); - if (const auto *TBI = dyn_cast(this)) - return TBI->unwindsToCaller(); return isa(this); } diff --git a/lib/IR/Instructions.cpp b/lib/IR/Instructions.cpp index 02cb1205da9..86c921aeda8 100644 --- a/lib/IR/Instructions.cpp +++ b/lib/IR/Instructions.cpp @@ -670,303 +670,6 @@ BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const { llvm_unreachable("ResumeInst has no successors!"); } -//===----------------------------------------------------------------------===// -// CleanupReturnInst Implementation -//===----------------------------------------------------------------------===// - -CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI) - : TerminatorInst(CRI.getType(), Instruction::CleanupRet, - OperandTraits::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::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::op_end(this) - Values, - Values, InsertAtEnd) { - init(RetVal, UnwindBB); -} - -BasicBlock *CleanupReturnInst::getUnwindDest() const { - if (hasUnwindDest()) - return cast(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::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::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::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::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::op_begin(this), 1, - InsertBefore) { - Op<0>() = BB; -} - -CatchReturnInst::CatchReturnInst(BasicBlock *BB, BasicBlock *InsertAtEnd) - : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, - OperandTraits::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 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::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 Args, - unsigned Values, const Twine &NameStr, - Instruction *InsertBefore) - : TerminatorInst(RetTy, Instruction::CatchBlock, - OperandTraits::op_end(this) - Values, - Values, InsertBefore) { - init(IfNormal, IfException, Args, NameStr); -} - -CatchBlockInst::CatchBlockInst(Type *RetTy, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - unsigned Values, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : TerminatorInst(RetTy, Instruction::CatchBlock, - OperandTraits::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 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::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 Args, unsigned Values, - const Twine &NameStr, - Instruction *InsertBefore) - : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock, - OperandTraits::op_end(this) - Values, - Values, InsertBefore) { - init(BB, Args, NameStr); -} - -TerminateBlockInst::TerminateBlockInst(LLVMContext &C, BasicBlock *BB, - ArrayRef Args, unsigned Values, - const Twine &NameStr, - BasicBlock *InsertAtEnd) - : TerminatorInst(Type::getVoidTy(C), Instruction::TerminateBlock, - OperandTraits::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 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::op_end(this) - - CBI.getNumOperands(), - CBI.getNumOperands()) { - std::copy(CBI.op_begin(), CBI.op_end(), op_begin()); -} - -CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef Args, - const Twine &NameStr, - Instruction *InsertBefore) - : Instruction(RetTy, Instruction::CleanupBlock, - OperandTraits::op_end(this) - Args.size(), - Args.size(), InsertBefore) { - init(Args, NameStr); -} - -CleanupBlockInst::CleanupBlockInst(Type *RetTy, ArrayRef Args, - const Twine &NameStr, - BasicBlock *InsertAtEnd) - : Instruction(RetTy, Instruction::CleanupBlock, - OperandTraits::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/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp index c85be99bc24..647920f23da 100644 --- a/lib/IR/Verifier.cpp +++ b/lib/IR/Verifier.cpp @@ -184,9 +184,6 @@ class Verifier : public InstVisitor, VerifierSupport { /// \brief Track unresolved string-based type references. SmallDenseMap 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, 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(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(I) || isa(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(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(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(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(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(I.getOperand(i)); // If the we have an invalid invoke, don't try to compute the dominance. diff --git a/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/lib/Transforms/Instrumentation/MemorySanitizer.cpp index ee77882e7ca..286a5633024 100644 --- a/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -2653,30 +2653,6 @@ struct MemorySanitizerVisitor : public InstVisitor { 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 { // 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/lib/Transforms/Scalar/ADCE.cpp b/lib/Transforms/Scalar/ADCE.cpp index 0c707c49425..d6fc9164158 100644 --- a/lib/Transforms/Scalar/ADCE.cpp +++ b/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(I) || isa(I) || I.isEHBlock() || - I.mayHaveSideEffects()) { + if (isa(I) || isa(I) || + isa(I) || I.mayHaveSideEffects()) { Alive.insert(&I); Worklist.push_back(&I); } diff --git a/lib/Transforms/Scalar/BDCE.cpp b/lib/Transforms/Scalar/BDCE.cpp index e484069f82a..09c605e7673 100644 --- a/lib/Transforms/Scalar/BDCE.cpp +++ b/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(I) || isa(I) || I->isEHBlock() || - I->mayHaveSideEffects(); + return isa(I) || isa(I) || + isa(I) || I->mayHaveSideEffects(); } void BDCE::determineLiveOperandBits(const Instruction *UserI, diff --git a/lib/Transforms/Scalar/JumpThreading.cpp b/lib/Transforms/Scalar/JumpThreading.cpp index e845a7f586b..1130d228acb 100644 --- a/lib/Transforms/Scalar/JumpThreading.cpp +++ b/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/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp index c625b0f3362..4d3a708fa20 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/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(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(TI)) return true; if (SwitchInst *SI = dyn_cast(TI)) { diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp index c761934162d..53471de6154 100644 --- a/lib/Transforms/Utils/BasicBlockUtils.cpp +++ b/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(PredBB->getTerminator())) return false; succ_iterator SI(succ_begin(PredBB)), SE(succ_end(PredBB)); BasicBlock *OnlySucc = BB; diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp index e1788c9e287..56085579b61 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -283,9 +283,8 @@ bool llvm::isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI) { if (!I->use_empty() || isa(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(I)) return false; // We don't want debug info removed by anything this general, unless diff --git a/test/Feature/exception.ll b/test/Feature/exception.ll index 3befbcd2430..7568ecfa5f7 100644 --- a/test/Feature/exception.ll +++ b/test/Feature/exception.ll @@ -25,72 +25,3 @@ lpad: ; preds = %entry declare void @_Z3quxv() optsize declare i32 @__gxx_personality_v0(...) - -define void @cleanupret0() personality i32 (...)* @__gxx_personality_v0 { -entry: - cleanupret i8 0 unwind label %bb -bb: - ret void -} - -define void @cleanupret1() personality i32 (...)* @__gxx_personality_v0 { -entry: - cleanupret void unwind label %bb -bb: - ret void -} - -define void @cleanupret2() personality i32 (...)* @__gxx_personality_v0 { -entry: - cleanupret i8 0 unwind to caller -} - -define void @cleanupret3() personality i32 (...)* @__gxx_personality_v0 { - cleanupret void unwind to caller -} - -define void @catchret() personality i32 (...)* @__gxx_personality_v0 { -entry: - br label %bb -bb: - catchret label %bb -} - -define i8 @catchblock() personality i32 (...)* @__gxx_personality_v0 { -entry: - br label %bb2 -bb: - ret i8 %cbv -bb2: - %cbv = catchblock i8 [i7 4] to label %bb unwind label %bb2 -} - -define void @terminateblock0() personality i32 (...)* @__gxx_personality_v0 { -entry: - br label %bb -bb: - terminateblock [i7 4] unwind label %bb -} - -define void @terminateblock1() personality i32 (...)* @__gxx_personality_v0 { -entry: - terminateblock [i7 4] unwind to caller -} - -define void @cleanupblock() personality i32 (...)* @__gxx_personality_v0 { -entry: - cleanupblock void [i7 4] - ret void -} - -define void @catchendblock0() personality i32 (...)* @__gxx_personality_v0 { -entry: - br label %bb -bb: - catchendblock unwind label %bb -} - -define void @catchendblock1() personality i32 (...)* @__gxx_personality_v0 { -entry: - catchendblock unwind to caller -} diff --git a/test/Verifier/invoke.ll b/test/Verifier/invoke.ll index 8fa9923c0cb..b56b72f84b9 100644 --- a/test/Verifier/invoke.ll +++ b/test/Verifier/invoke.ll @@ -2,7 +2,7 @@ ; PR1042 define i32 @foo() { -; CHECK: The unwind destination does not have an exception handling instruction +; CHECK: The unwind destination does not have a landingpad instruction %A = invoke i32 @foo( ) to label %L unwind label %L ; [#uses=1] L: ; preds = %0, %0 @@ -18,7 +18,7 @@ L1: ; preds = %0 L2: ; preds = %0 br label %L L: ; preds = %L2, %L1, %L1 -; CHECK: The unwind destination does not have an exception handling instruction +; CHECK: The unwind destination does not have a landingpad instruction ret i32 %A } diff --git a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp index d94a704dd7b..7672951f9c9 100644 --- a/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ b/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -241,11 +241,6 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID, STRINGIFY_CODE(FUNC_CODE, INST_SWITCH) STRINGIFY_CODE(FUNC_CODE, INST_INVOKE) STRINGIFY_CODE(FUNC_CODE, INST_UNREACHABLE) - STRINGIFY_CODE(FUNC_CODE, INST_CLEANUPRET) - STRINGIFY_CODE(FUNC_CODE, INST_CATCHRET) - STRINGIFY_CODE(FUNC_CODE, INST_CATCHBLOCK) - STRINGIFY_CODE(FUNC_CODE, INST_CATCHENDBLOCK) - STRINGIFY_CODE(FUNC_CODE, INST_TERMINATEBLOCK) STRINGIFY_CODE(FUNC_CODE, INST_PHI) STRINGIFY_CODE(FUNC_CODE, INST_ALLOCA) STRINGIFY_CODE(FUNC_CODE, INST_LOAD) -- 2.34.1