Index: docs/LangRef.rst =================================================================== --- docs/LangRef.rst +++ docs/LangRef.rst @@ -4727,7 +4727,11 @@ The terminator instructions are: ':ref:`ret `', ':ref:`br `', ':ref:`switch `', ':ref:`indirectbr `', ':ref:`invoke `', -':ref:`resume `', and ':ref:`unreachable `'. +':ref:`resume `', ':ref:`catchblock `', +':ref:`catchendblock `', +':ref:`catchret `', +':ref:`terminateblock `', +and ':ref:`unreachable `'. .. _i_ret: @@ -5081,6 +5085,289 @@ 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. +- 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 +the function it is located in. The +:ref:`personality function ` will look for an appropriate +catch block in the caller. + +Arguments: +"""""""""" + +The instruction optionally takes a label, ``nextaction``, indicating +where control should transfer to if none of the constituent +``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. + +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 and transfer control to +``normal``. + +Example: +"""""""" + +.. code-block:: llvm + + catchret unwind 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 the +:ref:`cleanupblock ` it transfered control to has ended. +It transfers control to ``continue`` or unwinds out of the function. + +Example: +"""""""" + +.. code-block:: llvm + + cleanupret { i8*, i32 } %exn unwind label %continue + +.. _i_terminateblock: + +'``terminateblock``' Instruction +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Syntax: +""""""" + +:: + + terminateblock [*] unwind label + +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 attempts to transfer +control 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 tranfered to the ``exception`` label if the +``terminateblock`` is an appropriate handler for the in-flight exception. +If the ``terminateblock`` is not an appropriate handler, execution of +the program is terminated via +:ref:`personality function ` specific means. + +Arguments: +"""""""""" + +The instruction takes a list of arbitrary values which are interpreted +by the :ref:`personality function `. + +The ``terminateblock`` must be provided 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 @@ -7979,6 +8266,68 @@ 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. +: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 `. + +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 Index: include/llvm-c/Core.h =================================================================== --- include/llvm-c/Core.h +++ include/llvm-c/Core.h @@ -248,7 +248,13 @@ /* Exception Handling Operators */ LLVMResume = 58, - LLVMLandingPad = 59 + LLVMLandingPad = 59, + LLVMCleanupRet = 61, + LLVMCatchRet = 62, + LLVMCatchBlock = 63, + LLVMTerminateBlock = 64, + LLVMCleanupBlock = 65, + LLVMCatchEndBlock = 66 } LLVMOpcode; @@ -1203,6 +1209,7 @@ macro(InsertElementInst) \ macro(InsertValueInst) \ macro(LandingPadInst) \ + macro(CleanupBlockInst) \ macro(PHINode) \ macro(SelectInst) \ macro(ShuffleVectorInst) \ @@ -1215,6 +1222,11 @@ macro(SwitchInst) \ macro(UnreachableInst) \ macro(ResumeInst) \ + macro(CleanupReturnInst) \ + macro(CatchReturnInst) \ + macro(CatchBlockInst) \ + macro(TerminateBlockInst) \ + macro(CatchEndBlockInst) \ macro(UnaryInstruction) \ macro(AllocaInst) \ macro(CastInst) \ Index: include/llvm/Bitcode/LLVMBitCodes.h =================================================================== --- include/llvm/Bitcode/LLVMBitCodes.h +++ include/llvm/Bitcode/LLVMBitCodes.h @@ -354,6 +354,12 @@ 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 { Index: include/llvm/IR/BasicBlock.h =================================================================== --- include/llvm/IR/BasicBlock.h +++ include/llvm/IR/BasicBlock.h @@ -309,6 +309,9 @@ /// 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 Index: include/llvm/IR/IRBuilder.h =================================================================== --- include/llvm/IR/IRBuilder.h +++ include/llvm/IR/IRBuilder.h @@ -672,6 +672,38 @@ 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)); } Index: include/llvm/IR/InstVisitor.h =================================================================== --- include/llvm/IR/InstVisitor.h +++ include/llvm/IR/InstVisitor.h @@ -169,6 +169,11 @@ 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);} @@ -200,6 +205,7 @@ 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);} Index: include/llvm/IR/InstrTypes.h =================================================================== --- include/llvm/IR/InstrTypes.h +++ include/llvm/IR/InstrTypes.h @@ -75,6 +75,22 @@ 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; + } + } }; Index: include/llvm/IR/Instruction.h =================================================================== --- include/llvm/IR/Instruction.h +++ include/llvm/IR/Instruction.h @@ -388,6 +388,20 @@ 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 Index: include/llvm/IR/Instruction.def =================================================================== --- include/llvm/IR/Instruction.def +++ include/llvm/IR/Instruction.def @@ -94,86 +94,92 @@ // 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) - LAST_TERM_INST ( 7) +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) // Standard binary operators... - 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) + 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) // Logical operators (integer operands) -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) +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) // Memory operators... - 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) + 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) // Cast operators ... // NOTE: The order matters here because CastInst::isEliminableCastPair // NOTE: (see Instructions.cpp) encodes a table based on this ordering. - 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) + 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) // Other operators... - 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) + 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) #undef FIRST_TERM_INST #undef HANDLE_TERM_INST Index: include/llvm/IR/Instructions.h =================================================================== --- include/llvm/IR/Instructions.h +++ include/llvm/IR/Instructions.h @@ -3548,6 +3548,526 @@ 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 invoke!"); + return i == 0 ? getNormalDest() : getUnwindDest(); + } + + void setSuccessor(unsigned idx, BasicBlock *NewSucc) { + assert(idx < 2 && "Successor # out of range for invoke!"); + *(&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 //===----------------------------------------------------------------------===// Index: lib/Analysis/IPA/InlineCost.cpp =================================================================== --- lib/Analysis/IPA/InlineCost.cpp +++ lib/Analysis/IPA/InlineCost.cpp @@ -156,6 +156,8 @@ bool visitSwitchInst(SwitchInst &SI); bool visitIndirectBrInst(IndirectBrInst &IBI); bool visitResumeInst(ResumeInst &RI); + bool visitCleanupReturnInst(CleanupReturnInst &RI); + bool visitCatchReturnInst(CatchReturnInst &RI); bool visitUnreachableInst(UnreachableInst &I); public: @@ -903,6 +905,18 @@ 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 Index: lib/AsmParser/LLLexer.cpp =================================================================== --- lib/AsmParser/LLLexer.cpp +++ lib/AsmParser/LLLexer.cpp @@ -524,6 +524,7 @@ KEYWORD(undef); KEYWORD(null); KEYWORD(to); + KEYWORD(caller); KEYWORD(tail); KEYWORD(musttail); KEYWORD(target); @@ -748,6 +749,12 @@ 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) \ Index: lib/AsmParser/LLParser.h =================================================================== --- lib/AsmParser/LLParser.h +++ lib/AsmParser/LLParser.h @@ -381,6 +381,9 @@ 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); @@ -441,6 +444,12 @@ 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); Index: lib/AsmParser/LLParser.cpp =================================================================== --- lib/AsmParser/LLParser.cpp +++ lib/AsmParser/LLParser.cpp @@ -4489,6 +4489,12 @@ case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); case lltok::kw_invoke: return ParseInvoke(Inst, PFS); case lltok::kw_resume: return ParseResume(Inst, PFS); + case lltok::kw_cleanupret: return ParseCleanupRet(Inst, PFS); + case lltok::kw_catchret: return ParseCatchRet(Inst, PFS); + case lltok::kw_catchblock: return ParseCatchBlock(Inst, PFS); + case lltok::kw_terminateblock: return ParseTerminateBlock(Inst, PFS); + case lltok::kw_cleanupblock: return ParseCleanupBlock(Inst, PFS); + case lltok::kw_catchendblock: return ParseCatchEndBlock(Inst, PFS); // Binary Operators. case lltok::kw_add: case lltok::kw_sub: @@ -4882,6 +4888,161 @@ 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 cleanupret")) + return true; + } else { + if (ParseTypeAndBasicBlock(UnwindBB, PFS)) { + return true; + } + } + + Inst = TerminateBlockInst::Create(Context, UnwindBB, Args); + return false; +} + +/// ParseCleanupBlock +/// ::= 'cleanupblock' ParamList +bool LLParser::ParseCleanupBlock(Instruction *&Inst, PerFunctionState &PFS) { + Type *RetType = nullptr; + + SmallVector Args; + if (ParseType(RetType, /*AllowVoid=*/true) || ParseExceptionArgs(Args, PFS)) + return true; + + Inst = CleanupBlockInst::Create(RetType, Args); + return false; +} + +/// ParseCatchEndBlock +/// ::= 'catchendblock' unwind ('to' 'caller' | TypeAndValue) +bool LLParser::ParseCatchEndBlock(Instruction *&Inst, PerFunctionState &PFS) { + if (ParseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret")) + return true; + + BasicBlock *UnwindBB = nullptr; + if (Lex.getKind() == lltok::kw_to) { + Lex.Lex(); + if (Lex.getKind() == lltok::kw_caller) { + Lex.Lex(); + } else { + return true; + } + } else { + if (ParseTypeAndBasicBlock(UnwindBB, PFS)) { + return true; + } + } + + Inst = CatchEndBlockInst::Create(Context, UnwindBB); + return false; +} + //===----------------------------------------------------------------------===// // Binary Operators. //===----------------------------------------------------------------------===// Index: lib/AsmParser/LLToken.h =================================================================== --- lib/AsmParser/LLToken.h +++ lib/AsmParser/LLToken.h @@ -51,6 +51,7 @@ kw_zeroinitializer, kw_undef, kw_null, kw_to, + kw_caller, kw_tail, kw_musttail, kw_target, @@ -176,7 +177,8 @@ kw_landingpad, kw_personality, kw_cleanup, kw_catch, kw_filter, kw_ret, kw_br, kw_switch, kw_indirectbr, kw_invoke, kw_resume, - kw_unreachable, + kw_unreachable, kw_cleanupret, kw_catchret, kw_catchblock, + kw_terminateblock, kw_cleanupblock, kw_catchendblock, kw_alloca, kw_load, kw_store, kw_fence, kw_cmpxchg, kw_atomicrmw, kw_getelementptr, Index: lib/Bitcode/Reader/BitcodeReader.cpp =================================================================== --- lib/Bitcode/Reader/BitcodeReader.cpp +++ lib/Bitcode/Reader/BitcodeReader.cpp @@ -3793,6 +3793,134 @@ } 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) { Index: lib/Bitcode/Writer/BitcodeWriter.cpp =================================================================== --- lib/Bitcode/Writer/BitcodeWriter.cpp +++ lib/Bitcode/Writer/BitcodeWriter.cpp @@ -1845,6 +1845,64 @@ 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; Index: lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h +++ lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h @@ -734,6 +734,12 @@ 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; Index: lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp =================================================================== --- lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -1161,6 +1161,30 @@ 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(); SDValue Chain = getControlRoot(); Index: lib/CodeGen/TargetLoweringBase.cpp =================================================================== --- lib/CodeGen/TargetLoweringBase.cpp +++ lib/CodeGen/TargetLoweringBase.cpp @@ -1555,6 +1555,12 @@ 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; Index: lib/IR/AsmWriter.cpp =================================================================== --- lib/IR/AsmWriter.cpp +++ lib/IR/AsmWriter.cpp @@ -2848,8 +2848,66 @@ 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) { Index: lib/IR/BasicBlock.cpp =================================================================== --- lib/IR/BasicBlock.cpp +++ lib/IR/BasicBlock.cpp @@ -197,7 +197,7 @@ return end(); iterator InsertPt = FirstNonPHI; - if (isa(InsertPt)) ++InsertPt; + if (InsertPt->isEHBlock()) ++InsertPt; return InsertPt; } Index: lib/IR/Instruction.cpp =================================================================== --- lib/IR/Instruction.cpp +++ lib/IR/Instruction.cpp @@ -196,6 +196,11 @@ case Invoke: return "invoke"; case Resume: return "resume"; case Unreachable: return "unreachable"; + case CleanupRet: return "cleanupret"; + case CatchEndBlock: return "catchendblock"; + case CatchRet: return "catchret"; + case CatchBlock: return "catchblock"; + case TerminateBlock: return "terminateblock"; // Standard binary operators... case Add: return "add"; @@ -256,6 +261,7 @@ case ExtractValue: return "extractvalue"; case InsertValue: return "insertvalue"; case LandingPad: return "landingpad"; + case CleanupBlock: return "cleanupblock"; default: return " "; } @@ -407,6 +413,8 @@ 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(); @@ -427,6 +435,8 @@ case Instruction::VAArg: case Instruction::AtomicCmpXchg: case Instruction::AtomicRMW: + case Instruction::CatchRet: + case Instruction::TerminateBlock: return true; case Instruction::Call: return !cast(this)->onlyReadsMemory(); @@ -455,6 +465,10 @@ 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(); return isa(this); } Index: lib/IR/Instructions.cpp =================================================================== --- lib/IR/Instructions.cpp +++ lib/IR/Instructions.cpp @@ -671,6 +671,303 @@ } //===----------------------------------------------------------------------===// +// 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 //===----------------------------------------------------------------------===// @@ -3618,6 +3915,30 @@ 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); Index: lib/IR/Verifier.cpp =================================================================== --- lib/IR/Verifier.cpp +++ lib/IR/Verifier.cpp @@ -380,6 +380,10 @@ void visitExtractValueInst(ExtractValueInst &EVI); void visitInsertValueInst(InsertValueInst &IVI); void visitLandingPadInst(LandingPadInst &LPI); + void visitCatchBlockInst(CatchBlockInst &CBI); + void visitCatchEndBlockInst(CatchEndBlockInst &CEBI); + void visitCleanupBlockInst(CleanupBlockInst &CBI); + void visitTerminateBlockInst(TerminateBlockInst &TBI); void VerifyCallSite(CallSite CS); void verifyMustTailCall(CallInst &CI); @@ -2404,10 +2408,12 @@ void Verifier::visitInvokeInst(InvokeInst &II) { VerifyCallSite(&II); - // Verify that there is a landingpad instruction as the first non-PHI + // Verify that there is an exception block instruction is the first non-PHI // instruction of the 'unwind' destination. - Assert(II.getUnwindDest()->isLandingPad(), - "The unwind destination does not have a landingpad instruction!", &II); + Assert( + II.getUnwindDest()->isEHBlock(), + "The unwind destination does not have an exception handling instruction!", + &II); visitTerminatorInst(II); } @@ -2819,6 +2825,72 @@ visitInstruction(LPI); } +void Verifier::visitCatchBlockInst(CatchBlockInst &CBI) { + BasicBlock *BB = CBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CatchBlockInst needs to be in a function with a personality.", &CBI); + + // The catchblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CBI, + "CatchBlockInst not the first non-PHI instruction in the block.", + &CBI); + + visitTerminatorInst(CBI); +} + +void Verifier::visitCatchEndBlockInst(CatchEndBlockInst &CEBI) { + BasicBlock *BB = CEBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CatchEndBlockInst needs to be in a function with a personality.", + &CEBI); + + // The catchendblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CEBI, + "CatchEndBlockInst not the first non-PHI instruction in the block.", + &CEBI); + + visitTerminatorInst(CEBI); +} + +void Verifier::visitCleanupBlockInst(CleanupBlockInst &CBI) { + BasicBlock *BB = CBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "CleanupBlockInst needs to be in a function with a personality.", &CBI); + + // The cleanupblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &CBI, + "CleanupBlockInst not the first non-PHI instruction in the block.", + &CBI); + + visitInstruction(CBI); +} + +void Verifier::visitTerminateBlockInst(TerminateBlockInst &TBI) { + BasicBlock *BB = TBI.getParent(); + + Function *F = BB->getParent(); + Assert(F->hasPersonalityFn(), + "TerminateBlockInst needs to be in a function with a personality.", + &TBI); + + // The terminateblock instruction must be the first non-PHI instruction in the + // block. + Assert(BB->getFirstNonPHI() == &TBI, + "TerminateBlockInst not the first non-PHI instruction in the block.", + &TBI); + + visitTerminatorInst(TBI); +} + void Verifier::verifyDominatesUse(Instruction &I, unsigned i) { Instruction *Op = cast(I.getOperand(i)); // If the we have an invalid invoke, don't try to compute the dominance. Index: lib/Transforms/Instrumentation/MemorySanitizer.cpp =================================================================== --- lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -2653,6 +2653,26 @@ setOrigin(&I, getCleanOrigin()); } + void visitCleanupBlockInst(CleanupBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitCatchBlock(CatchBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitTerminateBlock(TerminateBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + + void visitCatchEndBlockInst(CatchEndBlockInst &I) { + setShadow(&I, getCleanShadow(&I)); + setOrigin(&I, getCleanOrigin()); + } + void visitGetElementPtrInst(GetElementPtrInst &I) { handleShadowOr(I); } @@ -2696,6 +2716,16 @@ // 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) Index: lib/Transforms/Scalar/ADCE.cpp =================================================================== --- lib/Transforms/Scalar/ADCE.cpp +++ lib/Transforms/Scalar/ADCE.cpp @@ -58,8 +58,8 @@ // Collect the set of "root" instructions that are known live. for (Instruction &I : inst_range(F)) { - if (isa(I) || isa(I) || - isa(I) || I.mayHaveSideEffects()) { + if (isa(I) || isa(I) || I.isEHBlock() || + I.mayHaveSideEffects()) { Alive.insert(&I); Worklist.push_back(&I); } Index: lib/Transforms/Scalar/BDCE.cpp =================================================================== --- lib/Transforms/Scalar/BDCE.cpp +++ lib/Transforms/Scalar/BDCE.cpp @@ -77,8 +77,8 @@ false, false) static bool isAlwaysLive(Instruction *I) { - return isa(I) || isa(I) || - isa(I) || I->mayHaveSideEffects(); + return isa(I) || isa(I) || I->isEHBlock() || + I->mayHaveSideEffects(); } void BDCE::determineLiveOperandBits(const Instruction *UserI, Index: lib/Transforms/Scalar/JumpThreading.cpp =================================================================== --- lib/Transforms/Scalar/JumpThreading.cpp +++ lib/Transforms/Scalar/JumpThreading.cpp @@ -669,7 +669,8 @@ // because now the condition in this block can be threaded through // predecessors of our predecessor block. if (BasicBlock *SinglePred = BB->getSinglePredecessor()) { - if (SinglePred->getTerminator()->getNumSuccessors() == 1 && + const TerminatorInst *TI = SinglePred->getTerminator(); + if (!TI->isExceptional() && TI->getNumSuccessors() == 1 && SinglePred != BB && !hasAddressTakenAndUsed(BB)) { // If SinglePred was a loop header, BB becomes one. if (LoopHeaders.erase(SinglePred)) Index: lib/Transforms/Scalar/SCCP.cpp =================================================================== --- lib/Transforms/Scalar/SCCP.cpp +++ lib/Transforms/Scalar/SCCP.cpp @@ -539,9 +539,9 @@ return; } - if (isa(TI)) { - // Invoke instructions successors are always executable. - Succs[0] = Succs[1] = true; + // Unwinding instructions successors are always executable. + if (TI.isExceptional()) { + Succs.assign(TI.getNumSuccessors(), true); return; } @@ -605,8 +605,8 @@ return BI->getSuccessor(CI->isZero()) == To; } - // Invoke instructions successors are always executable. - if (isa(TI)) + // Unwinding instructions successors are always executable. + if (TI->isExceptional()) return true; if (SwitchInst *SI = dyn_cast(TI)) { Index: lib/Transforms/Utils/BasicBlockUtils.cpp =================================================================== --- lib/Transforms/Utils/BasicBlockUtils.cpp +++ lib/Transforms/Utils/BasicBlockUtils.cpp @@ -119,8 +119,9 @@ // Don't break self-loops. if (PredBB == BB) return false; - // Don't break invokes. - if (isa(PredBB->getTerminator())) return false; + // Don't break unwinding instructions. + if (PredBB->getTerminator()->isExceptional()) + return false; succ_iterator SI(succ_begin(PredBB)), SE(succ_end(PredBB)); BasicBlock *OnlySucc = BB; Index: lib/Transforms/Utils/Local.cpp =================================================================== --- lib/Transforms/Utils/Local.cpp +++ lib/Transforms/Utils/Local.cpp @@ -283,8 +283,9 @@ const TargetLibraryInfo *TLI) { if (!I->use_empty() || isa(I)) return false; - // We don't want the landingpad instruction removed by anything this general. - if (isa(I)) + // We don't want the landingpad-like instructions removed by anything this + // general. + if (I->isEHBlock()) return false; // We don't want debug info removed by anything this general, unless Index: test/Feature/exception.ll =================================================================== --- test/Feature/exception.ll +++ test/Feature/exception.ll @@ -25,3 +25,72 @@ 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: + %cbv = catchblock i8 [i7 4] to label %bb unwind label %bb2 +bb: + ret i8 %cbv +bb2: + ret i8 42 +} + +define void @terminateblock0() personality i32 (...)* @__gxx_personality_v0 { +entry: + terminateblock [i7 4] unwind label %bb +bb: + ret void +} + +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: + catchendblock unwind label %bb +bb: + ret void +} + +define void @catchendblock1() personality i32 (...)* @__gxx_personality_v0 { +entry: + catchendblock unwind to caller +} Index: test/Verifier/invoke.ll =================================================================== --- test/Verifier/invoke.ll +++ test/Verifier/invoke.ll @@ -2,7 +2,7 @@ ; PR1042 define i32 @foo() { -; CHECK: The unwind destination does not have a landingpad instruction +; CHECK: The unwind destination does not have an exception handling instruction %A = invoke i32 @foo( ) to label %L unwind label %L ; [#uses=1] L: ; preds = %0, %0 @@ -18,7 +18,7 @@ L2: ; preds = %0 br label %L L: ; preds = %L2, %L1, %L1 -; CHECK: The unwind destination does not have a landingpad instruction +; CHECK: The unwind destination does not have an exception handling instruction ret i32 %A } Index: tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp =================================================================== --- tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp +++ tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp @@ -241,6 +241,11 @@ 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)