Example Diff (EHTerminatorInst)

[JosephTremoulet]

Just posted this to save the diff somewhere public.

include/llvm/IR/InstVisitor.h

#include "llvm/IR/Instruction.def"
 
   // Specific Instruction type classes... note that all of the casts are
   // necessary because we use the instruction classes as opaque types...
   //
   RetTy visitReturnInst(ReturnInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitBranchInst(BranchInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitSwitchInst(SwitchInst &I)            { DELEGATE(TerminatorInst);}
   RetTy visitIndirectBrInst(IndirectBrInst &I)    { DELEGATE(TerminatorInst);}
-  RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(TerminatorInst);}
+  RetTy visitResumeInst(ResumeInst &I)            { DELEGATE(EHTerminatorInst);}
   RetTy visitUnreachableInst(UnreachableInst &I)  { DELEGATE(TerminatorInst);}
-  RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(TerminatorInst);}
-  RetTy visitCleanupEndPadInst(CleanupEndPadInst &I) { DELEGATE(TerminatorInst); }
-  RetTy visitCatchReturnInst(CatchReturnInst &I)  { DELEGATE(TerminatorInst); }
-  RetTy visitCatchPadInst(CatchPadInst &I)    { DELEGATE(TerminatorInst);}
-  RetTy visitCatchEndPadInst(CatchEndPadInst &I) { DELEGATE(TerminatorInst); }
-  RetTy visitTerminatePadInst(TerminatePadInst &I) { DELEGATE(TerminatorInst);}
+  RetTy visitCleanupReturnInst(CleanupReturnInst &I) { DELEGATE(EHTerminatorInst);}
+  RetTy visitCleanupEndPadInst(CleanupEndPadInst &I) { DELEGATE(EHTerminatorInst); }
+  RetTy visitCatchReturnInst(CatchReturnInst &I)  { DELEGATE(EHTerminatorInst); }
+  RetTy visitCatchPadInst(CatchPadInst &I)    { DELEGATE(EHTerminatorInst);}
+  RetTy visitCatchEndPadInst(CatchEndPadInst &I) { DELEGATE(EHTerminatorInst); }
+  RetTy visitTerminatePadInst(TerminatePadInst &I) { DELEGATE(EHTerminatorInst);}
   RetTy visitICmpInst(ICmpInst &I)                { DELEGATE(CmpInst);}
   RetTy visitFCmpInst(FCmpInst &I)                { DELEGATE(CmpInst);}
   RetTy visitAllocaInst(AllocaInst &I)            { DELEGATE(UnaryInstruction);}
   RetTy visitLoadInst(LoadInst     &I)            { DELEGATE(UnaryInstruction);}
   RetTy visitStoreInst(StoreInst   &I)            { DELEGATE(Instruction);}
   RetTy visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) { DELEGATE(Instruction);}
   RetTy visitAtomicRMWInst(AtomicRMWInst &I)      { DELEGATE(Instruction);}
   RetTy visitFenceInst(FenceInst   &I)            { DELEGATE(Instruction);}
#include "llvm/IR/Instruction.def"
   RetTy visitInvokeInst(InvokeInst &I) {
     return static_cast<SubClass*>(this)->visitCallSite(&I);
   }
 
   // Next level propagators: If the user does not overload a specific
   // instruction type, they can overload one of these to get the whole class
   // of instructions...
   //
-  RetTy visitCastInst(CastInst &I)                { DELEGATE(UnaryInstruction);}
-  RetTy visitBinaryOperator(BinaryOperator &I)    { DELEGATE(Instruction);}
-  RetTy visitCmpInst(CmpInst &I)                  { DELEGATE(Instruction);}
-  RetTy visitTerminatorInst(TerminatorInst &I)    { DELEGATE(Instruction);}
-  RetTy visitUnaryInstruction(UnaryInstruction &I){ DELEGATE(Instruction);}
+  RetTy visitCastInst(CastInst &I)                 { DELEGATE(UnaryInstruction);}
+  RetTy visitBinaryOperator(BinaryOperator &I)     { DELEGATE(Instruction);}
+  RetTy visitCmpInst(CmpInst &I)                   { DELEGATE(Instruction);}
+  RetTy visitTerminatorInst(TerminatorInst &I)     { DELEGATE(Instruction);}
+  RetTy visitEHTerminatorInst(EHTerminatorInst &I) { DELEGATE(TerminatorInst); }
+  RetTy visitUnaryInstruction(UnaryInstruction &I) { DELEGATE(Instruction);}
 
   // Provide a special visitor for a 'callsite' that visits both calls and
   // invokes. When unimplemented, properly delegates to either the terminator or
   // regular instruction visitor.
   RetTy visitCallSite(CallSite CS) {
     assert(CS);
     Instruction &I = *CS.getInstruction();
     if (CS.isCall())

include/llvm/IR/InstrTypes.h

public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->isTerminator();
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
-  // \brief Returns true if this terminator relates to exception handling.
-  bool isExceptional() const {
-    switch (getOpcode()) {
-    case Instruction::CatchPad:
-    case Instruction::CatchEndPad:
-    case Instruction::CatchRet:
-    case Instruction::CleanupEndPad:
-    case Instruction::CleanupRet:
-    case Instruction::Invoke:
-    case Instruction::Resume:
-    case Instruction::TerminatePad:
-      return true;
-    default:
-      return false;
-    }
-  }
-
   //===--------------------------------------------------------------------===//
   // succ_iterator definition
   //===--------------------------------------------------------------------===//
 
   template <class Term, class BB> // Successor Iterator
   class SuccIterator : public std::iterator<std::random_access_iterator_tag, BB,
                                             int, BB *, BB *> {
     typedef std::iterator<std::random_access_iterator_tag, BB, int, BB *, BB *>
inline succ_range successors() {
     return succ_range(succ_begin(), succ_end());
   }
   inline succ_const_range successors() const {
     return succ_const_range(succ_begin(), succ_end());
   }
 };
 
 //===----------------------------------------------------------------------===//
+//                           EHTerminatorInst Class
+//===----------------------------------------------------------------------===//
+
+/// Subclasses of this class are terminators that relate to exception
+/// propagation.  They may have an unwind successor block which exception
+/// edges target.
+///
+class EHTerminatorInst : public TerminatorInst {
+protected:
+  EHTerminatorInst(Type *Ty, Instruction::EHTermOps iType, Use *Ops,
+                   unsigned NumOps, Instruction *InsertBefore = nullptr)
+      : TerminatorInst(Ty, static_cast<Instruction::TermOps>(iType), Ops,
+                       NumOps, InsertBefore) {}
+
+  EHTerminatorInst(Type *Ty, Instruction::EHTermOps iType, Use *Ops,
+                   unsigned NumOps, BasicBlock *InsertAtEnd)
+      : TerminatorInst(Ty, static_cast<Instruction::TermOps>(iType), Ops,
+                       NumOps, InsertAtEnd) {}
+
+  // Out of line virtual method, so the vtable, etc has a home.
+  ~EHTerminatorInst() override;
+
+  /// Virtual methods - Terminators should overload these and provide inline
+  /// overrides of non-V methods.
+  virtual BasicBlock *getUnwindDestV() const = 0;
+  virtual void setUnwindDestV(BasicBlock *B) = 0;
+
+public:
+  /// Return the unwind successor.  May be null if this instruction unwinds
+  /// to caller.
+  BasicBlock *getUnwindDest() const { return getUnwindDestV(); }
+
+  /// Update the unwind successor to point at the provided block.
+  void setUnwindDest(BasicBlock *B) { setUnwindDestV(B); }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Instruction *I) {
+    return I->isEHTerminator();
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
+};
+
+//===----------------------------------------------------------------------===//
 //                          UnaryInstruction Class
 //===----------------------------------------------------------------------===//
 
 class UnaryInstruction : public Instruction {
   void *operator new(size_t, unsigned) = delete;
 
 protected:
   UnaryInstruction(Type *Ty, unsigned iType, Value *V,

include/llvm/IR/Instruction.h

public:
   // Subclass classification.
   //===--------------------------------------------------------------------===//
 
   /// getOpcode() returns a member of one of the enums like Instruction::Add.
   unsigned getOpcode() const { return getValueID() - InstructionVal; }
 
   const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
   bool isTerminator() const { return isTerminator(getOpcode()); }
+  bool isEHTerminator() const { return isEHTerminator(getOpcode()); }
   bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
   bool isShift() { return isShift(getOpcode()); }
   bool isCast() const { return isCast(getOpcode()); }
 
   static const char* getOpcodeName(unsigned OpCode);
 
   static inline bool isTerminator(unsigned OpCode) {
     return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
   }
 
+  static inline bool isEHTerminator(unsigned OpCode) {
+    return OpCode >= EHTermOpsBegin && OpCode < EHTermOpsEnd;
+  }
+
   static inline bool isBinaryOp(unsigned Opcode) {
     return Opcode >= BinaryOpsBegin && Opcode < BinaryOpsEnd;
   }
 
   /// @brief Determine if the Opcode is one of the shift instructions.
   static inline bool isShift(unsigned Opcode) {
     return Opcode >= Shl && Opcode <= AShr;
   }
public:
   //
   enum TermOps {       // These terminate basic blocks
 #define  FIRST_TERM_INST(N)             TermOpsBegin = N,
 #define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N,
 #define   LAST_TERM_INST(N)             TermOpsEnd = N+1
 #include "llvm/IR/Instruction.def"
   };
 
+  enum EHTermOps {
+#define FIRST_EH_TERM_INST(N) EHTermOpsBegin = N,
+#define HANDLE_EH_TERM_INST(N, OPC, CLASS) EH_##OPC = N,
+#define LAST_EH_TERM_INST(N) EHTermOpsEnd = N + 1
+#include "llvm/IR/Instruction.def"
+  };
+
   enum BinaryOps {
 #define  FIRST_BINARY_INST(N)             BinaryOpsBegin = N,
 #define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N,
 #define   LAST_BINARY_INST(N)             BinaryOpsEnd = N+1
 #include "llvm/IR/Instruction.def"
   };
 
   enum MemoryOps {

include/llvm/IR/Instruction.def

 #else
 #define HANDLE_TERM_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)
 #endif
 #endif
 #ifndef LAST_TERM_INST
 #define LAST_TERM_INST(num)
 #endif
 
+#ifndef FIRST_EH_TERM_INST
+#define FIRST_EH_TERM_INST(num)
+#endif
+#ifndef HANDLE_EH_TERM_INST
+#define HANDLE_EH_TERM_INST(num, opcode, Class) HANDLE_TERM_INST(num, opcode, Class)
+#endif
+#ifndef LAST_EH_TERM_INST
+#define LAST_EH_TERM_INST(num)
+#endif
+
 #ifndef FIRST_BINARY_INST
 #define FIRST_BINARY_INST(num)
 #endif
 #ifndef HANDLE_BINARY_INST
 #ifndef HANDLE_INST
 #define HANDLE_BINARY_INST(num, opcode, instclass)
 #else
 #define HANDLE_BINARY_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)

 #ifndef LAST_OTHER_INST
 #define LAST_OTHER_INST(num)
 #endif
 
 // Terminator Instructions - These instructions are used to terminate a basic
 // block of the program.   Every basic block must end with one of these
 // 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, CatchPad      , CatchPadInst)
-HANDLE_TERM_INST  (11, TerminatePad  , TerminatePadInst)
-HANDLE_TERM_INST  (12, CatchEndPad   , CatchEndPadInst)
-HANDLE_TERM_INST  (13, CleanupEndPad , CleanupEndPadInst)
+   HANDLE_TERM_INST  ( 5, Unreachable   , UnreachableInst)
+ FIRST_EH_TERM_INST  ( 6)
+HANDLE_EH_TERM_INST  ( 6, Invoke        , InvokeInst)
+HANDLE_EH_TERM_INST  ( 7, Resume        , ResumeInst)
+HANDLE_EH_TERM_INST  ( 8, CleanupRet    , CleanupReturnInst)
+HANDLE_EH_TERM_INST  ( 9, CatchRet      , CatchReturnInst)
+HANDLE_EH_TERM_INST  (10, CatchPad      , CatchPadInst)
+HANDLE_EH_TERM_INST  (11, TerminatePad  , TerminatePadInst)
+HANDLE_EH_TERM_INST  (12, CatchEndPad   , CatchEndPadInst)
+HANDLE_EH_TERM_INST  (13, CleanupEndPad , CleanupEndPadInst)
+  LAST_EH_TERM_INST  (13)
      LAST_TERM_INST  (13)
 
 // Standard binary operators...
  FIRST_BINARY_INST(14)
 HANDLE_BINARY_INST(14, Add  , BinaryOperator)
 HANDLE_BINARY_INST(15, FAdd , BinaryOperator)
 HANDLE_BINARY_INST(16, Sub  , BinaryOperator)
 HANDLE_BINARY_INST(17, FSub , BinaryOperator)
 HANDLE_BINARY_INST(18, Mul  , BinaryOperator)

 HANDLE_OTHER_INST(65, LandingPad, LandingPadInst)  // Landing pad instruction.
 HANDLE_OTHER_INST(66, CleanupPad, CleanupPadInst)
   LAST_OTHER_INST(66)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST
 #undef   LAST_TERM_INST
 
+#undef  FIRST_EH_TERM_INST
+#undef HANDLE_EH_TERM_INST
+#undef   LAST_EH_TERM_INST
+
 #undef  FIRST_BINARY_INST
 #undef HANDLE_BINARY_INST
 #undef   LAST_BINARY_INST
 
 #undef  FIRST_MEMORY_INST
 #undef HANDLE_MEMORY_INST
 #undef   LAST_MEMORY_INST
 

include/llvm/IR/Instructions.h

 
 //===----------------------------------------------------------------------===//
 //                               InvokeInst Class
 //===----------------------------------------------------------------------===//
 
 /// InvokeInst - Invoke instruction.  The SubclassData field is used to hold the
 /// calling convention of the call.
 ///
-class InvokeInst : public TerminatorInst,
+class InvokeInst : public EHTerminatorInst,
                    public OperandBundleUser<InvokeInst, User::op_iterator> {
   AttributeSet AttributeList;
   FunctionType *FTy;
   InvokeInst(const InvokeInst &BI);
   void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
             ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
             const Twine &NameStr) {
     init(cast<FunctionType>(
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(BasicBlock *B) override;
 
   bool hasFnAttrImpl(Attribute::AttrKind A) const;
 
   // 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<InvokeInst> : public VariadicOperandTraits<InvokeInst, 3> {
 };
 
 InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                        BasicBlock *IfException, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles, unsigned Values,
                        const Twine &NameStr, Instruction *InsertBefore)
-    : TerminatorInst(Ty->getReturnType(), Instruction::Invoke,
+    : EHTerminatorInst(Ty->getReturnType(), Instruction::EH_Invoke,
                        OperandTraits<InvokeInst>::op_end(this) - Values, Values,
                        InsertBefore) {
   init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
 }
 InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
                        BasicBlock *IfException, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles, unsigned Values,
                        const Twine &NameStr, BasicBlock *InsertAtEnd)
-    : TerminatorInst(
-          cast<FunctionType>(cast<PointerType>(Func->getType())
-                                 ->getElementType())->getReturnType(),
-          Instruction::Invoke, OperandTraits<InvokeInst>::op_end(this) - Values,
-          Values, InsertAtEnd) {
+    : EHTerminatorInst(cast<FunctionType>(
+                           cast<PointerType>(Func->getType())->getElementType())
+                           ->getReturnType(),
+                       Instruction::EH_Invoke,
+                       OperandTraits<InvokeInst>::op_end(this) - Values, Values,
+                       InsertAtEnd) {
   init(Func, IfNormal, IfException, Args, Bundles, NameStr);
 }
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                              ResumeInst Class
 //===----------------------------------------------------------------------===//
 
 //===---------------------------------------------------------------------------
 /// ResumeInst - Resume the propagation of an exception.
 ///
-class ResumeInst : public TerminatorInst {
+class ResumeInst : public EHTerminatorInst {
   ResumeInst(const ResumeInst &RI);
 
   explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
   ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(BasicBlock *B) override;
 };
 
 template <>
 struct OperandTraits<ResumeInst> :
     public FixedNumOperandTraits<ResumeInst, 1> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CatchEndPadInst Class
 //===----------------------------------------------------------------------===//
 
-class CatchEndPadInst : public TerminatorInst {
+class CatchEndPadInst : public EHTerminatorInst {
 private:
   CatchEndPadInst(const CatchEndPadInst &RI);
 
   void init(BasicBlock *UnwindBB);
   CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values,
                   Instruction *InsertBefore = nullptr);
   CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB, unsigned Values,
                   BasicBlock *InsertAtEnd);
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned Idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(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<CatchEndPadInst>
     : public VariadicOperandTraits<CatchEndPadInst> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchEndPadInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                           CatchPadInst Class
 //===----------------------------------------------------------------------===//
 
-class CatchPadInst : public TerminatorInst {
+class CatchPadInst : public EHTerminatorInst {
 private:
   void init(BasicBlock *IfNormal, BasicBlock *IfException,
             ArrayRef<Value *> Args, const Twine &NameStr);
 
   CatchPadInst(const CatchPadInst &CPI);
 
   explicit CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
                         ArrayRef<Value *> Args, unsigned Values,
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(BasicBlock *B) override;
 };
 
 template <>
 struct OperandTraits<CatchPadInst>
     : public VariadicOperandTraits<CatchPadInst, /*MINARITY=*/2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchPadInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                           TerminatePadInst Class
 //===----------------------------------------------------------------------===//
 
-class TerminatePadInst : public TerminatorInst {
+class TerminatePadInst : public EHTerminatorInst {
 private:
   void init(BasicBlock *BB, ArrayRef<Value *> Args);
 
   TerminatePadInst(const TerminatePadInst &TPI);
 
   explicit TerminatePadInst(LLVMContext &C, BasicBlock *BB,
                             ArrayRef<Value *> Args, unsigned Values,
                             Instruction *InsertBefore);
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(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);
   }
 };
 
struct OperandTraits<CleanupPadInst>
     : public VariadicOperandTraits<CleanupPadInst, /*MINARITY=*/0> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupPadInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CatchReturnInst Class
 //===----------------------------------------------------------------------===//
 
-class CatchReturnInst : public TerminatorInst {
+class CatchReturnInst : public EHTerminatorInst {
   CatchReturnInst(const CatchReturnInst &RI);
 
   void init(CatchPadInst *CatchPad, BasicBlock *BB);
   CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
                   Instruction *InsertBefore);
   CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
                   BasicBlock *InsertAtEnd);
 
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned Idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(BasicBlock *B) override;
 };
 
 template <>
 struct OperandTraits<CatchReturnInst>
     : public FixedNumOperandTraits<CatchReturnInst, 2> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CleanupEndPadInst Class
 //===----------------------------------------------------------------------===//
 
-class CleanupEndPadInst : public TerminatorInst {
+class CleanupEndPadInst : public EHTerminatorInst {
 private:
   CleanupEndPadInst(const CleanupEndPadInst &CEPI);
 
   void init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB);
   CleanupEndPadInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
                     unsigned Values, Instruction *InsertBefore = nullptr);
   CleanupEndPadInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
                     unsigned Values, BasicBlock *InsertAtEnd);
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned Idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(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<CleanupEndPadInst>
     : public VariadicOperandTraits<CleanupEndPadInst, /*MINARITY=*/1> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupEndPadInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CleanupReturnInst Class
 //===----------------------------------------------------------------------===//
 
-class CleanupReturnInst : public TerminatorInst {
+class CleanupReturnInst : public EHTerminatorInst {
 private:
   CleanupReturnInst(const CleanupReturnInst &RI);
 
   void init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB);
   CleanupReturnInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
                     unsigned Values, Instruction *InsertBefore = nullptr);
   CleanupReturnInst(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB,
                     unsigned Values, BasicBlock *InsertAtEnd);
public:
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   BasicBlock *getSuccessorV(unsigned Idx) const override;
   unsigned getNumSuccessorsV() const override;
   void setSuccessorV(unsigned Idx, BasicBlock *B) override;
+  BasicBlock *getUnwindDestV() const override;
+  void setUnwindDestV(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);
   }
 };
 

lib/IR/Instructions.cpp

 //                            TerminatorInst Class
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method, so the vtable, etc has a home.
 TerminatorInst::~TerminatorInst() {
 }
 
 //===----------------------------------------------------------------------===//
+//                            EHTerminatorInst Class
+//===----------------------------------------------------------------------===//
+
+// Out of line virtual method, so the vtable, etc has a home.
+EHTerminatorInst::~EHTerminatorInst() {
+}
+
+//===----------------------------------------------------------------------===//
 //                           UnaryInstruction Class
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method, so the vtable, etc has a home.
 UnaryInstruction::~UnaryInstruction() {
 }
 
 //===----------------------------------------------------------------------===//
#endif
   auto It = populateBundleOperandInfos(Bundles, Args.size());
   (void)It;
   assert(It + 3 == op_end() && "Should add up!");
 
   setName(NameStr);
 }
 
 InvokeInst::InvokeInst(const InvokeInst &II)
-    : TerminatorInst(II.getType(), Instruction::Invoke,
+    : EHTerminatorInst(II.getType(), Instruction::EH_Invoke,
                        OperandTraits<InvokeInst>::op_end(this) -
                            II.getNumOperands(),
                        II.getNumOperands()),
       AttributeList(II.AttributeList), FTy(II.FTy) {
   setCallingConv(II.getCallingConv());
   std::copy(II.op_begin(), II.op_end(), op_begin());
   std::copy(II.bundle_op_info_begin(), II.bundle_op_info_end(),
             bundle_op_info_begin());
   SubclassOptionalData = II.SubclassOptionalData;
 }
 
 BasicBlock *InvokeInst::getSuccessorV(unsigned idx) const {
   return getSuccessor(idx);
 }
 unsigned InvokeInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
   return setSuccessor(idx, B);
 }
+BasicBlock *InvokeInst::getUnwindDestV() const { return getUnwindDest(); }
+void InvokeInst::setUnwindDestV(BasicBlock *B) { return setUnwindDest(B); }
 
 bool InvokeInst::hasFnAttrImpl(Attribute::AttrKind A) const {
   if (AttributeList.hasAttribute(AttributeSet::FunctionIndex, A))
     return true;
   if (const Function *F = getCalledFunction())
     return F->getAttributes().hasAttribute(AttributeSet::FunctionIndex, A);
   return false;
 }

 ReturnInst::~ReturnInst() {
 }
 
 //===----------------------------------------------------------------------===//
 //                        ResumeInst Implementation
 //===----------------------------------------------------------------------===//
 
 ResumeInst::ResumeInst(const ResumeInst &RI)
-  : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Resume,
+    : EHTerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::EH_Resume,
                        OperandTraits<ResumeInst>::op_begin(this), 1) {
   Op<0>() = RI.Op<0>();
 }
 
 ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
-  : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
-                   OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
+    : EHTerminatorInst(
+          Type::getVoidTy(Exn->getContext()), Instruction::EH_Resume,
   Op<0>() = Exn;
 }
 
 ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd)
-  : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
-                   OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) {
+    : EHTerminatorInst(
+          Type::getVoidTy(Exn->getContext()), Instruction::EH_Resume,
   Op<0>() = Exn;
 }
 
 unsigned ResumeInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 
 void ResumeInst::setSuccessorV(unsigned idx, BasicBlock *NewSucc) {
   llvm_unreachable("ResumeInst has no successors!");
 }
 
 BasicBlock *ResumeInst::getSuccessorV(unsigned idx) const {
   llvm_unreachable("ResumeInst has no successors!");
 }
 
+BasicBlock *ResumeInst::getUnwindDestV() const {
+  llvm_unreachable("ResumeInst has no successors!");
+}
+void ResumeInst::setUnwindDestV(BasicBlock *B) {
+  llvm_unreachable("ResumeInst has no successors!");
+}
+
 //===----------------------------------------------------------------------===//
 //                        CleanupEndPadInst Implementation
 //===----------------------------------------------------------------------===//
 
 CleanupEndPadInst::CleanupEndPadInst(const CleanupEndPadInst &CEPI)
-    : TerminatorInst(CEPI.getType(), Instruction::CleanupEndPad,
+    : EHTerminatorInst(CEPI.getType(), Instruction::EH_CleanupEndPad,
                        OperandTraits<CleanupEndPadInst>::op_end(this) -
                            CEPI.getNumOperands(),
                        CEPI.getNumOperands()) {
   setInstructionSubclassData(CEPI.getSubclassDataFromInstruction());
   setCleanupPad(CEPI.getCleanupPad());
   if (BasicBlock *UnwindDest = CEPI.getUnwindDest())
     setUnwindDest(UnwindDest);
 }
 
 void CleanupEndPadInst::init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB) {
   setCleanupPad(CleanupPad);
   if (UnwindBB) {
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
     setUnwindDest(UnwindBB);
   }
 }
 
 CleanupEndPadInst::CleanupEndPadInst(CleanupPadInst *CleanupPad,
                                      BasicBlock *UnwindBB, unsigned Values,
                                      Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupEndPad,
+    : EHTerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+                       Instruction::EH_CleanupEndPad,
                        OperandTraits<CleanupEndPadInst>::op_end(this) - Values,
                        Values, InsertBefore) {
   init(CleanupPad, UnwindBB);
 }
 
 CleanupEndPadInst::CleanupEndPadInst(CleanupPadInst *CleanupPad,
                                      BasicBlock *UnwindBB, unsigned Values,
                                      BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupEndPad,
+    : EHTerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+                       Instruction::EH_CleanupEndPad,
                        OperandTraits<CleanupEndPadInst>::op_end(this) - Values,
                        Values, InsertAtEnd) {
   init(CleanupPad, UnwindBB);
 }
 
 BasicBlock *CleanupEndPadInst::getSuccessorV(unsigned Idx) const {
   assert(Idx == 0);
   return getUnwindDest();
 }
 unsigned CleanupEndPadInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CleanupEndPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx == 0);
   setUnwindDest(B);
 }
+BasicBlock *CleanupEndPadInst::getUnwindDestV() const {
+  return getUnwindDest();
+}
+void CleanupEndPadInst::setUnwindDestV(BasicBlock *B) {
+  return setUnwindDest(B);
+}
 
 //===----------------------------------------------------------------------===//
 //                        CleanupReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI)
-    : TerminatorInst(CRI.getType(), Instruction::CleanupRet,
+    : EHTerminatorInst(CRI.getType(), Instruction::EH_CleanupRet,
                        OperandTraits<CleanupReturnInst>::op_end(this) -
                            CRI.getNumOperands(),
                        CRI.getNumOperands()) {
   setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
   Op<-1>() = CRI.Op<-1>();
   if (CRI.hasUnwindDest())
     Op<-2>() = CRI.Op<-2>();
 }
 
 void CleanupReturnInst::init(CleanupPadInst *CleanupPad, BasicBlock *UnwindBB) {
   if (UnwindBB)
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
 
   Op<-1>() = CleanupPad;
   if (UnwindBB)
     Op<-2>() = UnwindBB;
 }
 
 CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
                                      BasicBlock *UnwindBB, unsigned Values,
                                      Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupRet,
+    : EHTerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+                       Instruction::EH_CleanupRet,
                        OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                        Values, InsertBefore) {
   init(CleanupPad, UnwindBB);
 }
 
 CleanupReturnInst::CleanupReturnInst(CleanupPadInst *CleanupPad,
                                      BasicBlock *UnwindBB, unsigned Values,
                                      BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
-                     Instruction::CleanupRet,
+    : EHTerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
+                       Instruction::EH_CleanupRet,
                        OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                        Values, InsertAtEnd) {
   init(CleanupPad, UnwindBB);
 }
 
 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);
 }
+BasicBlock *CleanupReturnInst::getUnwindDestV() const {
+  return getUnwindDest();
+}
+void CleanupReturnInst::setUnwindDestV(BasicBlock *B) {
+  return setUnwindDest(B);
+}
 
 //===----------------------------------------------------------------------===//
 //                        CatchEndPadInst Implementation
 //===----------------------------------------------------------------------===//
 
 CatchEndPadInst::CatchEndPadInst(const CatchEndPadInst &CRI)
-    : TerminatorInst(CRI.getType(), Instruction::CatchEndPad,
+    : EHTerminatorInst(CRI.getType(), Instruction::EH_CatchEndPad,
                        OperandTraits<CatchEndPadInst>::op_end(this) -
                            CRI.getNumOperands(),
                        CRI.getNumOperands()) {
   setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
   if (BasicBlock *UnwindDest = CRI.getUnwindDest())
     setUnwindDest(UnwindDest);
 }
 
 void CatchEndPadInst::init(BasicBlock *UnwindBB) {
   if (UnwindBB) {
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
     setUnwindDest(UnwindBB);
   }
 }
 
 CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
                                  unsigned Values, Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
+    : EHTerminatorInst(Type::getVoidTy(C), Instruction::EH_CatchEndPad,
                        OperandTraits<CatchEndPadInst>::op_end(this) - Values,
                        Values, InsertBefore) {
   init(UnwindBB);
 }
 
 CatchEndPadInst::CatchEndPadInst(LLVMContext &C, BasicBlock *UnwindBB,
                                  unsigned Values, BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::CatchEndPad,
+    : EHTerminatorInst(Type::getVoidTy(C), Instruction::EH_CatchEndPad,
                        OperandTraits<CatchEndPadInst>::op_end(this) - Values,
                        Values, InsertAtEnd) {
   init(UnwindBB);
 }
 
 BasicBlock *CatchEndPadInst::getSuccessorV(unsigned Idx) const {
   assert(Idx == 0);
   return getUnwindDest();
 }
 unsigned CatchEndPadInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CatchEndPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx == 0);
   setUnwindDest(B);
 }
+BasicBlock *CatchEndPadInst::getUnwindDestV() const { return getUnwindDest(); }
+void CatchEndPadInst::setUnwindDestV(BasicBlock *B) { return setUnwindDest(B); }
 
 //===----------------------------------------------------------------------===//
 //                        CatchReturnInst Implementation
 //===----------------------------------------------------------------------===//
 void CatchReturnInst::init(CatchPadInst *CatchPad, BasicBlock *BB) {
   Op<0>() = CatchPad;
   Op<1>() = BB;
 }
 
 CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI)
-    : TerminatorInst(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
+    : EHTerminatorInst(Type::getVoidTy(CRI.getContext()),
+                       Instruction::EH_CatchRet,
                        OperandTraits<CatchReturnInst>::op_begin(this), 2) {
   Op<0>() = CRI.Op<0>();
   Op<1>() = CRI.Op<1>();
 }
 
 CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
                                  Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
-                     OperandTraits<CatchReturnInst>::op_begin(this), 2,
-                     InsertBefore) {
+    : EHTerminatorInst(
+          Type::getVoidTy(BB->getContext()), Instruction::EH_CatchRet,
+          OperandTraits<CatchReturnInst>::op_begin(this), 2, InsertBefore) {
   init(CatchPad, BB);
 }
 
 CatchReturnInst::CatchReturnInst(CatchPadInst *CatchPad, BasicBlock *BB,
                                  BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
-                     OperandTraits<CatchReturnInst>::op_begin(this), 2,
-                     InsertAtEnd) {
+    : EHTerminatorInst(
+          Type::getVoidTy(BB->getContext()), Instruction::EH_CatchRet,
+          OperandTraits<CatchReturnInst>::op_begin(this), 2, InsertAtEnd) {
   init(CatchPad, BB);
 }
 
 BasicBlock *CatchReturnInst::getSuccessorV(unsigned Idx) const {
   assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
   return getSuccessor();
 }
 unsigned CatchReturnInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CatchReturnInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
   setSuccessor(B);
 }
+BasicBlock *CatchReturnInst::getUnwindDestV() const {
+  llvm_unreachable("CatchReturnInst does not have an unwind dest!");
+}
+void CatchReturnInst::setUnwindDestV(BasicBlock *B) {
+  llvm_unreachable("CatchReturnInst does not have an unwind dest!");
+}
 
 //===----------------------------------------------------------------------===//
 //                        CatchPadInst Implementation
 //===----------------------------------------------------------------------===//
 void CatchPadInst::init(BasicBlock *IfNormal, BasicBlock *IfException,
                         ArrayRef<Value *> Args, const Twine &NameStr) {
   assert(getNumOperands() == 2 + Args.size() && "NumOperands not set up?");
   Op<-2>() = IfNormal;
   Op<-1>() = IfException;
   std::copy(Args.begin(), Args.end(), op_begin());
   setName(NameStr);
 }
 
 CatchPadInst::CatchPadInst(const CatchPadInst &CPI)
-    : TerminatorInst(CPI.getType(), Instruction::CatchPad,
+    : EHTerminatorInst(CPI.getType(), Instruction::EH_CatchPad,
                        OperandTraits<CatchPadInst>::op_end(this) -
                            CPI.getNumOperands(),
                        CPI.getNumOperands()) {
   std::copy(CPI.op_begin(), CPI.op_end(), op_begin());
 }
 
 CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
                            ArrayRef<Value *> Args, unsigned Values,
                            const Twine &NameStr, Instruction *InsertBefore)
-    : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
-                     Instruction::CatchPad,
-                     OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
-                     InsertBefore) {
+    : EHTerminatorInst(Type::getTokenTy(IfNormal->getContext()),
+                       Instruction::EH_CatchPad,
+                       OperandTraits<CatchPadInst>::op_end(this) - Values,
+                       Values, InsertBefore) {
   init(IfNormal, IfException, Args, NameStr);
 }
 
 CatchPadInst::CatchPadInst(BasicBlock *IfNormal, BasicBlock *IfException,
                            ArrayRef<Value *> Args, unsigned Values,
                            const Twine &NameStr, BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getTokenTy(IfNormal->getContext()),
-                     Instruction::CatchPad,
-                     OperandTraits<CatchPadInst>::op_end(this) - Values, Values,
-                     InsertAtEnd) {
+    : EHTerminatorInst(Type::getTokenTy(IfNormal->getContext()),
+                       Instruction::EH_CatchPad,
+                       OperandTraits<CatchPadInst>::op_end(this) - Values,
+                       Values, InsertAtEnd) {
   init(IfNormal, IfException, Args, NameStr);
 }
 
 BasicBlock *CatchPadInst::getSuccessorV(unsigned Idx) const {
   return getSuccessor(Idx);
 }
 unsigned CatchPadInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void CatchPadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   return setSuccessor(Idx, B);
 }
+BasicBlock *CatchPadInst::getUnwindDestV() const { return getUnwindDest(); }
+void CatchPadInst::setUnwindDestV(BasicBlock *B) { return setUnwindDest(B); }
 
 //===----------------------------------------------------------------------===//
 //                        TerminatePadInst Implementation
 //===----------------------------------------------------------------------===//
 void TerminatePadInst::init(BasicBlock *BB, ArrayRef<Value *> Args) {
   if (BB)
     setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
   if (BB)
     Op<-1>() = BB;
   std::copy(Args.begin(), Args.end(), op_begin());
 }
 
 TerminatePadInst::TerminatePadInst(const TerminatePadInst &TPI)
-    : TerminatorInst(TPI.getType(), Instruction::TerminatePad,
+    : EHTerminatorInst(TPI.getType(), Instruction::EH_TerminatePad,
                        OperandTraits<TerminatePadInst>::op_end(this) -
                            TPI.getNumOperands(),
                        TPI.getNumOperands()) {
   setInstructionSubclassData(TPI.getSubclassDataFromInstruction());
   std::copy(TPI.op_begin(), TPI.op_end(), op_begin());
 }
 
 TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
                                    ArrayRef<Value *> Args, unsigned Values,
                                    Instruction *InsertBefore)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+    : EHTerminatorInst(Type::getVoidTy(C), Instruction::EH_TerminatePad,
                        OperandTraits<TerminatePadInst>::op_end(this) - Values,
                        Values, InsertBefore) {
   init(BB, Args);
 }
 
 TerminatePadInst::TerminatePadInst(LLVMContext &C, BasicBlock *BB,
                                    ArrayRef<Value *> Args, unsigned Values,
                                    BasicBlock *InsertAtEnd)
-    : TerminatorInst(Type::getVoidTy(C), Instruction::TerminatePad,
+    : EHTerminatorInst(Type::getVoidTy(C), Instruction::EH_TerminatePad,
                        OperandTraits<TerminatePadInst>::op_end(this) - Values,
                        Values, InsertAtEnd) {
   init(BB, Args);
 }
 
 BasicBlock *TerminatePadInst::getSuccessorV(unsigned Idx) const {
   assert(Idx == 0);
   return getUnwindDest();
 }
 unsigned TerminatePadInst::getNumSuccessorsV() const {
   return getNumSuccessors();
 }
 void TerminatePadInst::setSuccessorV(unsigned Idx, BasicBlock *B) {
   assert(Idx == 0);
   return setUnwindDest(B);
 }
+BasicBlock *TerminatePadInst::getUnwindDestV() const { return getUnwindDest(); }
+void TerminatePadInst::setUnwindDestV(BasicBlock *B) {
+  return setUnwindDest(B);
+}
 
 //===----------------------------------------------------------------------===//
 //                        CleanupPadInst Implementation
 //===----------------------------------------------------------------------===//
 void CleanupPadInst::init(ArrayRef<Value *> Args, const Twine &NameStr) {
   assert(getNumOperands() == Args.size() && "NumOperands not set up?");
   std::copy(Args.begin(), Args.end(), op_begin());
   setName(NameStr);

lib/Transforms/Scalar/JumpThreading.cpp

if (pred_empty(BB) &&
     return false;
 
   // If this block has a single predecessor, and if that pred has a single
   // successor, merge the blocks.  This encourages recursive jump threading
   // 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 (!isa<EHTerminatorInst>(TI) && TI->getNumSuccessors() == 1 &&
         SinglePred != BB && !hasAddressTakenAndUsed(BB)) {
       // If SinglePred was a loop header, BB becomes one.
       if (LoopHeaders.erase(SinglePred))
         LoopHeaders.insert(BB);
 
       LVI->eraseBlock(SinglePred);
       MergeBasicBlockIntoOnlyPred(BB);
 

lib/Transforms/Scalar/SCCP.cpp

if (BranchInst *BI = dyn_cast<BranchInst>(&TI)) {
     }
 
     // Constant condition variables mean the branch can only go a single way.
     Succs[CI->isZero()] = true;
     return;
   }
 
   // Unwinding instructions successors are always executable.
-  if (TI.isExceptional()) {
+  if (isa<EHTerminatorInst>(&TI)) {
     Succs.assign(TI.getNumSuccessors(), true);
     return;
   }
 
   if (SwitchInst *SI = dyn_cast<SwitchInst>(&TI)) {
     if (!SI->getNumCases()) {
       Succs[0] = true;
       return;
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
     if (!CI)
       return !BCValue.isUndefined();
 
     // Constant condition variables mean the branch can only go a single way.
     return BI->getSuccessor(CI->isZero()) == To;
   }
 
   // Unwinding instructions successors are always executable.
-  if (TI->isExceptional())
+  if (isa<EHTerminatorInst>(TI))
     return true;
 
   if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
     if (SI->getNumCases() < 1)
       return true;
 
     LatticeVal SCValue = getValueState(SI->getCondition());
     ConstantInt *CI = SCValue.getConstantInt();

lib/Transforms/Utils/BasicBlockUtils.cpp

bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DominatorTree *DT,
 
   // Can't merge if there are multiple predecessors, or no predecessors.
   BasicBlock *PredBB = BB->getUniquePredecessor();
   if (!PredBB) return false;
 
   // Don't break self-loops.
   if (PredBB == BB) return false;
   // Don't break unwinding instructions.
-  if (PredBB->getTerminator()->isExceptional())
+  if (isa<EHTerminatorInst>(PredBB->getTerminator()))
     return false;
 
   succ_iterator SI(succ_begin(PredBB)), SE(succ_end(PredBB));
   BasicBlock *OnlySucc = BB;
   for (; SI != SE; ++SI)
     if (*SI != OnlySucc) {
       OnlySucc = nullptr;     // There are multiple distinct successors!
       break;

lib/Transforms/Utils/SimplifyCFG.cpp

bool SimplifyCFGOpt::SimplifyCleanupReturn(CleanupReturnInst *RI) {
   }
 
   for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE;) {
     // The iterator must be updated here because we are removing this pred.
     BasicBlock *PredBB = *PI++;
     if (UnwindDest == nullptr) {
       removeUnwindEdge(PredBB);
     } else {
-      // If the predecessor did not terminate with an invoke instruction, it
-      // must be some variety of EH pad.
       TerminatorInst *TI = PredBB->getTerminator();
-      // FIXME: Introducing an EH terminator base class would simplify this.
-      if (auto *II = dyn_cast<InvokeInst>(TI))
-        II->setUnwindDest(UnwindDest);
-      else if (auto *CRI = dyn_cast<CleanupReturnInst>(TI))
-        CRI->setUnwindDest(UnwindDest);
-      else if (auto *CEP = dyn_cast<CatchEndPadInst>(TI))
-        CEP->setUnwindDest(UnwindDest);
-      else if (auto *TPI = dyn_cast<TerminatePadInst>(TI))
-        TPI->setUnwindDest(UnwindDest);
-      else
-        llvm_unreachable("Unexpected predecessor to cleanup pad.");
+      cast<EHTerminatorInst>(TI)->setUnwindDest(UnwindDest);
     }
   }
 
   // The cleanup pad is now unreachable.  Zap it.
   BB->eraseFromParent();
   return true;
 }