Move the personality function from LandingPadInst to Function

[majnemer]

Summary

The personality routine currently lives in the LandingPadInst.

This isn't desirable because:

• All LandingPadInsts in the same function must have the same personality routine. This means that each LandingPadInst beyond the first has an operand which produces no additional information.

• There is ongoing work to introduce EH IR constructs other than LandingPadInst. Moving the personality routine off of any one particular Instruction and onto the parent function seems a lot better than have N different places a personality function can sneak onto an exceptional function.

[qcolombet]

Hi David,

Just to let you know that I’ve been added as a reviewer because of my Herald’s rule when a file has RegAlloc in it, which is the case for one of the test case you edited.
In particular, I do not feel like I am the one that should review this patch, therefore, you will need to find someone else to actually review this patch.

Cheers,
-Quentin

[majnemer]

Rebase to trunk.

[rnk]

I'm happy with this, but we should find another reviewer or two. I'd try Anton for EH stuff and John and Rafael for IR changes.

lib/Bitcode/Reader/BitcodeReader.cpp

4063 ↗

(On Diff #27708)

What should we do with bitcode that has multiple landing pads with mismatched personalities? Obviously, it's invalid IR, but now we might not detect that anymore, right? Seems like if the parent function has a personality and it doesn't match the one we're adding, we should error.

[majnemer]

• Reserve exactly NumReservedValues
• Address @rnk's review comments

[• rafael]

Why do you need a personality on declarations?

With that explained or changed this is fine by me.

docs/LangRef.rst

651 ↗

(On Diff #27773)

Why do you need it on declarations?

[andrew.w.kaylor]

Looks good to me.

docs/LangRef.rst

7301 ↗

(On Diff #27773)

You should probably mention here that the personality function is inherited from the enclosing function.

[majnemer]

• Reserve exactly NumReservedValues
• Address @rnk's review comments
• Address latest review feedback.

llvm/trunk/docs/BitCodeFormat.rst

* *dllstorageclass*: If present, an encoding of the DLL storage class of this variable:
   * ``dllimport``: code 1
   * ``dllexport``: code 2
 
 .. _FUNCTION:
 
 MODULE_CODE_FUNCTION Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata]``
+``[FUNCTION, type, callingconv, isproto, linkage, paramattr, alignment, section, visibility, gc, prologuedata, dllstorageclass, comdat, prefixdata, personalityfn]``
 
 The ``FUNCTION`` record (code 8) marks the declaration or definition of a
 function. The operand fields are:
 
 * *type*: The type index of the function type describing this function
 
 * *callingconv*: The calling convention number:
   * ``ccc``: code 0

 * *dllstorageclass*: An encoding of the
   :ref:`dllstorageclass<bcdllstorageclass>` of this function
 
 * *comdat*: An encoding of the COMDAT of this function
 
 * *prefixdata*: If non-zero, the value index of the prefix data for this function,
   plus 1.
 
+* *personalityfn*: If non-zero, the value index of the personality function for this function,
+  plus 1.
 
 MODULE_CODE_ALIAS Record
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``[ALIAS, alias type, aliasee val#, linkage, visibility, dllstorageclass]``
 
 The ``ALIAS`` record (code 9) marks the definition of an alias. The operand
 fields are

llvm/trunk/docs/LangRef.rst

 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function
 name, a (possibly empty) argument list (each with optional :ref:`parameter
 attributes <paramattrs>`), optional :ref:`function attributes <fnattrs>`,
 an optional section, an optional alignment,
 an optional :ref:`comdat <langref_comdats>`,
 an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
-an optional :ref:`prologue <prologuedata>`, an opening
-curly brace, a list of basic blocks, and a closing curly brace.
+an optional :ref:`prologue <prologuedata>`,
+an optional :ref:`personality <personalityfn>`,
+an opening curly brace, a list of basic blocks, and a closing curly brace.
 
 LLVM function declarations consist of the "``declare``" keyword, an
 optional :ref:`linkage type <linkage>`, an optional :ref:`visibility
 style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function
 name, a possibly empty list of arguments, an optional alignment, an optional

 be significant and two identical functions can be merged.
 
 Syntax::
 
     define [linkage] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
            [unnamed_addr] [fn Attrs] [section "name"] [comdat [($name)]]
-           [align N] [gc] [prefix Constant] [prologue Constant] { ... }
+           [align N] [gc] [prefix Constant] [prologue Constant]
+           [personality Constant] { ... }
 
 The argument list is a comma seperated sequence of arguments where each
 argument is of the following form
 
 Syntax::
 
    <type> [parameter Attrs] [name]
 
.. code-block:: llvm
     %0 = type <{ i8, i8, i8* }>
 
     define void @f() prologue %0 <{ i8 235, i8 8, i8* @md}> { ... }
 
 A function may have prologue data but no body.  This has similar semantics
 to the ``available_externally`` linkage in that the data may be used by the
 optimizers but will not be emitted in the object file.
 
+.. _personalityfn:
+
+Personality Function
+-------------
+
+The ``personality`` attribute permits functions to specify what function
+to use for exception handling.
+
 .. _attrgrp:
 
 Attribute Groups
 ----------------
 
 Attribute groups are groups of attributes that are referenced by objects within
 the IR. They are important for keeping ``.ll`` files readable, because a lot of
 functions will use the same set of attributes. In the degenerative case of a

 '``landingpad``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <resultval> = landingpad <resultty> personality <type> <pers_fn> <clause>+
-      <resultval> = landingpad <resultty> personality <type> <pers_fn> cleanup <clause>*
+      <resultval> = landingpad <resultty> <clause>+
+      <resultval> = landingpad <resultty> cleanup <clause>*
 
       <clause> := catch <type> <value>
       <clause> := filter <array constant type> <array constant>
 
 Overview:
 """""""""
 
 The '``landingpad``' instruction is used by `LLVM's exception handling
 system <ExceptionHandling.html#overview>`_ to specify that a basic block
 is a landing pad --- one where the exception lands, and corresponds to the
 code found in the ``catch`` portion of a ``try``/``catch`` sequence. It
-defines values supplied by the personality function (``pers_fn``) upon
+defines values supplied by the :ref:`personality function <personalityfn>` upon
 re-entry to the function. The ``resultval`` has the type ``resultty``.
 
 Arguments:
 """"""""""
 
-This instruction takes a ``pers_fn`` value. This is the personality
-function associated with the unwinding mechanism. The optional
+The optional
 ``cleanup`` flag indicates that the landing pad block is a cleanup.
 
 A ``clause`` begins with the clause type --- ``catch`` or ``filter`` --- and
 contains the global variable representing the "type" that may be caught
 or filtered respectively. Unlike the ``catch`` clause, the ``filter``
 clause takes an array constant as its argument. Use
 "``[0 x i8**] undef``" for a filter which cannot throw. The
 '``landingpad``' instruction must contain *at least* one ``clause`` or
 the ``cleanup`` flag.
 
 Semantics:
 """"""""""
 
 The '``landingpad``' instruction defines the values which are set by the
-personality function (``pers_fn``) upon re-entry to the function, and
+:ref:`personality function <personalityfn>` upon re-entry to the function, and
 therefore the "result type" of the ``landingpad`` instruction. As with
 calling conventions, how the personality function results are
 represented in LLVM IR is target specific.
 
 The clauses are applied in order from top to bottom. If two
 ``landingpad`` instructions are merged together through inlining, the
 clauses from the calling function are appended to the list of clauses.
 When the call stack is being unwound due to an exception being thrown,
 the exception is compared against each ``clause`` in turn. If it doesn't
 match any of the clauses, and the ``cleanup`` flag is not set, then
 unwinding continues further up the call stack.
 
 The ``landingpad`` instruction has several restrictions:
 
 -  A landing pad block is a basic block which is the unwind destination
    of an '``invoke``' instruction.
 -  A landing pad block must have a '``landingpad``' instruction as its
    first non-PHI instruction.
 -  There can be only one '``landingpad``' instruction within the landing
    pad block.
 -  A basic block that is not a landing pad block may not include a
    '``landingpad``' instruction.
--  All '``landingpad``' instructions in a function must have the same
-   personality function.
 
 Example:
 """"""""
 
 .. code-block:: llvm
 
       ;; A landing pad which can catch an integer.
-      %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+      %res = landingpad { i8*, i32 }
                catch i8** @_ZTIi
       ;; A landing pad that is a cleanup.
-      %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+      %res = landingpad { i8*, i32 }
                cleanup
       ;; A landing pad which can catch an integer and can only throw a double.
-      %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+      %res = landingpad { i8*, i32 }
                catch i8** @_ZTIi
                filter [1 x i8**] [@_ZTId]
 
 .. _intrinsics:
 
 Intrinsic Functions
 ===================
 

llvm/trunk/include/llvm/Analysis/LibCallSemantics.h

inline bool isMSVCEHPersonality(EHPersonality Pers) {
     case EHPersonality::MSVC_X86SEH:
     case EHPersonality::MSVC_Win64SEH:
       return true;
     default: return false;
     }
     llvm_unreachable("invalid enum");
   }
 
-  bool canSimplifyInvokeNoUnwind(const InvokeInst *II);
+  bool canSimplifyInvokeNoUnwind(const Function *F);
 
 } // end namespace llvm
 
 #endif

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

enum FunctionCodes {
     FUNC_CODE_DEBUG_LOC        = 35, // DEBUG_LOC:  [Line,Col,ScopeVal, IAVal]
     FUNC_CODE_INST_FENCE       = 36, // FENCE: [ordering, synchscope]
     FUNC_CODE_INST_CMPXCHG_OLD = 37, // CMPXCHG: [ptrty,ptr,cmp,new, align, vol,
                                      //           ordering, synchscope]
     FUNC_CODE_INST_ATOMICRMW   = 38, // ATOMICRMW: [ptrty,ptr,val, operation,
                                      //             align, vol,
                                      //             ordering, synchscope]
     FUNC_CODE_INST_RESUME      = 39, // RESUME:     [opval]
-    FUNC_CODE_INST_LANDINGPAD  = 40, // LANDINGPAD: [ty,val,val,num,id0,val0...]
+    FUNC_CODE_INST_LANDINGPAD_OLD  = 40, // LANDINGPAD: [ty,val,val,num,id0,val0...]
     FUNC_CODE_INST_LOADATOMIC  = 41, // LOAD: [opty, op, align, vol,
                                      //        ordering, synchscope]
     FUNC_CODE_INST_STOREATOMIC_OLD = 42, // STORE: [ptrty,ptr,val, align, vol
                                      //         ordering, synchscope]
     FUNC_CODE_INST_GEP         = 43, // GEP:  [inbounds, n x operands]
     FUNC_CODE_INST_STORE       = 44, // STORE: [ptrty,ptr,valty,val, align, vol]
     FUNC_CODE_INST_STOREATOMIC = 45, // STORE: [ptrty,ptr,val, align, vol
     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...]
   };
 
   enum UseListCodes {
     USELIST_CODE_DEFAULT = 1, // DEFAULT: [index..., value-id]
     USELIST_CODE_BB      = 2  // BB: [index..., bb-id]
   };
 
   enum AttributeKindCodes {

llvm/trunk/include/llvm/IR/Function.h

 
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/GlobalObject.h"
+#include "llvm/IR/OperandTraits.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 class FunctionType;
 class LLVMContext;
 
 template<> struct ilist_traits<Argument>
private:
   /// the module.
   ///
   Function(FunctionType *Ty, LinkageTypes Linkage,
            const Twine &N = "", Module *M = nullptr);
 
 public:
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N = "", Module *M = nullptr) {
-    return new(0) Function(Ty, Linkage, N, M);
+    return new(1) Function(Ty, Linkage, N, M);
   }
 
   ~Function() override;
 
+  /// \brief Provide fast operand accessors
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+  /// \brief Get the personality function associated with this function.
+  bool hasPersonalityFn() const { return getNumOperands() != 0; }
+  Constant *getPersonalityFn() const {
+    assert(hasPersonalityFn());
+    return cast<Constant>(Op<0>());
+  }
+  void setPersonalityFn(Constant *C);
+
   Type *getReturnType() const;           // Return the type of the ret val
   FunctionType *getFunctionType() const; // Return the FunctionType for me
 
   /// getContext - Return a reference to the LLVMContext associated with this
   /// function.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
ilist_traits<BasicBlock>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
 inline ValueSymbolTable *
 ilist_traits<Argument>::getSymTab(Function *F) {
   return F ? &F->getValueSymbolTable() : nullptr;
 }
 
+template <>
+struct OperandTraits<Function> : public OptionalOperandTraits<Function> {};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
+
 } // End llvm namespace
 
 #endif

llvm/trunk/include/llvm/IR/IRBuilder.h

Value *CreateInsertValue(Value *Agg, Value *Val,
                            ArrayRef<unsigned> Idxs,
                            const Twine &Name = "") {
     if (Constant *AggC = dyn_cast<Constant>(Agg))
       if (Constant *ValC = dyn_cast<Constant>(Val))
         return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
   }
 
-  LandingPadInst *CreateLandingPad(Type *Ty, Value *PersFn, unsigned NumClauses,
+  LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
                                    const Twine &Name = "") {
-    return Insert(LandingPadInst::Create(Ty, PersFn, NumClauses), Name);
+    return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
   }
 
   //===--------------------------------------------------------------------===//
   // Utility creation methods
   //===--------------------------------------------------------------------===//
 
   /// \brief Return an i1 value testing if \p Arg is null.
   Value *CreateIsNull(Value *Arg, const Twine &Name = "") {

llvm/trunk/include/llvm/IR/Instructions.h

public:
   enum ClauseType { Catch, Filter };
 private:
   void *operator new(size_t, unsigned) = delete;
   // Allocate space for exactly zero operands.
   void *operator new(size_t s) {
     return User::operator new(s);
   }
   void growOperands(unsigned Size);
-  void init(Value *PersFn, unsigned NumReservedValues, const Twine &NameStr);
+  void init(unsigned NumReservedValues, const Twine &NameStr);
+
+  explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+                          const Twine &NameStr, Instruction *InsertBefore);
+  explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+                          const Twine &NameStr, BasicBlock *InsertAtEnd);
 
-  explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
-                          unsigned NumReservedValues, const Twine &NameStr,
-                          Instruction *InsertBefore);
-  explicit LandingPadInst(Type *RetTy, Value *PersonalityFn,
-                          unsigned NumReservedValues, const Twine &NameStr,
-                          BasicBlock *InsertAtEnd);
 protected:
   LandingPadInst *clone_impl() const override;
 public:
   /// Constructors - NumReservedClauses is a hint for the number of incoming
   /// clauses that this landingpad will have (use 0 if you really have no idea).
-  static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
-                                unsigned NumReservedClauses,
+  static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr);
-  static LandingPadInst *Create(Type *RetTy, Value *PersonalityFn,
-                                unsigned NumReservedClauses,
+  static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                                 const Twine &NameStr, BasicBlock *InsertAtEnd);
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  /// getPersonalityFn - Get the personality function associated with this
-  /// landing pad.
-  Value *getPersonalityFn() const { return getOperand(0); }
-
   /// isCleanup - Return 'true' if this landingpad instruction is a
   /// cleanup. I.e., it should be run when unwinding even if its landing pad
   /// doesn't catch the exception.
   bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
 
   /// setCleanup - Indicate that this landingpad instruction is a cleanup.
   void setCleanup(bool V) {
     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                                (V ? 1 : 0));
   }
 
   /// Add a catch or filter clause to the landing pad.
   void addClause(Constant *ClauseVal);
 
   /// Get the value of the clause at index Idx. Use isCatch/isFilter to
   /// determine what type of clause this is.
   Constant *getClause(unsigned Idx) const {
-    return cast<Constant>(getOperandList()[Idx + 1]);
+    return cast<Constant>(getOperandList()[Idx]);
   }
 
   /// isCatch - Return 'true' if the clause and index Idx is a catch clause.
   bool isCatch(unsigned Idx) const {
-    return !isa<ArrayType>(getOperandList()[Idx + 1]->getType());
+    return !isa<ArrayType>(getOperandList()[Idx]->getType());
   }
 
   /// isFilter - Return 'true' if the clause and index Idx is a filter clause.
   bool isFilter(unsigned Idx) const {
-    return isa<ArrayType>(getOperandList()[Idx + 1]->getType());
+    return isa<ArrayType>(getOperandList()[Idx]->getType());
   }
 
   /// getNumClauses - Get the number of clauses for this landing pad.
-  unsigned getNumClauses() const { return getNumOperands() - 1; }
+  unsigned getNumClauses() const { return getNumOperands(); }
 
   /// reserveClauses - Grow the size of the operand list to accommodate the new
   /// number of clauses.
   void reserveClauses(unsigned Size) { growOperands(Size); }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::LandingPad;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
 template <>
-struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<2> {
+struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               ReturnInst Class
 //===----------------------------------------------------------------------===//
 

llvm/trunk/include/llvm/IR/User.h

public:
   /// FIXME: As that the number of operands is used to find the start of
   /// the allocated memory in operator delete, we need to always think we have
   /// 1 operand before delete.
   void setGlobalVariableNumOperands(unsigned NumOps) {
     assert(NumOps <= 1 && "GlobalVariable can only have 0 or 1 operands");
     NumUserOperands = NumOps;
   }
 
+  /// Set the number of operands on a Function.
+  ///
+  /// Function always allocates space for a single operands, but
+  /// doesn't always use it.
+  ///
+  /// FIXME: As that the number of operands is used to find the start of
+  /// the allocated memory in operator delete, we need to always think we have
+  /// 1 operand before delete.
+  void setFunctionNumOperands(unsigned NumOps) {
+    assert(NumOps <= 1 && "Function can only have 0 or 1 operands");
+    NumUserOperands = NumOps;
+  }
+
   /// \brief Subclasses with hung off uses need to manage the operand count
   /// themselves.  In these instances, the operand count isn't used to find the
   /// OperandList, so there's no issue in having the operand count change.
   void setNumHungOffUseOperands(unsigned NumOps) {
     assert(HasHungOffUses && "Must have hung off uses to use this method");
     assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
     NumUserOperands = NumOps;
   }

llvm/trunk/lib/Analysis/LibCallSemantics.cpp

return StringSwitch<EHPersonality>(F->getName())
     .Case("__objc_personality_v0", EHPersonality::GNU_ObjC)
     .Case("_except_handler3",      EHPersonality::MSVC_X86SEH)
     .Case("_except_handler4",      EHPersonality::MSVC_X86SEH)
     .Case("__C_specific_handler",  EHPersonality::MSVC_Win64SEH)
     .Case("__CxxFrameHandler3",    EHPersonality::MSVC_CXX)
     .Default(EHPersonality::Unknown);
 }
 
-bool llvm::canSimplifyInvokeNoUnwind(const InvokeInst *II) {
-  const LandingPadInst *LP = II->getLandingPadInst();
-  EHPersonality Personality = classifyEHPersonality(LP->getPersonalityFn());
+bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
+  EHPersonality Personality = classifyEHPersonality(F->getPersonalityFn());
   // We can't simplify any invokes to nounwind functions if the personality
   // function wants to catch asynch exceptions.  The nounwind attribute only
   // implies that the function does not throw synchronous exceptions.
   return !isAsynchronousEHPersonality(Personality);
 }

llvm/trunk/lib/AsmParser/LLParser.cpp

bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
   BB = cast<BasicBlock>(V);
   return false;
 }
 
 
 /// FunctionHeader
 ///   ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
 ///       OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
-///       OptionalAlign OptGC OptionalPrefix OptionalPrologue
+///       OptionalAlign OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   // Parse the linkage.
   LocTy LinkageLoc = Lex.getLoc();
   unsigned Linkage;
 
   unsigned Visibility;
   unsigned DLLStorageClass;
   AttrBuilder RetAttrs;
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   LocTy BuiltinLoc;
   std::string Section;
   unsigned Alignment;
   std::string GC;
   bool UnnamedAddr;
   LocTy UnnamedAddrLoc;
   Constant *Prefix = nullptr;
   Constant *Prologue = nullptr;
+  Constant *PersonalityFn = nullptr;
   Comdat *C;
 
   if (ParseArgumentList(ArgList, isVarArg) ||
       ParseOptionalToken(lltok::kw_unnamed_addr, UnnamedAddr,
                          &UnnamedAddrLoc) ||
       ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
                                  BuiltinLoc) ||
       (EatIfPresent(lltok::kw_section) &&
        ParseStringConstant(Section)) ||
       parseOptionalComdat(FunctionName, C) ||
       ParseOptionalAlignment(Alignment) ||
       (EatIfPresent(lltok::kw_gc) &&
        ParseStringConstant(GC)) ||
       (EatIfPresent(lltok::kw_prefix) &&
        ParseGlobalTypeAndValue(Prefix)) ||
       (EatIfPresent(lltok::kw_prologue) &&
-       ParseGlobalTypeAndValue(Prologue)))
+       ParseGlobalTypeAndValue(Prologue)) ||
+      (EatIfPresent(lltok::kw_personality) &&
+       ParseGlobalTypeAndValue(PersonalityFn)))
     return true;
 
   if (FuncAttrs.contains(Attribute::Builtin))
     return Error(BuiltinLoc, "'builtin' attribute not valid on function");
 
   // If the alignment was parsed as an attribute, move to the alignment field.
   if (FuncAttrs.hasAlignmentAttr()) {
     Alignment = FuncAttrs.getAlignment();
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
   Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
   Fn->setComdat(C);
+  Fn->setPersonalityFn(PersonalityFn);
   if (!GC.empty()) Fn->setGC(GC.c_str());
   Fn->setPrefixData(Prefix);
   Fn->setPrologueData(Prologue);
   ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
 
   // Add all of the arguments we parsed to the function.
   Function::arg_iterator ArgIt = Fn->arg_begin();
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {

 /// ParseLandingPad
 ///   ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+
 /// Clause
 ///   ::= 'catch' TypeAndValue
 ///   ::= 'filter'
 ///   ::= 'filter' TypeAndValue ( ',' TypeAndValue )*
 bool LLParser::ParseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
   Type *Ty = nullptr; LocTy TyLoc;
-  Value *PersFn; LocTy PersFnLoc;
 
-  if (ParseType(Ty, TyLoc) ||
-      ParseToken(lltok::kw_personality, "expected 'personality'") ||
-      ParseTypeAndValue(PersFn, PersFnLoc, PFS))
+  if (ParseType(Ty, TyLoc))
     return true;
 
-  std::unique_ptr<LandingPadInst> LP(LandingPadInst::Create(Ty, PersFn, 0));
+  std::unique_ptr<LandingPadInst> LP(LandingPadInst::Create(Ty, 0));
   LP->setCleanup(EatIfPresent(lltok::kw_cleanup));
 
   while (Lex.getKind() == lltok::kw_catch || Lex.getKind() == lltok::kw_filter){
     LandingPadInst::ClauseType CT;
     if (EatIfPresent(lltok::kw_catch))
       CT = LandingPadInst::Catch;
     else if (EatIfPresent(lltok::kw_filter))
       CT = LandingPadInst::Filter;

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

class BitcodeReader : public GVMaterializer {
   BitcodeReaderMDValueList MDValueList;
   std::vector<Comdat *> ComdatList;
   SmallVector<Instruction *, 64> InstructionList;
 
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
   std::vector<std::pair<Function*, unsigned> > FunctionPrefixes;
   std::vector<std::pair<Function*, unsigned> > FunctionPrologues;
+  std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFns;
 
   SmallVector<Instruction*, 64> InstsWithTBAATag;
 
   /// The set of attributes by index.  Index zero in the file is for null, and
   /// is thus not represented here.  As such all indices are off by one.
   std::vector<AttributeSet> MAttributes;
 
   /// \brief The set of attribute groups.

 }
 
 /// Resolve all of the initializers for global values and aliases that we can.
 std::error_code BitcodeReader::resolveGlobalAndAliasInits() {
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist;
   std::vector<std::pair<Function*, unsigned> > FunctionPrefixWorklist;
   std::vector<std::pair<Function*, unsigned> > FunctionPrologueWorklist;
+  std::vector<std::pair<Function*, unsigned> > FunctionPersonalityFnWorklist;
 
   GlobalInitWorklist.swap(GlobalInits);
   AliasInitWorklist.swap(AliasInits);
   FunctionPrefixWorklist.swap(FunctionPrefixes);
   FunctionPrologueWorklist.swap(FunctionPrologues);
+  FunctionPersonalityFnWorklist.swap(FunctionPersonalityFns);
 
   while (!GlobalInitWorklist.empty()) {
     unsigned ValID = GlobalInitWorklist.back().second;
     if (ValID >= ValueList.size()) {
       // Not ready to resolve this yet, it requires something later in the file.
       GlobalInits.push_back(GlobalInitWorklist.back());
     } else {
       if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
if (ValID >= ValueList.size()) {
       if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
         FunctionPrologueWorklist.back().first->setPrologueData(C);
       else
         return error("Expected a constant");
     }
     FunctionPrologueWorklist.pop_back();
   }
 
+  while (!FunctionPersonalityFnWorklist.empty()) {
+    unsigned ValID = FunctionPersonalityFnWorklist.back().second;
+    if (ValID >= ValueList.size()) {
+      FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back());
+    } else {
+      if (Constant *C = dyn_cast_or_null<Constant>(ValueList[ValID]))
+        FunctionPersonalityFnWorklist.back().first->setPersonalityFn(C);
+      else
+        return error("Expected a constant");
+    }
+    FunctionPersonalityFnWorklist.pop_back();
+  }
+
   return std::error_code();
 }
 
 static APInt readWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) {
   SmallVector<uint64_t, 8> Words(Vals.size());
   std::transform(Vals.begin(), Vals.end(), Words.begin(),
                  BitcodeReader::decodeSignRotatedValue);
 
case bitc::MODULE_CODE_FUNCTION: {
         }
       } else if (hasImplicitComdat(RawLinkage)) {
         Func->setComdat(reinterpret_cast<Comdat *>(1));
       }
 
       if (Record.size() > 13 && Record[13] != 0)
         FunctionPrefixes.push_back(std::make_pair(Func, Record[13]-1));
 
+      if (Record.size() > 14 && Record[14] != 0)
+        FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
+
       ValueList.push_back(Func);
 
       // If this is a function with a body, remember the prototype we are
       // creating now, so that we can match up the body with them later.
       if (!isProto) {
         Func->setIsMaterializable(true);
         FunctionsWithBodies.push_back(Func);
         if (IsStreamed)
case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...]
         if (!V || !BB)
           return error("Invalid record");
         PN->addIncoming(V, BB);
       }
       I = PN;
       break;
     }
 
-    case bitc::FUNC_CODE_INST_LANDINGPAD: {
+    case bitc::FUNC_CODE_INST_LANDINGPAD:
+    case bitc::FUNC_CODE_INST_LANDINGPAD_OLD: {
       // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
       unsigned Idx = 0;
+      if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD) {
+        if (Record.size() < 3)
+          return error("Invalid record");
+      } else {
+        assert(BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD);
         if (Record.size() < 4)
           return error("Invalid record");
+      }
       Type *Ty = getTypeByID(Record[Idx++]);
       if (!Ty)
         return error("Invalid record");
+      if (BitCode == bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {
         Value *PersFn = nullptr;
         if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
           return error("Invalid record");
 
+        if (!F->hasPersonalityFn())
+          F->setPersonalityFn(cast<Constant>(PersFn));
+        else if (F->getPersonalityFn() != cast<Constant>(PersFn))
+          return error("Personality function mismatch");
+      }
+
       bool IsCleanup = !!Record[Idx++];
       unsigned NumClauses = Record[Idx++];
-      LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses);
+      LandingPadInst *LP = LandingPadInst::Create(Ty, NumClauses);
       LP->setCleanup(IsCleanup);
       for (unsigned J = 0; J != NumClauses; ++J) {
         LandingPadInst::ClauseType CT =
           LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
         Value *Val;
 
         if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
           delete LP;

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

for (const GlobalVariable &GV : M->globals()) {
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the function proto information.
   for (const Function &F : *M) {
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattrs, alignment,
     //             section, visibility, gc, unnamed_addr, prologuedata,
-    //             dllstorageclass, comdat, prefixdata]
+    //             dllstorageclass, comdat, prefixdata, personalityfn]
     Vals.push_back(VE.getTypeID(F.getFunctionType()));
     Vals.push_back(F.getCallingConv());
     Vals.push_back(F.isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
     Vals.push_back(VE.getAttributeID(F.getAttributes()));
     Vals.push_back(Log2_32(F.getAlignment())+1);
     Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
     Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
     Vals.push_back(F.hasUnnamedAddr());
     Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
                                        : 0);
     Vals.push_back(getEncodedDLLStorageClass(F));
     Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
+    Vals.push_back(
+        F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M->aliases()) {
case Instruction::PHI: {
     Vals64.clear();
     return;
   }
 
   case Instruction::LandingPad: {
     const LandingPadInst &LP = cast<LandingPadInst>(I);
     Code = bitc::FUNC_CODE_INST_LANDINGPAD;
     Vals.push_back(VE.getTypeID(LP.getType()));
-    PushValueAndType(LP.getPersonalityFn(), InstID, Vals, VE);
     Vals.push_back(LP.isCleanup());
     Vals.push_back(LP.getNumClauses());
     for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {
       if (LP.isCatch(I))
         Vals.push_back(LandingPadInst::Catch);
       else
         Vals.push_back(LandingPadInst::Filter);
       PushValueAndType(LP.getClause(I), InstID, Vals, VE);

llvm/trunk/lib/Bitcode/Writer/ValueEnumerator.cpp

if (!isa<GlobalValue>(A.getAliasee()))
       orderValue(A.getAliasee(), OM);
   for (const Function &F : M) {
     if (F.hasPrefixData())
       if (!isa<GlobalValue>(F.getPrefixData()))
         orderValue(F.getPrefixData(), OM);
     if (F.hasPrologueData())
       if (!isa<GlobalValue>(F.getPrologueData()))
         orderValue(F.getPrologueData(), OM);
+    if (F.hasPersonalityFn())
+      if (!isa<GlobalValue>(F.getPersonalityFn()))
+        orderValue(F.getPersonalityFn(), OM);
   }
   OM.LastGlobalConstantID = OM.size();
 
   // Initializers of GlobalValues are processed in
   // BitcodeReader::ResolveGlobalAndAliasInits().  Match the order there rather
   // than ValueEnumerator, and match the code in predictValueUseListOrderImpl()
   // by giving IDs in reverse order.
   //
if (G.hasInitializer())
       predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
   for (const GlobalAlias &A : M.aliases())
     predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
   for (const Function &F : M) {
     if (F.hasPrefixData())
       predictValueUseListOrder(F.getPrefixData(), nullptr, OM, Stack);
     if (F.hasPrologueData())
       predictValueUseListOrder(F.getPrologueData(), nullptr, OM, Stack);
+    if (F.hasPersonalityFn())
+      predictValueUseListOrder(F.getPersonalityFn(), nullptr, OM, Stack);
   }
 
   return Stack;
 }
 
 static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) {
   return V.first->getType()->isIntOrIntVectorTy();
 }
for (const Function &F : M)
     if (F.hasPrefixData())
       EnumerateValue(F.getPrefixData());
 
   // Enumerate the prologue data constants.
   for (const Function &F : M)
     if (F.hasPrologueData())
       EnumerateValue(F.getPrologueData());
 
+  // Enumerate the personality functions.
+  for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
+    if (I->hasPersonalityFn())
+      EnumerateValue(I->getPersonalityFn());
+
   // Enumerate the metadata type.
   //
   // TODO: Move this to ValueEnumerator::EnumerateOperandType() once bitcode
   // only encodes the metadata type when it's used as a value.
   EnumerateType(Type::getMetadataTy(M.getContext()));
 
   // Insert constants and metadata that are named at module level into the slot
   // pool so that the module symbol table can refer to them...

llvm/trunk/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

F->printAsOperand(OutStreamer->GetCommentOS(),
                    /*PrintType=*/false, F->getParent());
     OutStreamer->GetCommentOS() << '\n';
   }
 
   // Emit the prefix data.
   if (F->hasPrefixData())
     EmitGlobalConstant(F->getPrefixData());
 
+  // Emit the personality function.
+  if (F->hasPersonalityFn())
+    EmitGlobalConstant(F->getPersonalityFn());
+
   // Emit the CurrentFnSym.  This is a virtual function to allow targets to
   // do their wild and crazy things as required.
   EmitFunctionEntryLabel();
 
   // If the function had address-taken blocks that got deleted, then we have
   // references to the dangling symbols.  Emit them at the start of the function
   // so that we don't get references to undefined symbols.
   std::vector<MCSymbol*> DeadBlockSyms;

llvm/trunk/lib/CodeGen/DwarfEHPrepare.cpp

size_t DwarfEHPrepare::pruneUnreachableResumes(
   return ResumesLeft;
 }
 
 /// InsertUnwindResumeCalls - Convert the ResumeInsts that are still present
 /// into calls to the appropriate _Unwind_Resume function.
 bool DwarfEHPrepare::InsertUnwindResumeCalls(Function &Fn) {
   SmallVector<ResumeInst*, 16> Resumes;
   SmallVector<LandingPadInst*, 16> CleanupLPads;
-  bool FoundLP = false;
   for (BasicBlock &BB : Fn) {
     if (auto *RI = dyn_cast<ResumeInst>(BB.getTerminator()))
       Resumes.push_back(RI);
-    if (auto *LP = BB.getLandingPadInst()) {
+    if (auto *LP = BB.getLandingPadInst())
       if (LP->isCleanup())
         CleanupLPads.push_back(LP);
-      // Check the personality on the first landingpad. Don't do anything if
-      // it's for MSVC.
-      if (!FoundLP) {
-        FoundLP = true;
-        EHPersonality Pers = classifyEHPersonality(LP->getPersonalityFn());
-        if (isMSVCEHPersonality(Pers))
-          return false;
-      }
-    }
   }
 
   if (Resumes.empty())
     return false;
 
+  // Check the personality, don't do anything if it's for MSVC.
+  EHPersonality Pers = classifyEHPersonality(Fn.getPersonalityFn());
+  if (isMSVCEHPersonality(Pers))
+    return false;
+
   LLVMContext &Ctx = Fn.getContext();
 
   size_t ResumesLeft = pruneUnreachableResumes(Fn, Resumes, CleanupLPads);
   if (ResumesLeft == 0)
     return true; // We pruned them all.
 
   // Find the rewind function if we didn't already.
   if (!RewindFunction) {

llvm/trunk/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

for (BB = Fn->begin(); BB != EB; ++BB) {
     if (const auto *Invoke = dyn_cast<InvokeInst>(BB->getTerminator()))
       MBBMap[Invoke->getSuccessor(1)]->setIsLandingPad();
     if (BB->isLandingPad())
       LPads.push_back(BB->getLandingPadInst());
   }
 
   // If this is an MSVC EH personality, we need to do a bit more work.
   EHPersonality Personality = EHPersonality::Unknown;
-  if (!LPads.empty())
-    Personality = classifyEHPersonality(LPads.back()->getPersonalityFn());
+  if (Fn->hasPersonalityFn())
+    Personality = classifyEHPersonality(Fn->getPersonalityFn());
   if (!isMSVCEHPersonality(Personality))
     return;
 
   if (Personality == EHPersonality::MSVC_Win64SEH ||
       Personality == EHPersonality::MSVC_X86SEH) {
     addSEHHandlersForLPads(LPads);
   }
 
if (FT->isVarArg() && !MMI->usesVAFloatArgument()) {
     }
   }
 }
 
 /// AddLandingPadInfo - Extract the exception handling information from the
 /// landingpad instruction and add them to the specified machine module info.
 void llvm::AddLandingPadInfo(const LandingPadInst &I, MachineModuleInfo &MMI,
                              MachineBasicBlock *MBB) {
-  MMI.addPersonality(MBB,
-                     cast<Function>(I.getPersonalityFn()->stripPointerCasts()));
+  MMI.addPersonality(
+      MBB,
+      cast<Function>(
+          I.getParent()->getParent()->getPersonalityFn()->stripPointerCasts()));
 
   if (I.isCleanup())
     MMI.addCleanup(MBB);
 
   // FIXME: New EH - Add the clauses in reverse order. This isn't 100% correct,
   //        but we need to do it this way because of how the DWARF EH emitter
   //        processes the clauses.
   for (unsigned i = I.getNumClauses(); i != 0; --i) {

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

bool SelectionDAGISel::PrepareEHLandingPad() {
   const MCInstrDesc &II = TII->get(TargetOpcode::EH_LABEL);
   BuildMI(*MBB, FuncInfo->InsertPt, SDB->getCurDebugLoc(), II)
     .addSym(Label);
 
   // If this is an MSVC-style personality function, we need to split the landing
   // pad into several BBs.
   const BasicBlock *LLVMBB = MBB->getBasicBlock();
   const LandingPadInst *LPadInst = LLVMBB->getLandingPadInst();
-  MF->getMMI().addPersonality(
-      MBB, cast<Function>(LPadInst->getPersonalityFn()->stripPointerCasts()));
+  MF->getMMI().addPersonality(MBB, cast<Function>(LPadInst->getParent()
+                                                      ->getParent()
+                                                      ->getPersonalityFn()
+                                                      ->stripPointerCasts()));
   EHPersonality Personality = MF->getMMI().getPersonalityType();
 
   if (isMSVCEHPersonality(Personality)) {
     SmallVector<MachineBasicBlock *, 4> ClauseBBs;
     const IntrinsicInst *ActionsCall =
         dyn_cast<IntrinsicInst>(LLVMBB->getFirstInsertionPt());
     // Get all invoke BBs that unwind to this landingpad.
     SmallVector<MachineBasicBlock *, 4> InvokeBBs(MBB->pred_begin(),

llvm/trunk/lib/CodeGen/ShadowStackGCLowering.cpp

case 1:
       if (Calls.empty())
         return nullptr;
 
       // Create a cleanup block.
       LLVMContext &C = F.getContext();
       BasicBlock *CleanupBB = BasicBlock::Create(C, CleanupBBName, &F);
       Type *ExnTy =
           StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C), nullptr);
+      if (!F.hasPersonalityFn()) {
         Constant *PersFn = F.getParent()->getOrInsertFunction(
-          "__gcc_personality_v0", FunctionType::get(Type::getInt32Ty(C), true));
+            "__gcc_personality_v0",
+            FunctionType::get(Type::getInt32Ty(C), true));
+        F.setPersonalityFn(PersFn);
+      }
       LandingPadInst *LPad =
-          LandingPadInst::Create(ExnTy, PersFn, 1, "cleanup.lpad", CleanupBB);
+          LandingPadInst::Create(ExnTy, 1, "cleanup.lpad", CleanupBB);
       LPad->setCleanup(true);
       ResumeInst *RI = ResumeInst::Create(LPad, CleanupBB);
 
       // Transform the 'call' instructions into 'invoke's branching to the
       // cleanup block. Go in reverse order to make prettier BB names.
       SmallVector<Value *, 16> Args;
       for (unsigned I = Calls.size(); I != 0;) {
         CallInst *CI = cast<CallInst>(Calls[--I]);

llvm/trunk/lib/CodeGen/SjLjEHPrepare.cpp

for (unsigned I = 0, E = LPads.size(); I != E; ++I) {
     Value *SelVal = Builder.CreateLoad(SelectorAddr, true, "exn_selector_val");
 
     substituteLPadValues(LPI, ExnVal, SelVal);
   }
 
   // Personality function
   IRBuilder<> Builder(EntryBB->getTerminator());
   if (!PersonalityFn)
-    PersonalityFn = LPads[0]->getPersonalityFn();
+    PersonalityFn = F.getPersonalityFn();
   Value *PersonalityFieldPtr = Builder.CreateConstGEP2_32(
       FunctionContextTy, FuncCtx, 0, 3, "pers_fn_gep");
   Builder.CreateStore(
       Builder.CreateBitCast(PersonalityFn, Builder.getInt8PtrTy()),
       PersonalityFieldPtr, /*isVolatile=*/true);
 
   // LSDA address
   Value *LSDA = Builder.CreateCall(LSDAAddrFn, {}, "lsda_addr");

llvm/trunk/lib/CodeGen/WinEHPrepare.cpp

void completeNestedLandingPad(Function *ParentFn,
                                 LandingPadInst *OutlinedLPad,
                                 const LandingPadInst *OriginalLPad,
                                 FrameVarInfoMap &VarInfo);
   Function *createHandlerFunc(Type *RetTy, const Twine &Name, Module *M,
                               Value *&ParentFP);
   bool outlineHandler(ActionHandler *Action, Function *SrcFn,
                       LandingPadInst *LPad, BasicBlock *StartBB,
                       FrameVarInfoMap &VarInfo);
-  void addStubInvokeToHandlerIfNeeded(Function *Handler, Value *PersonalityFn);
+  void addStubInvokeToHandlerIfNeeded(Function *Handler);
 
   void mapLandingPadBlocks(LandingPadInst *LPad, LandingPadActions &Actions);
   CatchHandler *findCatchHandler(BasicBlock *BB, BasicBlock *&NextBB,
                                  VisitedBlockSet &VisitedBlocks);
   void findCleanupHandlers(LandingPadActions &Actions, BasicBlock *StartBB,
                            BasicBlock *EndBB);
 
   void processSEHCatchHandler(CatchHandler *Handler, BasicBlock *StartBB);
if (auto *Resume = dyn_cast<ResumeInst>(BB.getTerminator()))
       Resumes.push_back(Resume);
   }
 
   // No need to prepare functions that lack landing pads.
   if (LPads.empty())
     return false;
 
   // Classify the personality to see what kind of preparation we need.
-  Personality = classifyEHPersonality(LPads.back()->getPersonalityFn());
+  Personality = classifyEHPersonality(Fn.getPersonalityFn());
 
   // Do nothing if this is not an MSVC personality.
   if (!isMSVCEHPersonality(Personality))
     return false;
 
   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   LibInfo = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
static bool isCatchBlock(BasicBlock *BB) {
   for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(), IE = BB->end();
        II != IE; ++II) {
     if (match(cast<Value>(II), m_Intrinsic<Intrinsic::eh_begincatch>()))
       return true;
   }
   return false;
 }
 
-static BasicBlock *createStubLandingPad(Function *Handler,
-                                        Value *PersonalityFn) {
+static BasicBlock *createStubLandingPad(Function *Handler) {
   // FIXME: Finish this!
   LLVMContext &Context = Handler->getContext();
   BasicBlock *StubBB = BasicBlock::Create(Context, "stub");
   Handler->getBasicBlockList().push_back(StubBB);
   IRBuilder<> Builder(StubBB);
   LandingPadInst *LPad = Builder.CreateLandingPad(
       llvm::StructType::get(Type::getInt8PtrTy(Context),
                             Type::getInt32Ty(Context), nullptr),
-      PersonalityFn, 0);
+      0);
   // Insert a call to llvm.eh.actions so that we don't try to outline this lpad.
   Function *ActionIntrin =
       Intrinsic::getDeclaration(Handler->getParent(), Intrinsic::eh_actions);
   Builder.CreateCall(ActionIntrin, {}, "recover");
   LPad->setCleanup(true);
   Builder.CreateUnreachable();
   return StubBB;
 }
 
 // Cycles through the blocks in an outlined handler function looking for an
 // invoke instruction and inserts an invoke of llvm.donothing with an empty
 // landing pad if none is found.  The code that generates the .xdata tables for
 // the handler needs at least one landing pad to identify the parent function's
 // personality.
-void WinEHPrepare::addStubInvokeToHandlerIfNeeded(Function *Handler,
-                                                  Value *PersonalityFn) {
+void WinEHPrepare::addStubInvokeToHandlerIfNeeded(Function *Handler) {
   ReturnInst *Ret = nullptr;
   UnreachableInst *Unreached = nullptr;
   for (BasicBlock &BB : *Handler) {
     TerminatorInst *Terminator = BB.getTerminator();
     // If we find an invoke, there is nothing to be done.
     auto *II = dyn_cast<InvokeInst>(Terminator);
     if (II)
       return;
void WinEHPrepare::addStubInvokeToHandlerIfNeeded(Function *Handler) {
   else
     Term = Unreached;
   BasicBlock *OldRetBB = Term->getParent();
   BasicBlock *NewRetBB = SplitBlock(OldRetBB, Term, DT);
   // SplitBlock adds an unconditional branch instruction at the end of the
   // parent block.  We want to replace that with an invoke call, so we can
   // erase it now.
   OldRetBB->getTerminator()->eraseFromParent();
-  BasicBlock *StubLandingPad = createStubLandingPad(Handler, PersonalityFn);
+  BasicBlock *StubLandingPad = createStubLandingPad(Handler);
   Function *F =
       Intrinsic::getDeclaration(Handler->getParent(), Intrinsic::donothing);
   InvokeInst::Create(F, NewRetBB, StubLandingPad, None, "", OldRetBB);
 }
 
 // FIXME: Consider sinking this into lib/Target/X86 somehow. TargetLowering
 // usually doesn't build LLVM IR, so that's probably the wrong place.
 Function *WinEHPrepare::createHandlerFunc(Type *RetTy, const Twine &Name,
bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
   Function *Handler;
   if (Action->getType() == Catch) {
     Handler = createHandlerFunc(Int8PtrType, SrcFn->getName() + ".catch", M,
                                 ParentFP);
   } else {
     Handler = createHandlerFunc(Type::getVoidTy(Context),
                                 SrcFn->getName() + ".cleanup", M, ParentFP);
   }
+  Handler->setPersonalityFn(SrcFn->getPersonalityFn());
   HandlerToParentFP[Handler] = ParentFP;
   Handler->addFnAttr("wineh-parent", SrcFn->getName());
   BasicBlock *Entry = &Handler->getEntryBlock();
 
   // Generate a standard prolog to setup the frame recovery structure.
   IRBuilder<> Builder(Context);
   Builder.SetInsertPoint(Entry);
   Builder.SetCurrentDebugLocation(LPad->getDebugLoc());
bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
   while (!pred_empty(ClonedIt))
     ++ClonedIt;
   BasicBlock *ClonedEntryBB = ClonedIt;
   assert(ClonedEntryBB);
   Entry->getInstList().splice(Entry->end(), ClonedEntryBB->getInstList());
   ClonedEntryBB->eraseFromParent();
 
   // Make sure we can identify the handler's personality later.
-  addStubInvokeToHandlerIfNeeded(Handler, LPad->getPersonalityFn());
+  addStubInvokeToHandlerIfNeeded(Handler);
 
   if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
     WinEHCatchDirector *CatchDirector =
         reinterpret_cast<WinEHCatchDirector *>(Director.get());
     CatchAction->setExceptionVar(CatchDirector->getExceptionVar());
     CatchAction->setReturnTargets(CatchDirector->getReturnTargets());
 
     // Look for blocks that are not part of the landing pad that we just

llvm/trunk/lib/IR/AsmWriter.cpp

for (const Function &F : *M) {
     if (F.hasPrefixData())
       if (!isa<GlobalValue>(F.getPrefixData()))
         orderValue(F.getPrefixData(), OM);
 
     if (F.hasPrologueData())
       if (!isa<GlobalValue>(F.getPrologueData()))
         orderValue(F.getPrologueData(), OM);
 
+    if (F.hasPersonalityFn())
+      if (!isa<GlobalValue>(F.getPersonalityFn()))
+        orderValue(F.getPersonalityFn(), OM);
+
     orderValue(&F, OM);
 
     if (F.isDeclaration())
       continue;
 
     for (const Argument &A : F.args())
       orderValue(&A, OM);
     for (const BasicBlock &BB : F) {
void AssemblyWriter::printFunction(const Function *F) {
   if (F->hasPrefixData()) {
     Out << " prefix ";
     writeOperand(F->getPrefixData(), true);
   }
   if (F->hasPrologueData()) {
     Out << " prologue ";
     writeOperand(F->getPrologueData(), true);
   }
+  if (F->hasPersonalityFn()) {
+    Out << " personality ";
+    writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
+  }
 
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   F->getAllMetadata(MDs);
   printMetadataAttachments(MDs, " ");
 
   if (F->isDeclaration()) {
     Out << '\n';
   } else {
if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
     Out << ' ';
     writeOperand(I.getOperand(0), true); Out << ", ";
     writeOperand(I.getOperand(1), true);
     for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
       Out << ", " << *i;
   } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
     Out << ' ';
     TypePrinter.print(I.getType(), Out);
-    Out << " personality ";
-    writeOperand(I.getOperand(0), true); Out << '\n';
+    if (LPI->isCleanup() || LPI->getNumClauses() != 0)
+      Out << '\n';
 
     if (LPI->isCleanup())
       Out << "          cleanup";
 
     for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
       if (i != 0 || LPI->isCleanup()) Out << "\n";
       if (LPI->isCatch(i))
         Out << "          catch ";

llvm/trunk/lib/IR/Core.cpp

LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
                              const char *Name) {
   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
                                       makeArrayRef(unwrap(Args), NumArgs),
                                       Name));
 }
 
 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
-                                 LLVMValueRef PersFn, unsigned NumClauses,
-                                 const char *Name) {
-  return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty),
-                                          cast<Function>(unwrap(PersFn)),
-                                          NumClauses, Name));
+                                 unsigned NumClauses, const char *Name) {
+  return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
 }
 
 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
 }
 
 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
   return wrap(unwrap(B)->CreateUnreachable());

llvm/trunk/lib/IR/Function.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Function Implementation
 //===----------------------------------------------------------------------===//
 
 Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name,
                    Module *ParentModule)
-    : GlobalObject(PointerType::getUnqual(Ty), Value::FunctionVal, nullptr, 0,
-                   Linkage, name),
+    : GlobalObject(PointerType::getUnqual(Ty), Value::FunctionVal,
+                   OperandTraits<Function>::op_begin(this), 0, Linkage, name),
       Ty(Ty) {
   assert(FunctionType::isValidReturnType(getReturnType()) &&
          "invalid return type");
   setGlobalObjectSubClassData(0);
   SymTab = new ValueSymbolTable();
 
   // If the function has arguments, mark them as lazily built.
   if (Ty->getNumParams())
Function::~Function() {
   dropAllReferences();    // After this it is safe to delete instructions.
 
   // Delete all of the method arguments and unlink from symbol table...
   ArgumentList.clear();
   delete SymTab;
 
   // Remove the function from the on-the-side GC table.
   clearGC();
+
+  // FIXME: needed by operator delete
+  setFunctionNumOperands(1);
 }
 
 void Function::BuildLazyArguments() const {
   // Create the arguments vector, all arguments start out unnamed.
   FunctionType *FT = getFunctionType();
   for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
     assert(!FT->getParamType(i)->isVoidTy() &&
            "Cannot have void typed arguments!");
while (!BasicBlocks.empty())
     BasicBlocks.begin()->eraseFromParent();
 
   // Prefix and prologue data are stored in a side table.
   setPrefixData(nullptr);
   setPrologueData(nullptr);
 
   // Metadata is stored in a side-table.
   clearMetadata();
+
+  setPersonalityFn(nullptr);
 }
 
 void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
   AttributeSet PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, attr);
   setAttributes(PAL);
 }
 
void Function::copyAttributesFrom(const GlobalValue *Src) {
   if (SrcF->hasPrefixData())
     setPrefixData(SrcF->getPrefixData());
   else
     setPrefixData(nullptr);
   if (SrcF->hasPrologueData())
     setPrologueData(SrcF->getPrologueData());
   else
     setPrologueData(nullptr);
+  if (SrcF->hasPersonalityFn())
+    setPersonalityFn(SrcF->getPersonalityFn());
+  else
+    setPersonalityFn(nullptr);
 }
 
 /// \brief This does the actual lookup of an intrinsic ID which
 /// matches the given function name.
 static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
   unsigned Len = ValName->getKeyLength();
   const char *Name = ValName->getKeyData();
 
Optional<uint64_t> Function::getEntryCount() const {
   if (MD && MD->getOperand(0))
     if (MDString *MDS = dyn_cast<MDString>(MD->getOperand(0)))
       if (MDS->getString().equals("function_entry_count")) {
         ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
         return CI->getValue().getZExtValue();
       }
   return None;
 }
+
+void Function::setPersonalityFn(Constant *C) {
+  if (!C) {
+    if (hasPersonalityFn()) {
+      // Note, the num operands is used to compute the offset of the operand, so
+      // the order here matters.  Clearing the operand then clearing the num
+      // operands ensures we have the correct offset to the operand.
+      Op<0>().set(nullptr);
+      setFunctionNumOperands(0);
+    }
+  } else {
+    // Note, the num operands is used to compute the offset of the operand, so
+    // the order here matters.  We need to set num operands to 1 first so that
+    // we get the correct offset to the first operand when we set it.
+    if (!hasPersonalityFn())
+      setFunctionNumOperands(1);
+    Op<0>().set(C);
+  }
+}

llvm/trunk/lib/IR/Instructions.cpp

if (ConstantValue == this)
     return UndefValue::get(getType());
   return ConstantValue;
 }
 
 //===----------------------------------------------------------------------===//
 //                       LandingPadInst Implementation
 //===----------------------------------------------------------------------===//
 
-LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn,
-                               unsigned NumReservedValues, const Twine &NameStr,
-                               Instruction *InsertBefore)
+LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+                               const Twine &NameStr, Instruction *InsertBefore)
     : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
-  init(PersonalityFn, 1 + NumReservedValues, NameStr);
+  init(NumReservedValues, NameStr);
 }
 
-LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn,
-                               unsigned NumReservedValues, const Twine &NameStr,
-                               BasicBlock *InsertAtEnd)
+LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+                               const Twine &NameStr, BasicBlock *InsertAtEnd)
     : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) {
-  init(PersonalityFn, 1 + NumReservedValues, NameStr);
+  init(NumReservedValues, NameStr);
 }
 
 LandingPadInst::LandingPadInst(const LandingPadInst &LP)
     : Instruction(LP.getType(), Instruction::LandingPad, nullptr,
                   LP.getNumOperands()),
       ReservedSpace(LP.getNumOperands()) {
   allocHungoffUses(LP.getNumOperands());
   Use *OL = getOperandList();
   const Use *InOL = LP.getOperandList();
   for (unsigned I = 0, E = ReservedSpace; I != E; ++I)
     OL[I] = InOL[I];
 
   setCleanup(LP.isCleanup());
 }
 
-LandingPadInst *LandingPadInst::Create(Type *RetTy, Value *PersonalityFn,
-                                       unsigned NumReservedClauses,
+LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
                                        const Twine &NameStr,
                                        Instruction *InsertBefore) {
-  return new LandingPadInst(RetTy, PersonalityFn, NumReservedClauses, NameStr,
-                            InsertBefore);
+  return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertBefore);
 }
 
-LandingPadInst *LandingPadInst::Create(Type *RetTy, Value *PersonalityFn,
-                                       unsigned NumReservedClauses,
+LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
                                        const Twine &NameStr,
                                        BasicBlock *InsertAtEnd) {
-  return new LandingPadInst(RetTy, PersonalityFn, NumReservedClauses, NameStr,
-                            InsertAtEnd);
+  return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertAtEnd);
 }
 
-void LandingPadInst::init(Value *PersFn, unsigned NumReservedValues,
-                          const Twine &NameStr) {
+void LandingPadInst::init(unsigned NumReservedValues, const Twine &NameStr) {
   ReservedSpace = NumReservedValues;
-  setNumHungOffUseOperands(1);
+  setNumHungOffUseOperands(0);
   allocHungoffUses(ReservedSpace);
-  Op<0>() = PersFn;
   setName(NameStr);
   setCleanup(false);
 }
 
 /// growOperands - grow operands - This grows the operand list in response to a
 /// push_back style of operation. This grows the number of ops by 2 times.
 void LandingPadInst::growOperands(unsigned Size) {
   unsigned e = getNumOperands();
   if (ReservedSpace >= e + Size) return;
-  ReservedSpace = (e + Size / 2) * 2;
+  ReservedSpace = (std::max(e, 1U) + Size / 2) * 2;
   growHungoffUses(ReservedSpace);
 }
 
 void LandingPadInst::addClause(Constant *Val) {
   unsigned OpNo = getNumOperands();
   growOperands(1);
   assert(OpNo < ReservedSpace && "Growing didn't work!");
   setNumHungOffUseOperands(getNumOperands() + 1);

llvm/trunk/lib/IR/TypeFinder.cpp

for (Module::const_iterator FI = M.begin(), E = M.end(); FI != E; ++FI) {
     incorporateType(FI->getType());
 
     if (FI->hasPrefixData())
       incorporateValue(FI->getPrefixData());
 
     if (FI->hasPrologueData())
       incorporateValue(FI->getPrologueData());
 
+    if (FI->hasPersonalityFn())
+      incorporateValue(FI->getPersonalityFn());
+
     // First incorporate the arguments.
     for (Function::const_arg_iterator AI = FI->arg_begin(),
            AE = FI->arg_end(); AI != AE; ++AI)
       incorporateValue(AI);
 
     for (Function::const_iterator BB = FI->begin(), E = FI->end();
          BB != E;++BB)
       for (BasicBlock::const_iterator II = BB->begin(),

llvm/trunk/lib/IR/Verifier.cpp

class Verifier : public InstVisitor<Verifier>, VerifierSupport {
   SmallPtrSet<Instruction *, 16> InstsInThisBlock;
 
   /// \brief Keep track of the metadata nodes that have been checked already.
   SmallPtrSet<const Metadata *, 32> MDNodes;
 
   /// \brief Track unresolved string-based type references.
   SmallDenseMap<const MDString *, const MDNode *, 32> UnresolvedTypeRefs;
 
-  /// \brief The personality function referenced by the LandingPadInsts.
-  /// All LandingPadInsts within the same function must use the same
-  /// personality function.
-  const Value *PersonalityFn;
-
   /// \brief Whether we've seen a call to @llvm.frameescape in this function
   /// already.
   bool SawFrameEscape;
 
   /// Stores the count of how many objects were passed to llvm.frameescape for a
   /// given function and the largest index passed to llvm.framerecover.
   DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
 
 public:
   explicit Verifier(raw_ostream &OS)
-      : VerifierSupport(OS), Context(nullptr), PersonalityFn(nullptr),
-        SawFrameEscape(false) {}
+      : VerifierSupport(OS), Context(nullptr), SawFrameEscape(false) {}
 
   bool verify(const Function &F) {
     M = F.getParent();
     Context = &M->getContext();
 
     // First ensure the function is well-enough formed to compute dominance
     // information.
     if (F.empty()) {
bool verify(const Function &F) {
     // run this code outside of a pass manager.
     // FIXME: It's really gross that we have to cast away constness here.
     DT.recalculate(const_cast<Function &>(F));
 
     Broken = false;
     // FIXME: We strip const here because the inst visitor strips const.
     visit(const_cast<Function &>(F));
     InstsInThisBlock.clear();
-    PersonalityFn = nullptr;
     SawFrameEscape = false;
 
     return !Broken;
   }
 
   bool verify(const Module &M) {
     this->M = &M;
     Context = &M.getContext();
if (F.isMaterializable()) {
     // Function has a body somewhere we can't see.
     Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
            MDs.empty() ? nullptr : MDs.front().second);
   } else if (F.isDeclaration()) {
     Assert(F.hasExternalLinkage() || F.hasExternalWeakLinkage(),
            "invalid linkage type for function declaration", &F);
     Assert(MDs.empty(), "function without a body cannot have metadata", &F,
            MDs.empty() ? nullptr : MDs.front().second);
+    Assert(!F.hasPersonalityFn(),
+           "Function declaration shouldn't have a personality routine", &F);
   } else {
     // Verify that this function (which has a body) is not named "llvm.*".  It
     // is not legal to define intrinsics.
     Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
 
     // Check the entry node
     const BasicBlock *Entry = &F.getEntryBlock();
     Assert(pred_empty(Entry),
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
   for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
     const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator());
     Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
            "Block containing LandingPadInst must be jumped to "
            "only by the unwind edge of an invoke.",
            &LPI);
   }
 
+  Function *F = LPI.getParent()->getParent();
+  Assert(F->hasPersonalityFn(),
+         "LandingPadInst needs to be in a function with a personality.", &LPI);
+
   // The landingpad instruction must be the first non-PHI instruction in the
   // block.
   Assert(LPI.getParent()->getLandingPadInst() == &LPI,
          "LandingPadInst not the first non-PHI instruction in the block.",
          &LPI);
 
-  // The personality functions for all landingpad instructions within the same
-  // function should match.
-  if (PersonalityFn)
-    Assert(LPI.getPersonalityFn() == PersonalityFn,
-           "Personality function doesn't match others in function", &LPI);
-  PersonalityFn = LPI.getPersonalityFn();
-
-  // All operands must be constants.
-  Assert(isa<Constant>(PersonalityFn), "Personality function is not constant!",
-         &LPI);
   for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
     Constant *Clause = LPI.getClause(i);
     if (LPI.isCatch(i)) {
       Assert(isa<PointerType>(Clause->getType()),
              "Catch operand does not have pointer type!", &LPI);
     } else {
       Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
       Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),

llvm/trunk/lib/Linker/LinkModules.cpp

if (Src.hasPrefixData())
     Dst.setPrefixData(MapValue(Src.getPrefixData(), ValueMap, RF_None, &TypeMap,
                                &ValMaterializer));
 
   // Link in the prologue data.
   if (Src.hasPrologueData())
     Dst.setPrologueData(MapValue(Src.getPrologueData(), ValueMap, RF_None,
                                  &TypeMap, &ValMaterializer));
 
+  // Link in the personality function.
+  if (Src.hasPersonalityFn())
+    Dst.setPersonalityFn(MapValue(Src.getPersonalityFn(), ValueMap, RF_None,
+                                  &TypeMap, &ValMaterializer));
+
   // Go through and convert function arguments over, remembering the mapping.
   Function::arg_iterator DI = Dst.arg_begin();
   for (Argument &Arg : Src.args()) {
     DI->setName(Arg.getName());  // Copy the name over.
 
     // Add a mapping to our mapping.
     ValueMap[&Arg] = DI;
     ++DI;

llvm/trunk/lib/Target/X86/X86WinEHState.cpp

bool WinEHStatePass::runOnFunction(Function &F) {
   // If this is an outlined handler, don't do anything. We'll do state insertion
   // for it in the parent.
   StringRef WinEHParentName =
       F.getFnAttribute("wineh-parent").getValueAsString();
   if (WinEHParentName != F.getName() && !WinEHParentName.empty())
     return false;
 
   // Check the personality. Do nothing if this is not an MSVC personality.
-  LandingPadInst *LP = nullptr;
-  for (BasicBlock &BB : F) {
-    LP = BB.getLandingPadInst();
-    if (LP)
-      break;
-  }
-  if (!LP)
+  if (!F.hasPersonalityFn())
     return false;
   PersonalityFn =
-      dyn_cast<Function>(LP->getPersonalityFn()->stripPointerCasts());
+      dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
   if (!PersonalityFn)
     return false;
   Personality = classifyEHPersonality(PersonalityFn);
   if (!isMSVCEHPersonality(Personality))
     return false;
 
   // Disable frame pointer elimination in this function.
   // FIXME: Do the nested handlers need to keep the parent ebp in ebp, or can we

llvm/trunk/lib/Transforms/IPO/GlobalDCE.cpp

if (GlobalVariable *GV = dyn_cast<GlobalVariable>(G)) {
     Function *F = cast<Function>(G);
 
     if (F->hasPrefixData())
       MarkUsedGlobalsAsNeeded(F->getPrefixData());
 
     if (F->hasPrologueData())
       MarkUsedGlobalsAsNeeded(F->getPrologueData());
 
+    if (F->hasPersonalityFn())
+      MarkUsedGlobalsAsNeeded(F->getPersonalityFn());
+
     for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
       for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
         for (User::op_iterator U = I->op_begin(), E = I->op_end(); U != E; ++U)
           if (GlobalValue *GV = dyn_cast<GlobalValue>(*U))
             GlobalIsNeeded(GV);
           else if (Constant *C = dyn_cast<Constant>(*U))
             MarkUsedGlobalsAsNeeded(C);
   }

llvm/trunk/lib/Transforms/IPO/PruneEH.cpp

 
 // SimplifyFunction - Given information about callees, simplify the specified
 // function if we have invokes to non-unwinding functions or code after calls to
 // no-return functions.
 bool PruneEH::SimplifyFunction(Function *F) {
   bool MadeChange = false;
   for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
     if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator()))
-      if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(II)) {
+      if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(F)) {
         SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3);
         // Insert a call instruction before the invoke.
         CallInst *Call = CallInst::Create(II->getCalledValue(), Args, "", II);
         Call->takeName(II);
         Call->setCallingConv(II->getCallingConv());
         Call->setAttributes(II->getAttributes());
         Call->setDebugLoc(II->getDebugLoc());
 

llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp

static bool shorter_filter(const Value *LHS, const Value *RHS) {
   <
     cast<ArrayType>(RHS->getType())->getNumElements();
 }
 
 Instruction *InstCombiner::visitLandingPadInst(LandingPadInst &LI) {
   // The logic here should be correct for any real-world personality function.
   // However if that turns out not to be true, the offending logic can always
   // be conditioned on the personality function, like the catch-all logic is.
-  EHPersonality Personality = classifyEHPersonality(LI.getPersonalityFn());
+  EHPersonality Personality =
+      classifyEHPersonality(LI.getParent()->getParent()->getPersonalityFn());
 
   // Simplify the list of clauses, eg by removing repeated catch clauses
   // (these are often created by inlining).
   bool MakeNewInstruction = false; // If true, recreate using the following:
   SmallVector<Constant *, 16> NewClauses; // - Clauses for the new instruction;
   bool CleanupFlag = LI.isCleanup();   // - The new instruction is a cleanup.
 
   SmallPtrSet<Value *, 16> AlreadyCaught; // Typeinfos known caught already.
for (unsigned j = NewClauses.size() - 1; j != i; --j) {
       // Move on to the next filter.
     }
   }
 
   // If we changed any of the clauses, replace the old landingpad instruction
   // with a new one.
   if (MakeNewInstruction) {
     LandingPadInst *NLI = LandingPadInst::Create(LI.getType(),
-                                                 LI.getPersonalityFn(),
                                                  NewClauses.size());
     for (unsigned i = 0, e = NewClauses.size(); i != e; ++i)
       NLI->addClause(NewClauses[i]);
     // A landing pad with no clauses must have the cleanup flag set.  It is
     // theoretically possible, though highly unlikely, that we eliminated all
     // clauses.  If so, force the cleanup flag to true.
     if (NewClauses.empty())
       CleanupFlag = true;
if (isInstructionTriviallyDead(I, TLI)) {
       DEBUG(dbgs() << "IC: DCE: " << *I << '\n');
       EraseInstFromFunction(*I);
       ++NumDeadInst;
       MadeIRChange = true;
       continue;
     }
 
     // Instruction isn't dead, see if we can constant propagate it.
-    if (!I->use_empty() && isa<Constant>(I->getOperand(0))) {
+    if (!I->use_empty() &&
+        (I->getNumOperands() == 0 || isa<Constant>(I->getOperand(0)))) {
       if (Constant *C = ConstantFoldInstruction(I, DL, TLI)) {
         DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: " << *I << '\n');
 
         // Add operands to the worklist.
         ReplaceInstUsesWith(*I, C);
         ++NumConstProp;
         EraseInstFromFunction(*I);
         MadeIRChange = true;
for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
       if (isInstructionTriviallyDead(Inst, TLI)) {
         ++NumDeadInst;
         DEBUG(dbgs() << "IC: DCE: " << *Inst << '\n');
         Inst->eraseFromParent();
         continue;
       }
 
       // ConstantProp instruction if trivially constant.
-      if (!Inst->use_empty() && isa<Constant>(Inst->getOperand(0)))
+      if (!Inst->use_empty() &&
+          (Inst->getNumOperands() == 0 || isa<Constant>(Inst->getOperand(0))))
         if (Constant *C = ConstantFoldInstruction(Inst, DL, TLI)) {
           DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: "
                        << *Inst << '\n');
           Inst->replaceAllUsesWith(C);
           ++NumConstProp;
           Inst->eraseFromParent();
           continue;
         }

llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp

bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
   if (CalledFunc->hasGC()) {
     if (!Caller->hasGC())
       Caller->setGC(CalledFunc->getGC());
     else if (CalledFunc->getGC() != Caller->getGC())
       return false;
   }
 
   // Get the personality function from the callee if it contains a landing pad.
-  Value *CalleePersonality = nullptr;
-  for (Function::const_iterator I = CalledFunc->begin(), E = CalledFunc->end();
-       I != E; ++I)
-    if (const InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator())) {
-      const BasicBlock *BB = II->getUnwindDest();
-      const LandingPadInst *LP = BB->getLandingPadInst();
-      CalleePersonality = LP->getPersonalityFn();
-      break;
-    }
+  Constant *CalledPersonality =
+      CalledFunc->hasPersonalityFn() ? CalledFunc->getPersonalityFn() : nullptr;
 
   // Find the personality function used by the landing pads of the caller. If it
   // exists, then check to see that it matches the personality function used in
   // the callee.
-  if (CalleePersonality) {
-    for (Function::const_iterator I = Caller->begin(), E = Caller->end();
-         I != E; ++I)
-      if (const InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator())) {
-        const BasicBlock *BB = II->getUnwindDest();
-        const LandingPadInst *LP = BB->getLandingPadInst();
-
-        // If the personality functions match, then we can perform the
-        // inlining. Otherwise, we can't inline.
-        // TODO: This isn't 100% true. Some personality functions are proper
-        //       supersets of others and can be used in place of the other.
-        if (LP->getPersonalityFn() != CalleePersonality)
-          return false;
-
-        break;
-      }
+  Constant *CallerPersonality =
+      Caller->hasPersonalityFn() ? Caller->getPersonalityFn() : nullptr;
+  if (CalledPersonality) {
+    if (!CallerPersonality)
+      Caller->setPersonalityFn(CalledPersonality);
+    else if (CalledPersonality != CallerPersonality)
   }
 
   // Get an iterator to the last basic block in the function, which will have
   // the new function inlined after it.
   Function::iterator LastBlock = &Caller->back();
 
   // Make sure to capture all of the return instructions from the cloned
   // function.

llvm/trunk/lib/Transforms/Utils/Local.cpp

static void changeToCall(InvokeInst *II) {
   // Follow the call by a branch to the normal destination.
   BranchInst::Create(II->getNormalDest(), II);
 
   // Update PHI nodes in the unwind destination
   II->getUnwindDest()->removePredecessor(II->getParent());
   II->eraseFromParent();
 }
 
-static bool markAliveBlocks(BasicBlock *BB,
+static bool markAliveBlocks(Function &F,
                             SmallPtrSetImpl<BasicBlock*> &Reachable) {
 
   SmallVector<BasicBlock*, 128> Worklist;
+  BasicBlock *BB = F.begin();
   Worklist.push_back(BB);
   Reachable.insert(BB);
   bool Changed = false;
   do {
     BB = Worklist.pop_back_val();
 
     // Do a quick scan of the basic block, turning any obviously unreachable
     // instructions into LLVM unreachable insts.  The instruction combining pass
do {
     }
 
     // Turn invokes that call 'nounwind' functions into ordinary calls.
     if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
       Value *Callee = II->getCalledValue();
       if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
         changeToUnreachable(II, true);
         Changed = true;
-      } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(II)) {
+      } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
         if (II->use_empty() && II->onlyReadsMemory()) {
           // jump to the normal destination branch.
           BranchInst::Create(II->getNormalDest(), II);
           II->getUnwindDest()->removePredecessor(II->getParent());
           II->eraseFromParent();
         } else
           changeToCall(II);
         Changed = true;
       }
     }
 
     Changed |= ConstantFoldTerminator(BB, true);
     for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
       if (Reachable.insert(*SI).second)
         Worklist.push_back(*SI);
   } while (!Worklist.empty());
   return Changed;
 }
 
 /// removeUnreachableBlocksFromFn - Remove blocks that are not reachable, even
 /// if they are in a dead cycle.  Return true if a change was made, false
 /// otherwise.
 bool llvm::removeUnreachableBlocks(Function &F) {
   SmallPtrSet<BasicBlock*, 128> Reachable;
-  bool Changed = markAliveBlocks(F.begin(), Reachable);
+  bool Changed = markAliveBlocks(F, Reachable);
 
   // If there are unreachable blocks in the CFG...
   if (Reachable.size() == F.size())
     return Changed;
 
   assert(Reachable.size() < F.size());
   NumRemoved += F.size()-Reachable.size();
 

llvm/trunk/test/Analysis/CallGraph/do-nothing-intrinsic.ll

 ; RUN: opt < %s -basiccg
 ; PR13903
 
-define void @main() {
+define void @main() personality i8 0 {
   invoke void @llvm.donothing()
           to label %ret unwind label %unw
 unw:
-  %tmp = landingpad i8 personality i8 0 cleanup
+  %tmp = landingpad i8 cleanup
   br label %ret
 ret:
   ret void
 }
 declare void @llvm.donothing() nounwind readnone

llvm/trunk/test/Analysis/Dominators/invoke.ll

 ; RUN: opt -verify -disable-output < %s
 ; This tests that we handle unreachable blocks correctly
 
-define void @f() {
+define void @f() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %v1 = invoke i32* @g()
           to label %bb1 unwind label %bb2
   invoke void @__dynamic_cast()
           to label %bb1 unwind label %bb2
 bb1:
   %Hidden = getelementptr inbounds i32, i32* %v1, i64 1
   ret void
 bb2:
-  %lpad.loopexit80 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %lpad.loopexit80 = landingpad { i8*, i32 }
           cleanup
   ret void
 }
 declare i32 @__gxx_personality_v0(...)
 declare void @__dynamic_cast()
 declare i32* @g()

llvm/trunk/test/Analysis/LazyCallGraph/basic.ll

 entry:
   call void @f()
   call void @f()
   call void @f()
   call void @f()
   ret void
 }
 
-define void ()* @test1(void ()** %x) {
+define void ()* @test1(void ()** %x) personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: Call edges in function: test1
 ; CHECK-NEXT: -> f12
 ; CHECK-NEXT: -> f11
 ; CHECK-NEXT: -> f10
 ; CHECK-NEXT: -> f7
 ; CHECK-NEXT: -> f9
 ; CHECK-NEXT: -> f8
 ; CHECK-NEXT: -> f6
next:
   call void @f6()
   call void (void ()*, void ()*) bitcast (void ()* @f7 to void (void ()*, void ()*)*)(void ()* @f8, void ()* @f9)
   invoke void @f10() to label %exit unwind label %unwind
 
 exit:
   ret void ()* @f11
 
 unwind:
-  %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %res = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } { i8* bitcast (void ()* @f12 to i8*), i32 42 }
 }
 
 @g = global void ()* @f1
 @g1 = global [4 x void ()*] [void ()* @f2, void ()* @f3, void ()* @f4, void ()* @f5]
 @g2 = global {i8, void ()*, i8} {i8 1, void ()* @f6, i8 2}
 @h = constant void ()* @f7

llvm/trunk/test/Analysis/Lint/cppeh-catch-intrinsics-clean.ll

 ; RUN: opt -lint -disable-output < %s
 
 ; This test is meant to prove that the verifier does not report errors for correct
 ; use of the llvm.eh.begincatch and llvm.eh.endcatch intrinsics.
 
 target triple = "x86_64-pc-windows-msvc"
 
 declare void @llvm.eh.begincatch(i8*, i8*)
 
 declare void @llvm.eh.endcatch()
 
 @_ZTIi = external constant i8*
 
 ; Function Attrs: uwtable
-define void @test_ref_clean() {
+define void @test_ref_clean() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   call void @llvm.eh.begincatch(i8* %exn, i8* null)
   call void @_Z10handle_intv()
   br label %invoke.cont2
 
 invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch()
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %entry
   ret void
 
 eh.resume:                                        ; preds = %catch.dispatch
   resume { i8*, i32 } %0
 }
 
 ; Function Attrs: uwtable
-define void @test_ref_clean_multibranch() {
+define void @test_ref_clean_multibranch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad1
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad1:                                            ; preds = %entry
-  %l1.0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %l1.0 = landingpad { i8*, i32 }
       cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn1 = extractvalue { i8*, i32 } %l1.0, 0
   %sel1 = extractvalue { i8*, i32 } %l1.0, 1
   %l1.1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matchesl1 = icmp eq i32 %sel1, %l1.1
   br i1 %matchesl1, label %catch, label %eh.resume
 

llvm/trunk/test/Analysis/Lint/cppeh-catch-intrinsics.ll

 ; RUN: opt -lint -disable-output < %s 2>&1 | FileCheck %s
 
 ; This test is meant to prove that the Verifier is able to identify a variety
 ; of errors with the llvm.eh.begincatch and llvm.eh.endcatch intrinsics.
 ; See cppeh-catch-intrinsics-clean for correct uses.
 
 target triple = "x86_64-pc-windows-msvc"
 
 declare void @llvm.eh.begincatch(i8*, i8*)
 
 declare void @llvm.eh.endcatch()
 
 @_ZTIi = external constant i8*
 
 ; Function Attrs: uwtable
-define void @test_missing_endcatch() {
+define void @test_missing_endcatch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: Some paths from llvm.eh.begincatch may not reach llvm.eh.endcatch
 ; CHECK-NEXT: call void @llvm.eh.begincatch(i8* %exn, i8* null)
 entry:
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   call void @llvm.eh.begincatch(i8* %exn, i8* null)
   call void @_Z10handle_intv()
   br label %invoke.cont2
 
 invoke.cont2:                                     ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %entry
   ret void
 
 eh.resume:                                        ; preds = %catch.dispatch
   resume { i8*, i32 } %0
 }
 
 ; Function Attrs: uwtable
-define void @test_missing_begincatch() {
+define void @test_missing_begincatch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: llvm.eh.endcatch may be reachable without passing llvm.eh.begincatch
 ; CHECK-NEXT:  call void @llvm.eh.endcatch()
 entry:
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   call void @_Z10handle_intv()
   br label %invoke.cont2
 
 invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch()
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %entry
   ret void
 
 eh.resume:                                        ; preds = %catch.dispatch
   resume { i8*, i32 } %0
 }
 
 ; Function Attrs: uwtable
-define void @test_multiple_begin() {
+define void @test_multiple_begin() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: llvm.eh.begincatch may be called a second time before llvm.eh.endcatch
 ; CHECK-NEXT: call void @llvm.eh.begincatch(i8* %exn, i8* null)
 ; CHECK-NEXT: call void @llvm.eh.begincatch(i8* %exn, i8* null)
 entry:
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad

 try.cont:                                         ; preds = %invoke.cont2, %entry
   ret void
 
 eh.resume:                                        ; preds = %catch.dispatch
   resume { i8*, i32 } %0
 }
 
 ; Function Attrs: uwtable
-define void @test_multiple_end() {
+define void @test_multiple_end() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: llvm.eh.endcatch may be called a second time after llvm.eh.begincatch
 ; CHECK-NEXT:  call void @llvm.eh.endcatch()
 ; CHECK-NEXT:  call void @llvm.eh.endcatch()
 entry:
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch()
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %entry
   ret void
 }
 
 ; Function Attrs: uwtable
-define void @test_branch_to_begincatch_with_no_lpad(i32 %fake.sel) {
+define void @test_branch_to_begincatch_with_no_lpad(i32 %fake.sel) personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: llvm.eh.begincatch may be reachable without passing a landingpad
 ; CHECK-NEXT: call void @llvm.eh.begincatch(i8* %exn2, i8* null)
 entry:
   %fake.exn = alloca i8
   invoke void @_Z9may_throwv()
           to label %catch unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
   invoke void @_Z9may_throwv()
try.cont:                                         ; preds = %invoke.cont2
   ret void
 
 eh.resume:                                        ; preds = %catch.dispatch
   %lpad.val = insertvalue { i8*, i32 } undef, i32 0, 1
   resume { i8*, i32 } %lpad.val
 }
 
 ; Function Attrs: uwtable
-define void @test_branch_missing_endcatch() {
+define void @test_branch_missing_endcatch() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: Some paths from llvm.eh.begincatch may not reach llvm.eh.endcatch
 ; CHECK-NEXT: call void @llvm.eh.begincatch(i8* %exn2, i8* null)
 entry:
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad1
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn = extractvalue { i8*, i32 } %0, 0
   %sel = extractvalue { i8*, i32 } %0, 1
   %1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matches = icmp eq i32 %sel, %1
   br i1 %matches, label %catch, label %eh.resume
 
   invoke void @_Z9may_throwv()
           to label %try.cont unwind label %lpad
 
 lpad1:                                            ; preds = %entry
-  %l1.0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %l1.0 = landingpad { i8*, i32 }
       cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %exn1 = extractvalue { i8*, i32 } %l1.0, 0
   %sel1 = extractvalue { i8*, i32 } %l1.0, 1
   %l1.1 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %matchesl1 = icmp eq i32 %sel1, %l1.1
   br i1 %matchesl1, label %catch, label %eh.resume
 

llvm/trunk/test/Assembler/invalid-landingpad.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
 
 ; CHECK: clause argument must be a constant
 
-define void @test(i32 %in) {
-  landingpad {} personality void()* null filter i32 %in
+define void @test(i32 %in) personality void()* null {
+  landingpad {} filter i32 %in
 }

llvm/trunk/test/Bitcode/miscInstructions.3.2.ll

 ; RUN:  llvm-dis < %s.bc| FileCheck %s
 
 ; miscInstructions.3.2.ll.bc was generated by passing this file to llvm-as-3.2.
 ; The test checks that LLVM does not misread miscellaneous instructions of
 ; older bitcode files.
 
 @X = global i8 1
 @_ZTIi = global i8* @X 
 @_ZTId = global i8* @X 
 
 define i32 @__gxx_personality_v0(...){
 entry:
   ret i32 0
 }
 
+; CHECK-LABEL: define void @landingpadInstr1
+; CHECK-SAME: personality i32 (...)* @__gxx_personality_v0
 define void @landingpadInstr1(i1 %cond1, <2 x i1> %cond2, <2 x i8> %x1, <2 x i8> %x2){
 entry:
-; CHECK: %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: %res = landingpad { i8*, i32 }
   %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0 
 ; CHECK: catch i8** @_ZTIi
   catch i8** @_ZTIi
   ret void
 }
 
+; CHECK-LABEL: define void @landingpadInstr2
+; CHECK-SAME: personality i32 (...)* @__gxx_personality_v0
 define void @landingpadInstr2(i1 %cond1, <2 x i1> %cond2, <2 x i8> %x1, <2 x i8> %x2){
 entry:
-; CHECK: %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: %res = landingpad { i8*, i32 }
   %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
 ; CHECK: cleanup
   cleanup
   ret void
 }
 
+; CHECK-LABEL: define void @landingpadInstr3
+; CHECK-SAME: personality i32 (...)* @__gxx_personality_v0
 define void @landingpadInstr3(i1 %cond1, <2 x i1> %cond2, <2 x i8> %x1, <2 x i8> %x2){
 entry:
-; CHECK: %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0 
+; CHECK: %res = landingpad { i8*, i32 }
   %res = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
 ; CHECK: catch i8** @_ZTIi
   catch i8** @_ZTIi
 ; CHECK: filter [1 x i8**] [i8** @_ZTId]
   filter [1 x i8**] [i8** @_ZTId]
   ret void
 }
 

llvm/trunk/test/CodeGen/AArch64/arm64-big-endian-eh.ll

 ; RUN: llc -mtriple aarch64_be-linux-gnu -filetype obj < %s | llvm-objdump -s - | FileCheck %s
 
 ; ARM EHABI for big endian
 ; This test case checks whether CIE length record is laid out in big endian format.
 ;
 ; This is the LLVM assembly generated from following C++ code:
 ;
 ; extern void foo(int);
 ; void test(int a, int b) {
 ;   try {
 ;   foo(a);
 ; } catch (...) {
 ;   foo(b);
 ; }
 ;}
 
-define void @_Z4testii(i32 %a, i32 %b) #0 {
+define void @_Z4testii(i32 %a, i32 %b) #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z3fooi(i32 %a)
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1) #2
   invoke void @_Z3fooi(i32 %b)
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %lpad
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:                                         ; preds = %entry, %invoke.cont2
   ret void
 
 lpad1:                                            ; preds = %lpad
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:                                        ; preds = %lpad1
   resume { i8*, i32 } %3
 
 terminate.lpad:                                   ; preds = %lpad1
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   tail call void @__clang_call_terminate(i8* %5) #3
   unreachable
 }
 
 declare void @_Z3fooi(i32) #0
 

llvm/trunk/test/CodeGen/AArch64/br-to-eh-lpad.ll

 ; RUN: llc < %s -mtriple=aarch64-apple-ios -verify-machineinstrs
 
 ; This function tests that the machine verifier accepts an unconditional
 ; branch from an invoke basic block, to its EH landing pad basic block.
 ; The test is brittle and isn't ideally reduced, because in most cases the
 ; branch would be removed (for instance, turned into a fallthrough), and in
 ; that case, the machine verifier, which relies on analyzing branches for this
 ; kind of verification, is unable to check anything, so accepts the CFG.
 
-define void @test_branch_to_landingpad() {
+define void @test_branch_to_landingpad() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   br i1 undef, label %if.end50.thread, label %if.then6
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch %struct._objc_typeinfo.12.129.194.285.350.493.519.532.571.597.623.765* @"OBJC_EHTYPE_$_NSString"
           catch %struct._objc_typeinfo.12.129.194.285.350.493.519.532.571.597.623.765* @OBJC_EHTYPE_id
           catch i8* null
   br i1 undef, label %invoke.cont33, label %catch.fallthrough
 
 catch.fallthrough:
   %matches31 = icmp eq i32 undef, 0
   br i1 %matches31, label %invoke.cont41, label %finally.catchall

 invoke.cont41:
   invoke void @objc_exception_rethrow()
           to label %invoke.cont43 unwind label %lpad40
 
 invoke.cont43:
   unreachable
 
 lpad40:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   br label %finally.catchall
 
 finally.catchall:
   tail call void (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str1, i64 0, i64 0), i32 125)
   unreachable
 }
 

llvm/trunk/test/CodeGen/AArch64/pic-eh-stubs.ll

; CHECK-NEXT: .xword  .L_ZTIi.DW.stub-[[TYPEINFO_LBL]]
 
   ; .. and which is properly defined (in a writable section for the dynamic loader) later.
 ; CHECK: .section .data.rel,"aw"
 ; CHECK: .L_ZTIi.DW.stub:
 ; CHECK-NEXT: .xword _ZTIi
 
 @_ZTIi = external constant i8*
 
-define i32 @_Z3barv() {
+define i32 @_Z3barv() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z3foov()
           to label %return unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) nounwind
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   %3 = extractvalue { i8*, i32 } %0, 0

llvm/trunk/test/CodeGen/ARM/2009-08-31-LSDA-Name.ll

 ; RUN: llc < %s -mtriple=arm-apple-darwin9 -march=arm | FileCheck %s
 
 ; CHECK: .cfi_lsda 16, [[LABEL:.*]]
 ; CHECK: .long  [[LABEL]]-
 ; CHECK: [[LABEL]]:
 ; CHECK: .byte   255                     @ @LPStart Encoding = omit
 
 %struct.A = type { i32* }
 
-define void @"\01-[MyFunction Name:]"() {
+define void @"\01-[MyFunction Name:]"() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %save_filt.1 = alloca i32
   %save_eptr.0 = alloca i8*
   %a = alloca %struct.A
   %eh_exception = alloca i8*
   %eh_selector = alloca i32
   %"alloca point" = bitcast i32 0 to i32
   call void @_ZN1AC1Ev(%struct.A* %a)
bb:                                               ; preds = %ppad
   %1 = load i32, i32* %save_filt.1, align 4
   store i32 %1, i32* %eh_selector, align 4
   br label %Unwind
 
 return:                                           ; preds = %invcont
   ret void
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn = landingpad {i8*, i32}
            cleanup
   %eh_ptr = extractvalue {i8*, i32} %exn, 0
   store i8* %eh_ptr, i8** %eh_exception
   %eh_select2 = extractvalue {i8*, i32} %exn, 1
   store i32 %eh_select2, i32* %eh_selector
   br label %ppad
 
 ppad:                                             ; preds = %lpad

llvm/trunk/test/CodeGen/ARM/2010-07-26-GlobalMerge.ll

entry:
   %tmp3.i = load i32, i32* @d                          ; <i32> [#uses=1]
   %inc.i = add nsw i32 %tmp3.i, 1                 ; <i32> [#uses=1]
   store i32 %inc.i, i32* @d
   ret void
 }
 
 declare void @__cxa_throw(i8*, i8*, i8*)
 
-define i32 @main() ssp {
+define i32 @main() ssp personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %puts.i = tail call i32 @puts(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str, i32 0, i32 0)) ; <i32> [#uses=0]
   %exception.i = tail call i8* @__cxa_allocate_exception(i32 4) nounwind ; <i8*> [#uses=2]
   %tmp2.i.i.i = bitcast i8* %exception.i to i32*  ; <i32*> [#uses=1]
   store i32 1, i32* %tmp2.i.i.i
   %call.i.i.i = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str5, i32 0, i32 0), i32 1) nounwind ; <i32> [#uses=0]
   invoke void @__cxa_throw(i8* %exception.i, i8* bitcast (%0* @_ZTI1A to i8*), i8* bitcast (void (%struct.A*)* @_ZN1AD1Ev to i8*)) noreturn
           to label %.noexc unwind label %lpad
try.cont:                                         ; preds = %lpad
   %tmp13 = load i32, i32* @d                           ; <i32> [#uses=1]
   %call14 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str2, i32 0, i32 0), i32 2, i32 %tmp13) ; <i32> [#uses=0]
   %tmp16 = load i32, i32* @d                           ; <i32> [#uses=1]
   %cmp = icmp ne i32 %tmp16, 2                    ; <i1> [#uses=1]
   %conv = zext i1 %cmp to i32                     ; <i32> [#uses=1]
   ret i32 %conv
 
 lpad:                                             ; preds = %entry
-  %exn.ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn.ptr = landingpad { i8*, i32 }
            catch i8* bitcast (%0* @_ZTI1A to i8*)
            catch i8* null
   %exn = extractvalue { i8*, i32 } %exn.ptr, 0
   %eh.selector = extractvalue { i8*, i32 } %exn.ptr, 1
   %2 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%0* @_ZTI1A to i8*)) nounwind ; <i32> [#uses=1]
   %3 = icmp eq i32 %eh.selector, %2               ; <i1> [#uses=1]
   br i1 %3, label %try.cont, label %eh.resume
 

llvm/trunk/test/CodeGen/ARM/2010-08-04-EHCrash.ll

 ; RUN: llc < %s -mtriple=thumbv7-apple-darwin10
 ; <rdar://problem/8264008>
 
-define linkonce_odr arm_apcscc void @func1() {
+define linkonce_odr arm_apcscc void @func1() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %save_filt.936 = alloca i32                     ; <i32*> [#uses=2]
   %save_eptr.935 = alloca i8*                     ; <i8**> [#uses=2]
   %eh_exception = alloca i8*                      ; <i8**> [#uses=5]
   %eh_selector = alloca i32                       ; <i32*> [#uses=3]
   %"alloca point" = bitcast i32 0 to i32          ; <i32> [#uses=0]
   call arm_apcscc  void @func2()
   br label %return

 bb12:                                             ; preds = %ppad
   call arm_apcscc  void @_ZSt9terminatev() noreturn nounwind
   unreachable
 
 return:                                           ; preds = %entry
   ret void
 
 lpad:                                             ; preds = %bb
-  %eh_ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %eh_ptr = landingpad { i8*, i32 }
               cleanup
   %exn = extractvalue { i8*, i32 } %eh_ptr, 0
   store i8* %exn, i8** %eh_exception
   %eh_ptr13 = load i8*, i8** %eh_exception             ; <i8*> [#uses=1]
   %eh_select14 = extractvalue { i8*, i32 } %eh_ptr, 1
   store i32 %eh_select14, i32* %eh_selector
   br label %ppad
 

llvm/trunk/test/CodeGen/ARM/2011-05-04-MultipleLandingPadSuccs.ll

 ; RUN: llc < %s -verify-machineinstrs
 ; <rdar://problem/9187612>
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:64:64-v128:128:128-a0:0:32-n32"
 target triple = "thumbv7-apple-darwin"
 
-define void @func() unnamed_addr align 2 {
+define void @func() unnamed_addr align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   br label %for.cond
 
 for.cond:
   %tmp2 = phi i32 [ 0, %entry ], [ %add, %for.cond.backedge ]
   %cmp = icmp ult i32 %tmp2, 14
   br i1 %cmp, label %for.body, label %for.end
 

 invoke.cont17:
   invoke void @foo()
           to label %for.cond.backedge unwind label %lpad26
 
 for.cond.backedge:
   br label %for.cond
 
 lpad:
-  %exn = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn = landingpad { i8*, i32 }
            catch i8* null
   invoke void @foo()
           to label %eh.resume unwind label %terminate.lpad
 
 lpad26:
-  %exn27 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn27 = landingpad { i8*, i32 }
            catch i8* null
   invoke void @foo()
           to label %eh.resume unwind label %terminate.lpad
 
 sw.default:
   br label %for.cond.backedge
 
 for.end:
   invoke void @foo()
           to label %call8.i.i.i.noexc unwind label %lpad44
 
 call8.i.i.i.noexc:
   ret void
 
 lpad44:
-  %exn45 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn45 = landingpad { i8*, i32 }
            catch i8* null
   invoke void @foo()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:
   %exn.slot.0 = phi { i8*, i32 } [ %exn27, %lpad26 ], [ %exn, %lpad ], [ %exn45, %lpad44 ]
   resume { i8*, i32 } %exn.slot.0
 
 terminate.lpad:
-  %exn51 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn51 = landingpad { i8*, i32 }
            catch i8* null
   tail call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 }
 
 declare void @foo()
 
 declare i32 @__gxx_personality_sj0(...)

llvm/trunk/test/CodeGen/ARM/2011-12-19-sjlj-clobber.ll

 ; RUN: llc < %s -O0 -mtriple=thumbv7-apple-ios | FileCheck %s
 
 ; Radar 10567930: Make sure that all the caller-saved registers are saved and
 ; restored in a function with setjmp/longjmp EH.  In particular, r6 was not
 ; being saved here.
 ; CHECK: push {r4, r5, r6, r7, lr}
 
 %0 = type opaque
 %struct.NSConstantString = type { i32*, i32, i8*, i32 }
 
-define i32 @asdf(i32 %a, i32 %b, i8** %c, i8* %d) {
+define i32 @asdf(i32 %a, i32 %b, i8** %c, i8* %d) personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 bb:
   %tmp = alloca i32, align 4
   %tmp1 = alloca i32, align 4
   %tmp2 = alloca i8*, align 4
   %tmp3 = alloca i1
   %myException = alloca %0*, align 4
   %tmp4 = alloca i8*
   %tmp5 = alloca i32
bb11:                                             ; preds = %bb
   %tmp13 = bitcast %0* %tmp12 to i8*
   invoke void @objc_exception_throw(i8* %tmp13) noreturn
           to label %bb14 unwind label %bb15
 
 bb14:                                             ; preds = %bb11
   unreachable
 
 bb15:                                             ; preds = %bb11, %bb
-  %tmp16 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %tmp16 = landingpad { i8*, i32 }
           catch i8* null
   %tmp17 = extractvalue { i8*, i32 } %tmp16, 0
   store i8* %tmp17, i8** %tmp4
   %tmp18 = extractvalue { i8*, i32 } %tmp16, 1
   store i32 %tmp18, i32* %tmp5
   store i1 true, i1* %tmp3
   br label %bb56
 
 bb56:
   unreachable
 }
 
 declare i8* @objc_msgSend(i8*, i8*, ...) nonlazybind
 declare i32 @__objc_personality_v0(...)
 declare void @objc_exception_throw(i8*)

llvm/trunk/test/CodeGen/ARM/2012-04-24-SplitEHCriticalEdge.ll

 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
 
 declare void @__cxa_end_catch()
 
 declare void @_ZSt9terminatev()
 
-define hidden double @t(%0* %self, i8* nocapture %_cmd) optsize ssp {
+define hidden double @t(%0* %self, i8* nocapture %_cmd) optsize ssp personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %call = invoke double undef(%class.FunctionInterpreter.3.15.31* undef) optsize
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8* }* @_ZTI13ParseErrorMsg to i8*)
   br i1 undef, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, %struct.ParseErrorMsg.0.12.28*)*)(i8* undef, i8* undef, %struct.ParseErrorMsg.0.12.28* undef) optsize
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %entry
   %value.0 = phi double [ 0x7FF8000000000000, %invoke.cont2 ], [ %call, %entry ]
   ret double %value.0
 
 lpad1:                                            ; preds = %catch
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:                                        ; preds = %lpad1, %lpad
   resume { i8*, i32 } undef
 
 terminate.lpad:                                   ; preds = %lpad1
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 declare i32 @__gxx_personality_sj0(...)
 
 !llvm.module.flags = !{!0, !1, !2, !3}
 
 !0 = !{i32 1, !"Objective-C Version", i32 2}
 !1 = !{i32 1, !"Objective-C Image Info Version", i32 0}
 !2 = !{i32 1, !"Objective-C Image Info Section", !"__DATA, __objc_imageinfo, regular, no_dead_strip"}
 !3 = !{i32 4, !"Objective-C Garbage Collection", i32 0}

llvm/trunk/test/CodeGen/ARM/2014-05-14-DwarfEHCrash.ll

 ; Assertion `Encoding == DW_EH_PE_absptr && "Can handle absptr encoding only"' failed.
 ; Broken in r208166, fixed in 208715.
 
 ; RUN: llc -mtriple=arm-linux-androideabi -o - -filetype=asm -relocation-model=pic %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
 target triple = "armv4t--linux-androideabi"
 
 @_ZTIi = external constant i8*
 
-define void @_Z3fn2v() #0 {
+define void @_Z3fn2v() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z3fn1v()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) #2
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   %3 = extractvalue { i8*, i32 } %0, 0

llvm/trunk/test/CodeGen/ARM/arm-ttype-target2.ll

 ; RUN: llc -mtriple=armv7-none-linux-gnueabi < %s | FileCheck %s
 
 @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
 @_ZTS3Foo = linkonce_odr constant [5 x i8] c"3Foo\00"
 @_ZTI3Foo = linkonce_odr unnamed_addr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @_ZTS3Foo, i32 0, i32 0) }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z3foov()
           to label %return unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8* }* @_ZTI3Foo to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = tail call i32 @llvm.eh.typeid.for(i8* bitcast ({ i8*, i8* }* @_ZTI3Foo to i8*)) nounwind
 ; CHECK: _ZTI3Foo(target2)
 
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %catch, label %eh.resume
 

llvm/trunk/test/CodeGen/ARM/big-endian-eh-unwind.ll

 ; RUN: llc < %s -mtriple armeb-eabi -mattr v7 -filetype obj -o - | llvm-objdump -s - | FileCheck %s
 
 ; ARM EHABI for big endian
 ; This test case checks whether frame unwinding instructions are laid out in big endian format.
 ; 
 ; This is the LLVM assembly generated from following C++ code:
 ;
 ; extern void foo(int);
 ; void test(int a, int b) {
 ;   try {
 ;   foo(a);
 ; } catch (...) {
 ;   foo(b);
 ; }
 ;}
 
-define void @_Z4testii(i32 %a, i32 %b) #0 {
+define void @_Z4testii(i32 %a, i32 %b) #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z3fooi(i32 %a)
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1) #2
   invoke void @_Z3fooi(i32 %b)
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %lpad
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:                                         ; preds = %entry, %invoke.cont2
   ret void
 
 lpad1:                                            ; preds = %lpad
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:                                        ; preds = %lpad1
   resume { i8*, i32 } %3
 
 terminate.lpad:                                   ; preds = %lpad1
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   tail call void @__clang_call_terminate(i8* %5) #3
   unreachable
 }
 
 declare void @_Z3fooi(i32) #0
 

llvm/trunk/test/CodeGen/ARM/crash.ll

bb:
   store <4 x float> %tmp154, <4 x float>* undef, align 16
   ret void
 }
 
 ; <rdar://problem/12721258>
 %A = type { %B }
 %B = type { i32 }
 
-define void @_Z3Foov() ssp {
+define void @_Z3Foov() ssp personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   br i1 true, label %exit, label %false
 
 false:
   invoke void undef(%A* undef)
           to label %exit unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 
 exit:
   ret void
 }
 
 declare i32 @__gxx_personality_sj0(...)

llvm/trunk/test/CodeGen/ARM/debug-frame-no-debug.ll

 ;   }
 
 declare void @_Z5printiiiii(i32, i32, i32, i32, i32)
 
 declare void @_Z5printddddd(double, double, double, double, double)
 
 define void @_Z4testiiiiiddddd(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e,
                                double %m, double %n, double %p,
-                               double %q, double %r) {
+                               double %q, double %r) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z5printiiiii(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e)
           to label %try.cont unwind label %lpad
 
 lpad:
   %0 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1)
   invoke void @_Z5printddddd(double %m, double %n, double %p,
                              double %q, double %r)
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret void
 
 lpad1:
   %3 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:
   resume { i8*, i32 } %3
 
 terminate.lpad:
   %4 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   tail call void @__clang_call_terminate(i8* %5)
   unreachable
 }
 
 declare void @__clang_call_terminate(i8*)
 

llvm/trunk/test/CodeGen/ARM/debug-frame.ll

 ;   }
 
 declare void @_Z5printiiiii(i32, i32, i32, i32, i32)
 
 declare void @_Z5printddddd(double, double, double, double, double)
 
 define void @_Z4testiiiiiddddd(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e,
                                double %m, double %n, double %p,
-                               double %q, double %r) {
+                               double %q, double %r) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z5printiiiii(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e)
           to label %try.cont unwind label %lpad
 
 lpad:
   %0 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1)
   invoke void @_Z5printddddd(double %m, double %n, double %p,
                              double %q, double %r)
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret void
 
 lpad1:
   %3 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:
   resume { i8*, i32 } %3
 
 terminate.lpad:
   %4 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   tail call void @__clang_call_terminate(i8* %5)
   unreachable
 }
 
 declare void @__clang_call_terminate(i8*)
 

llvm/trunk/test/CodeGen/ARM/dwarf-eh.ll

 target triple = "armv5e--netbsd-eabi"
 
 %struct.exception = type { i8 }
 
 @_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
 @_ZTS9exception = linkonce_odr constant [11 x i8] c"9exception\00"
 @_ZTI9exception = linkonce_odr unnamed_addr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @_ZTS9exception, i32 0, i32 0) }
 
-define void @f() uwtable {
+define void @f() uwtable personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %1 = alloca i8*
   %2 = alloca i32
   %e = alloca %struct.exception*, align 4
   invoke void @g()
           to label %3 unwind label %4
 
   br label %16
 
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8* }* @_ZTI9exception to i8*)
   %6 = extractvalue { i8*, i32 } %5, 0
   store i8* %6, i8** %1
   %7 = extractvalue { i8*, i32 } %5, 1
   store i32 %7, i32* %2
   br label %8
 
   %9 = load i32, i32* %2

llvm/trunk/test/CodeGen/ARM/eh-dispcont.ll

 ; RUN: llc -mtriple armv7-apple-ios -relocation-model=pic -o - %s | FileCheck %s -check-prefix=ARM-PIC
 ; RUN: llc -mtriple armv7-apple-ios -relocation-model=static -o - %s | FileCheck %s -check-prefix=ARM-NOPIC
 ; RUN: llc -mtriple armv7-apple-ios -relocation-model=dynamic-no-pic -o - %s | FileCheck %s -check-prefix=ARM-NOPIC
 ; RUN: llc -mtriple thumbv6-apple-ios -relocation-model=pic -o - %s | FileCheck %s -check-prefix=THUMB1-PIC
 ; RUN: llc -mtriple thumbv6-apple-ios -relocation-model=static -o - %s | FileCheck %s -check-prefix=THUMB1-NOPIC
 ; RUN: llc -mtriple thumbv6-apple-ios -relocation-model=dynamic-no-pic -o - %s | FileCheck %s -check-prefix=THUMB1-NOPIC
 
 @_ZTIi = external constant i8*
 
-define i32 @main() #0 {
+define i32 @main() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %exception = tail call i8* @__cxa_allocate_exception(i32 4) #1
   %0 = bitcast i8* %exception to i32*
   store i32 1, i32* %0, align 4
   invoke void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #2
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   %2 = extractvalue { i8*, i32 } %1, 0
   %3 = tail call i8* @__cxa_begin_catch(i8* %2) #1
   tail call void @__cxa_end_catch()
   ret i32 0
 
 unreachable:                                      ; preds = %entry
   unreachable

llvm/trunk/test/CodeGen/ARM/eh-resume-darwin.ll

 ; RUN: llc < %s -march=arm | FileCheck %s
 target triple = "armv6-apple-macosx10.6"
 
 declare void @func()
 
 declare i32 @__gxx_personality_sj0(...)
 
-define void @test0() {
+define void @test0() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   invoke void @func()
     to label %cont unwind label %lpad
 
 cont:
   ret void
 
 lpad:
-  %exn = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %exn = landingpad { i8*, i32 }
            cleanup
   resume { i8*, i32 } %exn
 }
 
 ; CHECK: __Unwind_SjLj_Resume

llvm/trunk/test/CodeGen/ARM/ehabi-filters.ll

 ; RUN: llc < %s | FileCheck %s
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
 target triple = "armv7-none-linux-gnueabi"
 
 @_ZTIi = external constant i8*
 
 declare void @_Z3foov() noreturn;
 
 declare i8* @__cxa_allocate_exception(i32)
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @__cxa_throw(i8*, i8*, i8*)
 
 declare void @__cxa_call_unexpected(i8*)
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: main:
 entry:
   %exception.i = tail call i8* @__cxa_allocate_exception(i32 4) nounwind
   %0 = bitcast i8* %exception.i to i32*
   store i32 42, i32* %0, align 4
   invoke void @__cxa_throw(i8* %exception.i, i8* bitcast (i8** @_ZTIi to i8*), i8* null) noreturn
           to label %unreachable.i unwind label %lpad.i
 
 lpad.i:                                           ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           filter [1 x i8*] [i8* bitcast (i8** @_ZTIi to i8*)]
           catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK: .long  _ZTIi(target2)          @ TypeInfo 1
 ; CHECK: .long  _ZTIi(target2)          @ FilterInfo -1
   %2 = extractvalue { i8*, i32 } %1, 1
   %ehspec.fails.i = icmp slt i32 %2, 0
   br i1 %ehspec.fails.i, label %ehspec.unexpected.i, label %lpad.body
 
 ehspec.unexpected.i:                              ; preds = %lpad.i
   %3 = extractvalue { i8*, i32 } %1, 0
   invoke void @__cxa_call_unexpected(i8* %3) noreturn
           to label %.noexc unwind label %lpad
 
 .noexc:                                           ; preds = %ehspec.unexpected.i
   unreachable
 
 unreachable.i:                                    ; preds = %entry
   unreachable
 
 lpad:                                             ; preds = %ehspec.unexpected.i
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   br label %lpad.body
 
 lpad.body:                                        ; preds = %lpad.i, %lpad
   %eh.lpad-body = phi { i8*, i32 } [ %4, %lpad ], [ %1, %lpad.i ]
   %5 = extractvalue { i8*, i32 } %eh.lpad-body, 1
   %6 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) nounwind
   %matches = icmp eq i32 %5, %6

llvm/trunk/test/CodeGen/ARM/ehabi-handlerdata-nounwind.ll

 declare void @throw_exception()
 
 declare i32 @__gxx_personality_v0(...)
 
 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @__cxa_end_catch()
 
-define void @test1() nounwind {
+define void @test1() nounwind personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throw_exception() to label %try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1)
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret void

llvm/trunk/test/CodeGen/ARM/ehabi-handlerdata.ll

 declare void @throw_exception()
 
 declare i32 @__gxx_personality_v0(...)
 
 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @__cxa_end_catch()
 
-define void @test1() {
+define void @test1() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throw_exception() to label %try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1)
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret void

llvm/trunk/test/CodeGen/ARM/ehabi.ll

 ;   }
 
 declare void @_Z5printiiiii(i32, i32, i32, i32, i32)
 
 declare void @_Z5printddddd(double, double, double, double, double)
 
 define void @_Z4testiiiiiddddd(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e,
                                double %m, double %n, double %p,
-                               double %q, double %r) {
+                               double %q, double %r) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z5printiiiii(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e)
           to label %try.cont unwind label %lpad
 
 lpad:
   %0 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = tail call i8* @__cxa_begin_catch(i8* %1)
   invoke void @_Z5printddddd(double %m, double %n, double %p,
                              double %q, double %r)
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:
   tail call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret void
 
 lpad1:
   %3 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           cleanup
   invoke void @__cxa_end_catch()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:
   resume { i8*, i32 } %3
 
 terminate.lpad:
   %4 = landingpad { i8*, i32 }
-          personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   tail call void @__clang_call_terminate(i8* %5)
   unreachable
 }
 
 declare void @__clang_call_terminate(i8*)
 

llvm/trunk/test/CodeGen/ARM/global-merge.ll

 ; CHECK: g8
 @g8 = internal global i32 0
 @llvm.used = appending global [1 x i8*] [i8* bitcast (i32* @g8 to i8*)], section "llvm.metadata"
 
 ; Global used in landing pad instruction must be kept
 ; CHECK: ZTIi
 @_ZTIi = internal global i8* null
 
-define i32 @_Z9exceptioni(i32 %arg) {
+define i32 @_Z9exceptioni(i32 %arg) personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 bb:
   %tmp = invoke i32 @_Z14throwSomethingi(i32 %arg)
           to label %bb9 unwind label %bb1
 
 bb1:                                              ; preds = %bb
-  %tmp2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp2 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %tmp3 = extractvalue { i8*, i32 } %tmp2, 1
   %tmp4 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*))
   %tmp5 = icmp eq i32 %tmp3, %tmp4
   br i1 %tmp5, label %bb6, label %bb10
 
 bb6:                                              ; preds = %bb1
   %tmp7 = extractvalue { i8*, i32 } %tmp2, 0

llvm/trunk/test/CodeGen/ARM/gv-stubs-crash.ll

 ; RUN: llc < %s -mtriple=thumbv7-apple-ios -relocation-model=pic
 ; <rdar://problem/10336715>
 
 @Exn = external hidden unnamed_addr constant { i8*, i8* }
 
-define hidden void @func(i32* %this, i32* %e) optsize align 2 {
+define hidden void @func(i32* %this, i32* %e) optsize align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
   %e.ld = load i32, i32* %e, align 4
   %inv = invoke zeroext i1 @func2(i32* %this, i32 %e.ld) optsize
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad:
-  %lp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %lp = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8* }* @Exn to i8*)
   br label %.loopexit4
 
 .loopexit4:
   %exn = call i8* @__cxa_allocate_exception(i32 8) nounwind
   call void @__cxa_throw(i8* %exn, i8* bitcast ({ i8*, i8* }* @Exn to i8*), i8* bitcast (void (i32*)* @dtor to i8*)) noreturn
   unreachable
 

llvm/trunk/test/CodeGen/ARM/invoke-donothing-assert.ll

 ; RUN: llc < %s -mtriple=armv7-apple-ios | FileCheck %s
 ; This testcase makes sure we can handle invoke @llvm.donothing without
 ; assertion failure.
 ; <rdar://problem/13228754> & <rdar://problem/13316637>
 
 ; CHECK: .globl  _foo
-define void @foo() {
+define void @foo() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 invoke.cont:
   invoke void @callA() 
           to label %invoke.cont25 unwind label %lpad2
 invoke.cont25:
   invoke void @llvm.donothing()
           to label %invoke.cont27 unwind label %lpad15
 
 invoke.cont27:
   invoke void @callB()
           to label %invoke.cont75 unwind label %lpad15
 
 invoke.cont75:
   ret void
 
 lpad2:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 lpad15:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 eh.resume:
   resume { i8*, i32 } zeroinitializer
 }
 
 ; CHECK: .globl _bar
-define linkonce_odr void @bar(i32* %a) {
+define linkonce_odr void @bar(i32* %a) personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 if.end.i.i.i:
   invoke void @llvm.donothing()
           to label %call.i.i.i.noexc unwind label %eh.resume
 
 call.i.i.i.noexc:
   br i1 false, label %cleanup, label %new.notnull.i.i
 
 new.notnull.i.i:
   br label %cleanup
 
 cleanup:
   %0 = load i32, i32* %a, align 4
   %inc294 = add nsw i32 %0, 4
   store i32 %inc294, i32* %a, align 4
   br i1 false, label %_ZN3lol5ArrayIivvvvvvvED1Ev.exit, label %delete.notnull.i.i.i1409
 
 delete.notnull.i.i.i1409:
   br label %_ZN3lol5ArrayIivvvvvvvED1Ev.exit
 
 _ZN3lol5ArrayIivvvvvvvED1Ev.exit:
   ret void
 
 eh.resume:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   %2 = extractvalue { i8*, i32 } %1, 0
   %3 = extractvalue { i8*, i32 } %1, 1
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %2, 0
   %lpad.val395 = insertvalue { i8*, i32 } %lpad.val, i32 %3, 1
   resume { i8*, i32 } %lpad.val395
 }
 
 declare void @callA()
 declare void @callB()
 declare void @llvm.donothing() nounwind readnone
 declare i32 @__gxx_personality_sj0(...)

llvm/trunk/test/CodeGen/ARM/sjlj-prepare-critical-edge.ll

 ; RUN: llc < %s -O1 -mtriple thumbv7-apple-ios6 | FileCheck %s
 ; Just make sure no one tries to make the assumption that the normal edge of an
 ; invoke is never a critical edge.  Previously, this code would assert.
 
 %struct.__CFString = type opaque
 
 declare void @bar(%struct.__CFString*, %struct.__CFString*)
 
-define noalias i8* @foo(i8* nocapture %inRefURL) noreturn ssp {
+define noalias i8* @foo(i8* nocapture %inRefURL) noreturn ssp personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %call = tail call %struct.__CFString* @bar3()
   %call2 = invoke i8* @bar2()
           to label %for.cond unwind label %lpad
 
 for.cond:                                         ; preds = %entry, %for.cond
   invoke void @bar(%struct.__CFString* undef, %struct.__CFString* null)
           to label %for.cond unwind label %lpad5
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   br label %ehcleanup
 
 lpad5:                                            ; preds = %for.cond
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   %4 = extractvalue { i8*, i32 } %3, 0
   %5 = extractvalue { i8*, i32 } %3, 1
   invoke void @release(i8* %call2)
           to label %ehcleanup unwind label %terminate.lpad.i.i16
 
 terminate.lpad.i.i16:                             ; preds = %lpad5
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %6 = landingpad { i8*, i32 }
           catch i8* null
   tail call void @terminatev() noreturn nounwind
   unreachable
 
 ehcleanup:                                        ; preds = %lpad5, %lpad
   %exn.slot.0 = phi i8* [ %1, %lpad ], [ %4, %lpad5 ]
   %ehselector.slot.0 = phi i32 [ %2, %lpad ], [ %5, %lpad5 ]
   %7 = bitcast %struct.__CFString* %call to i8*
   invoke void @release(i8* %7)
           to label %_ZN5SmartIPK10__CFStringED1Ev.exit unwind label %terminate.lpad.i.i
 
 terminate.lpad.i.i:                               ; preds = %ehcleanup
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %8 = landingpad { i8*, i32 }
           catch i8* null
   tail call void @terminatev() noreturn nounwind
   unreachable
 
 _ZN5SmartIPK10__CFStringED1Ev.exit:               ; preds = %ehcleanup
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn.slot.0, 0
   %lpad.val12 = insertvalue { i8*, i32 } %lpad.val, i32 %ehselector.slot.0, 1
   resume { i8*, i32 } %lpad.val12

 %"class.std::__1::__compressed_pair" = type { %"class.std::__1::__libcpp_compressed_pair_imp" }
 %"class.std::__1::__libcpp_compressed_pair_imp" = type { %"struct.std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::__rep" }
 %"struct.std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::__rep" = type { %union.anon }
 %union.anon = type { %"struct.std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::__long" }
 %"struct.std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::__long" = type { i32, i32, i8* }
 
 @.str = private unnamed_addr constant [12 x i8] c"some_string\00", align 1
 
-define void @_Z4foo1c(i8 signext %a) {
+define void @_Z4foo1c(i8 signext %a) personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %s1 = alloca %"class.std::__1::basic_string", align 4
   call void @_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm(%"class.std::__1::basic_string"* %s1, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 11)
   %call.i.i.i14.i.i = invoke noalias i8* @_Znwm(i32 1024)
           to label %do.body.i.i.i unwind label %lpad.body
 
 do.body.i.i.i:                                    ; preds = %entry, %_ZNSt3__116allocator_traitsINS_9allocatorIcEEE9constructIccEEvRS2_PT_RKT0_.exit.i.i.i
   %lsr.iv = phi i32 [ %lsr.iv.next, %_ZNSt3__116allocator_traitsINS_9allocatorIcEEE9constructIccEEvRS2_PT_RKT0_.exit.i.i.i ], [ -1024, %entry ]
_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i19: ; preds = %invoke.cont5
   call void @_ZdlPv(i8* %call.i.i.i14.i.i)
   br label %invoke.cont6
 
 invoke.cont6:                                     ; preds = %_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i19, %invoke.cont5
   %call10 = call %"class.std::__1::basic_string"* @_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev(%"class.std::__1::basic_string"* %s1)
   ret void
 
 lpad.body:                                        ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %3 = extractvalue { i8*, i32 } %2, 0
   %4 = extractvalue { i8*, i32 } %2, 1
   br label %ehcleanup
 
 lpad2:                                            ; preds = %invoke.cont
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %5 = landingpad { i8*, i32 }
           cleanup
   %6 = extractvalue { i8*, i32 } %5, 0
   %7 = extractvalue { i8*, i32 } %5, 1
   %cmp.i.i.i21 = icmp eq i8* %call.i.i.i14.i.i, null
   br i1 %cmp.i.i.i21, label %ehcleanup, label %_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i26
 
 _ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i26: ; preds = %lpad2
   call void @_ZdlPv(i8* %call.i.i.i14.i.i)
   br label %ehcleanup
 
 ehcleanup:                                        ; preds = %_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i26, %lpad2, %lpad.body
   %exn.slot.0 = phi i8* [ %3, %lpad.body ], [ %6, %lpad2 ], [ %6, %_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i26 ]
   %ehselector.slot.0 = phi i32 [ %4, %lpad.body ], [ %7, %lpad2 ], [ %7, %_ZNSt3__113__vector_baseIcNS_9allocatorIcEEE5clearEv.exit.i.i.i26 ]
   %call12 = invoke %"class.std::__1::basic_string"* @_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev(%"class.std::__1::basic_string"* %s1)
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:                                        ; preds = %ehcleanup
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn.slot.0, 0
   %lpad.val13 = insertvalue { i8*, i32 } %lpad.val, i32 %ehselector.slot.0, 1
   resume { i8*, i32 } %lpad.val13
 
 terminate.lpad:                                   ; preds = %ehcleanup
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %8 = landingpad { i8*, i32 }
           catch i8* null
   %9 = extractvalue { i8*, i32 } %8, 0
   call void @__clang_call_terminate(i8* %9)
   unreachable
 }
 
 declare void @_Z4foo2Pci(i8*, i32)
 

llvm/trunk/test/CodeGen/ARM/sjljehprepare-lower-empty-struct.ll

 ; RUN: llc -mtriple=armv7-apple-ios -O0 < %s | FileCheck %s
 ; RUN: llc -mtriple=armv7-apple-ios -O1 < %s | FileCheck %s
 ; RUN: llc -mtriple=armv7-apple-ios -O2 < %s | FileCheck %s
 ; RUN: llc -mtriple=armv7-apple-ios -O3 < %s | FileCheck %s
 
 ; SjLjEHPrepare shouldn't crash when lowering empty structs.
 ;
 ; Checks that between in case of empty structs used as arguments
 ; nothing happens, i.e. there are no instructions between
 ; __Unwind_SjLj_Register and actual @bar invocation
 
 
-define i8* @foo(i8 %a, {} %c) {
+define i8* @foo(i8 %a, {} %c) personality i8* bitcast (i32 (...)* @baz to i8*) {
 entry:
 ; CHECK: bl __Unwind_SjLj_Register
 ; CHECK-NEXT: {{[A-Z][a-zA-Z0-9]*}}:
 ; CHECK-NEXT: bl _bar
   invoke void @bar ()
     to label %unreachable unwind label %handler
 
 unreachable:
   unreachable
 
 handler:
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @baz to i8*)
+  %tmp = landingpad { i8*, i32 }
   cleanup
   resume { i8*, i32 } undef
 }
 
 declare void @bar()
 declare i32 @baz(...)

llvm/trunk/test/CodeGen/Generic/2007-02-25-invoke.ll

 ; RUN: llc < %s
 
 ; PR1224
 
 declare i32 @test()
-define i32 @test2() {
+define i32 @test2() personality i32 (...)* @__gxx_personality_v0 {
         %A = invoke i32 @test() to label %invcont unwind label %blat
 invcont:
         ret i32 %A
 blat:
-  %lpad = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpad = landingpad { i8*, i32 }
             cleanup
   ret i32 0
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Generic/2007-04-30-LandingPadBranchFolding.ll

 ; RUN: llc < %s 
 ; PR1228
 
   %"struct.std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Alloc_hider" = type { i8* }
   %"struct.std::locale" = type { %"struct.std::locale::_Impl"* }
   %"struct.std::locale::_Impl" = type { i32, %"struct.std::locale::facet"**, i32, %"struct.std::locale::facet"**, i8** }
   %"struct.std::locale::facet" = type { i32 (...)**, i32 }
   %"struct.std::string" = type { %"struct.std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Alloc_hider" }
 
-define void @_ZNKSt6locale4nameEv(%"struct.std::string"* %agg.result) {
+define void @_ZNKSt6locale4nameEv(%"struct.std::string"* %agg.result) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %tmp105 = icmp eq i8* null, null    ; <i1> [#uses=1]
   br i1 %tmp105, label %cond_true, label %cond_true222
 
 cond_true:    ; preds = %entry
   invoke void @_ZNSs14_M_replace_auxEjjjc( )
       to label %cond_next1328 unwind label %cond_true1402
 

 
 invcont317:   ; preds = %invcont282
   ret void
 
 cond_next1328:    ; preds = %cond_true235, %cond_true
   ret void
 
 cond_true1402:    ; preds = %invcont282, %cond_false280, %cond_true235, %cond_true
-  %lpad = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpad = landingpad { i8*, i32 }
             cleanup
   ret void
 }
 
 declare void @_ZNSs14_M_replace_auxEjjjc()
 
 declare i32 @strcmp()
 
 declare void @_ZNSs6assignEPKcj()
 
 declare void @_ZNSs7reserveEj()
 
 declare void @_ZNSs6appendEPKcj()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Generic/2007-12-17-InvokeAsm.ll

 ; RUN: llc -no-integrated-as < %s
 
-define fastcc void @bc__support__high_resolution_time__initialize_clock_rate() {
+define fastcc void @bc__support__high_resolution_time__initialize_clock_rate() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void asm "rdtsc\0A\09movl %eax, $0\0A\09movl %edx, $1", "=*imr,=*imr,~{dirflag},~{fpsr},~{flags},~{dx},~{ax}"( i32* null, i32* null )
       to label %.noexc unwind label %cleanup144
 
 .noexc:   ; preds = %entry
   ret void
 
 cleanup144:   ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   resume { i8*, i32 } %exn
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Generic/2007-12-31-UnusedSelector.ll

 ; RUN: llc < %s
 ; PR1833
 
   %struct.__class_type_info_pseudo = type { %struct.__type_info_pseudo }
   %struct.__type_info_pseudo = type { i8*, i8* }
 @_ZTI2e1 = external constant %struct.__class_type_info_pseudo    ; <%struct.__class_type_info_pseudo*> [#uses=1]
 
-define void @_Z7ex_testv() {
+define void @_Z7ex_testv() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @__cxa_throw( i8* null, i8* bitcast (%struct.__class_type_info_pseudo* @_ZTI2e1 to i8*), void (i8*)* null ) noreturn 
       to label %UnifiedUnreachableBlock unwind label %lpad
 
 bb14:   ; preds = %lpad
   unreachable
 
 lpad:   ; preds = %entry
-        %lpad1 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+        %lpad1 = landingpad { i8*, i32 }
                   catch i8* null
   invoke void @__cxa_end_catch( )
       to label %bb14 unwind label %lpad17
 
 lpad17:   ; preds = %lpad
-        %lpad2 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+        %lpad2 = landingpad { i8*, i32 }
                   catch i8* null
   unreachable
 
 UnifiedUnreachableBlock:    ; preds = %entry
   unreachable
 }
 
 declare void @__cxa_throw(i8*, i8*, void (i8*)*) noreturn 
 
 declare void @__cxa_end_catch()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Generic/2009-11-16-BadKillsCrash.ll

 %"struct.std::locale::_Impl" = type { i32, %"struct.std::locale::facet"**, i32, %"struct.std::locale::facet"**, i8** }
 %"struct.std::locale::facet" = type { i32 (...)**, i32 }
 %union..0._15 = type { i32 }
 
 declare i8* @__cxa_begin_catch(i8*) nounwind
 
 declare %"struct.std::ctype<char>"* @_ZSt9use_facetISt5ctypeIcEERKT_RKSt6locale(%"struct.std::locale"*)
 
-define %"struct.std::basic_istream<char,std::char_traits<char> >"* @_ZStrsIcSt11char_traitsIcEERSt13basic_istreamIT_T0_ES6_PS3_(%"struct.std::basic_istream<char,std::char_traits<char> >"* %__in, i8* nocapture %__s) {
+define %"struct.std::basic_istream<char,std::char_traits<char> >"* @_ZStrsIcSt11char_traitsIcEERSt13basic_istreamIT_T0_ES6_PS3_(%"struct.std::basic_istream<char,std::char_traits<char> >"* %__in, i8* nocapture %__s) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %0 = invoke %"struct.std::ctype<char>"* @_ZSt9use_facetISt5ctypeIcEERKT_RKSt6locale(%"struct.std::locale"* undef)
           to label %invcont8 unwind label %lpad74 ; <%"struct.std::ctype<char>"*> [#uses=0]
 
 invcont8:                                         ; preds = %entry
   %1 = invoke i32 undef(%"struct.std::basic_streambuf<char,std::char_traits<char> >"* undef)
           to label %bb26.preheader unwind label %lpad ; <i32> [#uses=0]
 
invcont25:                                        ; preds = %bb.i93, %_ZNSt15basic_streambufIcSt11char_traitsIcEE6sbumpcEv.exit.i
   br label %invcont38
 
 invcont38:                                        ; preds = %invcont25, %bb1.i, %bb.i97, %bb26.preheader
   %__extracted.0 = phi i32 [ 0, %bb26.preheader ], [ undef, %invcont25 ], [ %2, %bb.i97 ], [ %2, %bb1.i ] ; <i32> [#uses=1]
   br i1 false, label %bb1.i100, label %invcont24
 
 lpad:                                             ; preds = %bb.i93, %invcont24, %bb1.i, %invcont8
   %__extracted.1 = phi i32 [ 0, %invcont8 ], [ %2, %bb1.i ], [ undef, %bb.i93 ], [ undef, %invcont24 ] ; <i32> [#uses=0]
-  %lpad1 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpad1 = landingpad { i8*, i32 }
             catch i8* null
   %eh_ptr = extractvalue { i8*, i32 } %lpad1, 0
   %6 = call i8* @__cxa_begin_catch(i8* %eh_ptr) nounwind ; <i8*> [#uses=0]
   unreachable
 
 lpad74:                                           ; preds = %entry
-  %lpad2 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpad2 = landingpad { i8*, i32 }
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Generic/donothing.ll

 ; RUN: llc < %s | FileCheck %s
 
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
 declare void @llvm.donothing() readnone
 
 ; CHECK: f1
-define void @f1() nounwind uwtable ssp {
+define void @f1() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK-NOT: donothing
   invoke void @llvm.donothing()
   to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @__cxa_call_unexpected(i8* %1) noreturn nounwind
   unreachable
 }
 
 ; CHECK: f2
 define void @f2() nounwind {
 entry:
 ; CHECK-NOT: donothing
   call void @llvm.donothing()
   ret void
 }

llvm/trunk/test/CodeGen/Generic/exception-handling.ll

 ; RUN: llc < %s
 ; PR10733
 declare void @_Znam()
 
-define void @_ZNK14gIndexOdometer15AfterExcisionOfERi() uwtable align 2 {
+define void @_ZNK14gIndexOdometer15AfterExcisionOfERi() uwtable align 2 personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 _ZN6Gambit5ArrayIiEC2Ej.exit36:
   br label %"9"
 
 "9":                                              ; preds = %"10", %_ZN6Gambit5ArrayIiEC2Ej.exit36
   %indvar82 = phi i64 [ 0, %_ZN6Gambit5ArrayIiEC2Ej.exit36 ], [ %tmp85, %"10" ]
   %tmp85 = add i64 %indvar82, 1
   %tmp = trunc i64 %tmp85 to i32
   invoke void @_ZNK14gIndexOdometer9NoIndicesEv()
           to label %"10" unwind label %lpad27
 
 "10":                                             ; preds = %"9"
   invoke void @_Znam()
           to label %"9" unwind label %lpad27
 
 lpad27:                                           ; preds = %"10", %"9"
   %0 = phi i32 [ undef, %"9" ], [ %tmp, %"10" ]
-  %1 = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %1 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } zeroinitializer
 }
 
 declare void @_ZNK14gIndexOdometer9NoIndicesEv()
 
 declare i32 @__gxx_personality_v0(i32, i64, i8*, i8*)

llvm/trunk/test/CodeGen/Generic/multiple-return-values-cross-block-with-invoke.ll

 ; RUN: llc < %s
 ; XFAIL: hexagon
 declare { i64, double } @wild()
 
-define void @foo(i64* %p, double* %q) nounwind {
+define void @foo(i64* %p, double* %q) nounwind personality i32 (...)* @__gxx_personality_v0 {
         %t = invoke { i64, double } @wild() to label %normal unwind label %handler
 
 normal:
         %mrv_gr = extractvalue { i64, double } %t, 0
         store i64 %mrv_gr, i64* %p
         %mrv_gr12681 = extractvalue { i64, double } %t, 1   
         store double %mrv_gr12681, double* %q
   ret void
   
 handler:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/Mips/eh.ll

 ; RUN: llc  < %s -march=mipsel | FileCheck %s -check-prefix=CHECK-EL
 ; RUN: llc  < %s -march=mips   | FileCheck %s -check-prefix=CHECK-EB
 
 @g1 = global double 0.000000e+00, align 8
 @_ZTId = external constant i8*
 
-define void @_Z1fd(double %i2) {
+define void @_Z1fd(double %i2) personality i32 (...)* @__gxx_personality_v0 {
 entry:
 ; CHECK-EL:  addiu $sp, $sp
 ; CHECK-EL:  .cfi_def_cfa_offset
 ; CHECK-EL:  sdc1 $f20
 ; CHECK-EL:  sw  $ra
 ; CHECK-EL:  .cfi_offset 52, -8
 ; CHECK-EL:  .cfi_offset 53, -4
 ; CHECK-EB:  .cfi_offset 53, -8
 ; CHECK-EB:  .cfi_offset 52, -4
 ; CHECK-EL:  .cfi_offset 31, -12
 
   %exception = tail call i8* @__cxa_allocate_exception(i32 8) nounwind
   %0 = bitcast i8* %exception to double*
   store double 3.200000e+00, double* %0, align 8
   invoke void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTId to i8*), i8* null) noreturn
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
 ; CHECK-EL:  # %lpad
 ; CHECK-EL:  bne $5
 
-  %exn.val = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %exn.val = landingpad { i8*, i32 }
            cleanup
            catch i8* bitcast (i8** @_ZTId to i8*)
   %exn = extractvalue { i8*, i32 } %exn.val, 0
   %sel = extractvalue { i8*, i32 } %exn.val, 1
   %1 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTId to i8*)) nounwind
   %2 = icmp eq i32 %sel, %1
   br i1 %2, label %catch, label %eh.resume
 

llvm/trunk/test/CodeGen/Mips/ehframe-indirect.ll

 ; RUN: llc -mtriple=mipsel-linux-gnu < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=O32 %s
 ; RUN: llc -mtriple=mipsel-linux-android < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=O32 %s
 ; RUN: llc -mtriple=mips64el-linux-gnu -target-abi=n32 < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=N32 %s
 ; RUN: llc -mtriple=mips64el-linux-android -target-abi=n32 < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=N32 %s
 ; RUN: llc -mtriple=mips64el-linux-gnu < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=N64 %s
 ; RUN: llc -mtriple=mips64el-linux-android < %s -asm-verbose | FileCheck -check-prefix=ALL -check-prefix=N64 %s
 
 @_ZTISt9exception = external constant i8*
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; ALL: .cfi_startproc
 ; ALL: .cfi_personality 128, DW.ref.__gxx_personality_v0
 
 entry:
   invoke void @foo() to label %cont unwind label %lpad
 ; ALL: foo
 ; ALL: jalr
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8*
-    bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
     catch i8* null
     catch i8* bitcast (i8** @_ZTISt9exception to i8*)
   ret i32 0
 
 cont:
   ret i32 0
 }
 ; ALL: .cfi_endproc

llvm/trunk/test/CodeGen/Mips/insn-zero-size-bb.ll

 ; RUN: llc < %s -march=mips -mcpu=mips32 | FileCheck %s
 ; RUN: llc < %s -march=mips -mcpu=mips32r3 -mattr=+micromips | FileCheck %s
 ; RUN: llc < %s -march=mips -mcpu=mips16 | FileCheck %s
 
 ; Verify that we emit the .insn directive for zero-sized (empty) basic blocks.
 ; This only really matters for microMIPS and MIPS16.
 
 declare i32 @foo(...)
 declare void @bar()
 
-define void @main() {
+define void @main() personality i8* bitcast (i32 (...)* @foo to i8*) {
 entry:
   invoke void @bar() #0
           to label %unreachable unwind label %return
 
 unreachable:
 ; CHECK:          ${{.*}}: # %unreachable
 ; CHECK-NEXT:         .insn
   unreachable
 
 return:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @foo to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret void
 }
 
 attributes #0 = { noreturn }

llvm/trunk/test/CodeGen/Mips/mips16ex.ll

 ; RUN: llc  -march=mipsel -mcpu=mips16 -relocation-model=pic -O3 < %s | FileCheck %s -check-prefix=16
 
 ;16: main:
 ;16-NEXT: [[TMP:.*]]:
 ;16-NEXT: $func_begin0 = ([[TMP]])
 ;16-NEXT: .cfi_startproc
 ;16-NEXT: .cfi_personality
 @.str = private unnamed_addr constant [7 x i8] c"hello\0A\00", align 1
 @_ZTIi = external constant i8*
 @.str1 = private unnamed_addr constant [15 x i8] c"exception %i \0A\00", align 1
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %retval = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   store i32 0, i32* %retval
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0))
   %exception = call i8* @__cxa_allocate_exception(i32 4) nounwind
   %0 = bitcast i8* %exception to i32*
   store i32 20, i32* %0
   invoke void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) noreturn
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   br label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %lpad

 invoke.cont:                                      ; preds = %catch
   call void @__cxa_end_catch() nounwind
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont
   ret i32 0
 
 lpad1:                                            ; preds = %catch
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %8 = landingpad { i8*, i32 }
           cleanup
   %9 = extractvalue { i8*, i32 } %8, 0
   store i8* %9, i8** %exn.slot
   %10 = extractvalue { i8*, i32 } %8, 1
   store i32 %10, i32* %ehselector.slot
   call void @__cxa_end_catch() nounwind
   br label %eh.resume
 

llvm/trunk/test/CodeGen/PowerPC/2007-11-16-landingpad-split.ll

 ; CHECK: .cfi_def_cfa_register r31
 ; CHECK: .cfi_offset r27, -16
 ; CHECK: .cfi_offset r28, -24
 ; CHECK: .cfi_offset r29, -32
 ; CHECK: .cfi_offset r30, -40
 ; CHECK: .cfi_endproc
 
 
-define void @Bork(i64 %range.0.0, i64 %range.0.1, i64 %size) {
+define void @Bork(i64 %range.0.0, i64 %range.0.1, i64 %size) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %effectiveRange = alloca %struct.Range, align 8    ; <%struct.Range*> [#uses=2]
   %tmp4 = call i8* @llvm.stacksave()    ; <i8*> [#uses=1]
   %size1 = trunc i64 %size to i32   ; <i32> [#uses=1]
   %tmp17 = alloca i8*, i32 %size1   ; <i8**> [#uses=1]
   invoke void @Foo(i8** %tmp17)
       to label %bb30.preheader unwind label %unwind
 
 bb30.preheader:   ; preds = %entry
   %tmp26 = getelementptr %struct.Range, %struct.Range* %effectiveRange, i64 0, i32 1    ; <i64*> [#uses=1]
   br label %bb30
 
 unwind:   ; preds = %cond_true, %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   call void @llvm.stackrestore(i8* %tmp4)
         resume { i8*, i32 } %exn
 
 invcont23:    ; preds = %cond_true
   %tmp27 = load i64, i64* %tmp26, align 8    ; <i64> [#uses=1]
   %tmp28 = sub i64 %range_addr.1.0, %tmp27    ; <i64> [#uses=1]
   br label %bb30

llvm/trunk/test/CodeGen/PowerPC/extra-toc-reg-deps.ll

 %"class.Foam::VectorSpace.10" = type { [3 x double] }
 %"class.Foam::Ostream.189" = type <{ %"class.Foam::IOstream.8", i16, [6 x i8] }>
 
 @_ZN4Foam4InfoE = external global %"class.Foam::messageStream.6", align 8
 @.str27 = external unnamed_addr constant [24 x i8], align 1
 @.str28 = external unnamed_addr constant [7 x i8], align 1
 @_ZN4Foam4PoutE = external global %"class.Foam::prefixOSstream.27", align 8
 
-define void @_ZN4Foam13checkTopologyERKNS_8polyMeshEbb(i1 zeroext %allTopology) #0 {
+define void @_ZN4Foam13checkTopologyERKNS_8polyMeshEbb(i1 zeroext %allTopology) #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br i1 undef, label %for.body, label %for.cond.cleanup
 
 ; CHECK-LABEL: @_ZN4Foam13checkTopologyERKNS_8polyMeshEbb
 
 ; CHECK: addis [[REG1:[0-9]+]], 2, .LC0@toc@ha
 ; CHECK: std 2, 40(1)
 ; CHECK: ld {{[0-9]+}}, .LC0@toc@l([[REG1]])

 for.body.i1504:                                   ; preds = %_ZNK4Foam8ZoneMeshINS_8faceZoneENS_8polyMeshEE15checkDefinitionEb.exit
   unreachable
 
 _ZNK4Foam8ZoneMeshINS_9pointZoneENS_8polyMeshEE15checkDefinitionEb.exit: ; preds = %_ZNK4Foam8ZoneMeshINS_8faceZoneENS_8polyMeshEE15checkDefinitionEb.exit
   invoke void @_ZN4Foam4word12stripInvalidEv()
           to label %_ZN4Foam4wordC2EPKcb.exit unwind label %lpad.i
 
 lpad.i:                                           ; preds = %_ZNK4Foam8ZoneMeshINS_9pointZoneENS_8polyMeshEE15checkDefinitionEb.exit
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } %0
 
 _ZN4Foam4wordC2EPKcb.exit:                        ; preds = %_ZNK4Foam8ZoneMeshINS_9pointZoneENS_8polyMeshEE15checkDefinitionEb.exit
   invoke void @_ZN4Foam7cellSetC1ERKNS_8polyMeshERKNS_4wordEiNS_8IOobject11writeOptionE()
           to label %invoke.cont59 unwind label %lpad
 
 invoke.cont59:                                    ; preds = %_ZN4Foam4wordC2EPKcb.exit

 
 _ZNSsD2Ev.exit:                                   ; preds = %if.then4.i.i, %_ZN9__gnu_cxxL27__exchange_and_add_dispatchEPii.exit.i.i, %invoke.cont59
   br i1 undef, label %for.body70, label %for.cond.cleanup69
 
 for.cond.cleanup69:                               ; preds = %_ZNSsD2Ev.exit
   br i1 undef, label %if.then121, label %if.else
 
 lpad:                                             ; preds = %_ZN4Foam4wordC2EPKcb.exit
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   br i1 undef, label %_ZNSsD2Ev.exit1578, label %if.then.i.i1570, !prof !1
 
 if.then.i.i1570:                                  ; preds = %lpad
   br i1 undef, label %if.then4.i.i1577, label %_ZNSsD2Ev.exit1578
 
 if.then4.i.i1577:                                 ; preds = %if.then.i.i1570
   unreachable
 
 _ZNSsD2Ev.exit1578:                               ; preds = %if.then.i.i1570, %lpad
   unreachable
 
 for.body70:                                       ; preds = %_ZNSsD2Ev.exit
   unreachable
 
 if.then121:                                       ; preds = %for.cond.cleanup69
   unreachable
 
 if.else:                                          ; preds = %for.cond.cleanup69
   invoke void @_ZN4Foam4word12stripInvalidEv()
           to label %_ZN4Foam4wordC2EPKcb.exit1701 unwind label %lpad.i1689
 
 lpad.i1689:                                       ; preds = %if.else
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 _ZN4Foam4wordC2EPKcb.exit1701:                    ; preds = %if.else
   invoke void @_ZN4Foam8pointSetC1ERKNS_8polyMeshERKNS_4wordEiNS_8IOobject11writeOptionE()
           to label %invoke.cont169 unwind label %lpad165
 
 invoke.cont169:                                   ; preds = %_ZN4Foam4wordC2EPKcb.exit1701
   %call177 = invoke zeroext i1 undef(%"class.Foam::primitiveMesh.135"* undef, i1 zeroext true, %"class.Foam::HashSet.127"* undef)
           to label %invoke.cont176 unwind label %lpad175
 
 invoke.cont176:                                   ; preds = %invoke.cont169
   br i1 %call177, label %if.then178, label %if.end213
 
 if.then178:                                       ; preds = %invoke.cont176
   unreachable
 
 lpad165:                                          ; preds = %_ZN4Foam4wordC2EPKcb.exit1701
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad175:                                          ; preds = %invoke.cont169
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   invoke void @_ZN4Foam8pointSetD1Ev()
           to label %eh.resume unwind label %terminate.lpad
 
 if.end213:                                        ; preds = %invoke.cont176
   invoke void @_ZN4Foam4word12stripInvalidEv()
           to label %_ZN4Foam4wordC2EPKcb.exit1777 unwind label %lpad.i1765
 
 lpad.i1765:                                       ; preds = %if.end213
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           cleanup
   br i1 undef, label %eh.resume.i1776, label %if.then.i.i.i1767, !prof !1
 
 if.then.i.i.i1767:                                ; preds = %lpad.i1765
   unreachable
 
 eh.resume.i1776:                                  ; preds = %lpad.i1765
   resume { i8*, i32 } %5
_ZNSsD2Ev.exit1792:                               ; preds = %if.then4.i.i1791, %if.then.i.i1784, %invoke.cont221
   %call232 = invoke zeroext i1 undef(%"class.Foam::primitiveMesh.135"* undef, i1 zeroext true, %"class.Foam::HashSet.127"* undef)
           to label %invoke.cont231 unwind label %lpad230
 
 invoke.cont231:                                   ; preds = %_ZNSsD2Ev.exit1792
   invoke void @_ZN4Foam6reduceIiNS_5sumOpIiEEEEvRKNS_4ListINS_8UPstream11commsStructEEERT_RKT0_ii()
           to label %invoke.cont243 unwind label %lpad230
 
 lpad217:                                          ; preds = %_ZN4Foam4wordC2EPKcb.exit1777
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %6 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 lpad230:                                          ; preds = %invoke.cont231, %_ZNSsD2Ev.exit1792
-  %7 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %7 = landingpad { i8*, i32 }
           cleanup
   invoke void @_ZN4Foam7faceSetD1Ev()
           to label %eh.resume unwind label %terminate.lpad
 
 invoke.cont243:                                   ; preds = %invoke.cont231
   invoke void @_ZN4Foam4word12stripInvalidEv()
           to label %_ZN4Foam4wordC2EPKcb.exit1862 unwind label %lpad.i1850
 
 lpad.i1850:                                       ; preds = %invoke.cont243
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %8 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 _ZN4Foam4wordC2EPKcb.exit1862:                    ; preds = %invoke.cont243
   invoke void @_ZN4Foam7faceSetC1ERKNS_8polyMeshERKNS_4wordEiNS_8IOobject11writeOptionE()
           to label %invoke.cont280 unwind label %lpad276
 
 invoke.cont280:                                   ; preds = %_ZN4Foam4wordC2EPKcb.exit1862
   br i1 undef, label %_ZNSsD2Ev.exit1877, label %if.then.i.i1869, !prof !1
 
 if.then.i.i1869:                                  ; preds = %invoke.cont280
   unreachable
 
 _ZNSsD2Ev.exit1877:                               ; preds = %invoke.cont280
   br i1 undef, label %if.then292, label %if.end328
 
 if.then292:                                       ; preds = %_ZNSsD2Ev.exit1877
   unreachable
 
 lpad276:                                          ; preds = %_ZN4Foam4wordC2EPKcb.exit1862
-  %9 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %9 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 if.end328:                                        ; preds = %_ZNSsD2Ev.exit1877
   br i1 %allTopology, label %if.then331, label %if.end660
 
 if.then331:                                       ; preds = %if.end328
   unreachable
invoke.cont674:                                   ; preds = %invoke.cont670
   %call677 = invoke dereferenceable(56) %"class.Foam::Ostream.189"* @_ZN4FoamlsERNS_7OstreamEPKc()
           to label %invoke.cont676 unwind label %lpad663
 
 invoke.cont676:                                   ; preds = %invoke.cont674
   invoke void undef(%"class.Foam::Ostream.189"* %call677)
           to label %if.end878 unwind label %lpad663
 
 lpad663:                                          ; preds = %invoke.cont670, %if.end660, %invoke.cont668, %invoke.cont674, %invoke.cont676
-  %10 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %10 = landingpad { i8*, i32 }
           cleanup
   br i1 undef, label %_ZN4Foam4ListIiED2Ev.exit.i3073, label %delete.notnull.i.i3071
 
 if.end878:                                        ; preds = %invoke.cont676
   br i1 undef, label %_ZN4Foam11regionSplitD2Ev.exit, label %delete.notnull.i.i3056
 
 delete.notnull.i.i3056:                           ; preds = %if.end878
   unreachable
_ZN4Foam4ListIiED2Ev.exit.i3073:                  ; preds = %lpad663
   invoke void @_ZN4Foam11regIOobjectD2Ev()
           to label %eh.resume unwind label %terminate.lpad
 
 if.else888:                                       ; preds = %_ZN4Foam11regionSplitD2Ev.exit
   invoke void @_ZN4Foam4word12stripInvalidEv()
           to label %_ZN4Foam4wordC2EPKcb.exit3098 unwind label %lpad.i3086
 
 lpad.i3086:                                       ; preds = %if.else888
-  %11 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %11 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 _ZN4Foam4wordC2EPKcb.exit3098:                    ; preds = %if.else888
   invoke void @_ZN4Foam8pointSetC1ERKNS_8polyMeshERKNS_4wordEiNS_8IOobject11writeOptionE()
           to label %invoke.cont902 unwind label %lpad898
 
 invoke.cont902:                                   ; preds = %_ZN4Foam4wordC2EPKcb.exit3098

 call.i3116.noexc:                                 ; preds = %_ZNSsD2Ev.exit3113
   %call5.i3118 = invoke zeroext i32 null(%"class.Foam::IOstream.8"* getelementptr inbounds (%"class.Foam::prefixOSstream.27", %"class.Foam::prefixOSstream.27"* @_ZN4Foam4PoutE, i64 0, i32 0, i32 0, i32 0), i32 zeroext undef)
           to label %invoke.cont906 unwind label %lpad905.loopexit.split-lp
 
 invoke.cont906:                                   ; preds = %call.i3116.noexc
   unreachable
 
 lpad898:                                          ; preds = %_ZN4Foam4wordC2EPKcb.exit3098
-  %12 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %12 = landingpad { i8*, i32 }
           cleanup
   br i1 undef, label %_ZNSsD2Ev.exit3204, label %if.then.i.i3196, !prof !1
 
 if.then.i.i3196:                                  ; preds = %lpad898
   unreachable
 
 _ZNSsD2Ev.exit3204:                               ; preds = %lpad898
   unreachable
 
 lpad905.loopexit.split-lp:                        ; preds = %call.i3116.noexc, %_ZNSsD2Ev.exit3113
-  %lpad.loopexit.split-lp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %lpad.loopexit.split-lp = landingpad { i8*, i32 }
           cleanup
   invoke void @_ZN4Foam8pointSetD1Ev()
           to label %eh.resume unwind label %terminate.lpad
 
 eh.resume:                                        ; preds = %_ZN4Foam4ListIiED2Ev.exit.i3073, %lpad230, %lpad175, %lpad905.loopexit.split-lp, %lpad217
   resume { i8*, i32 } undef
 
 terminate.lpad:                                   ; preds = %_ZN4Foam4ListIiED2Ev.exit.i3073, %lpad230, %lpad175, %lpad905.loopexit.split-lp
-  %13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %13 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 declare dereferenceable(56) %"class.Foam::Ostream.189"* @_ZN4FoamlsERNS_7OstreamEPKc() #0
 
 declare void @_ZN4Foam13messageStreamcvRNS_8OSstreamEEv() #0
 

llvm/trunk/test/CodeGen/PowerPC/fast-isel-icmp-split.ll

 ; RUN: llc -O0 -relocation-model=pic < %s | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-bgq-linux"
 
 %"class.std::__1::__tree_node.130.151" = type { %"class.std::__1::__tree_node_base.base.128.149", %"class.boost::serialization::extended_type_info.129.150"* }
 %"class.std::__1::__tree_node_base.base.128.149" = type <{ %"class.std::__1::__tree_end_node.127.148", %"class.std::__1::__tree_node_base.126.147"*, %"class.std::__1::__tree_node_base.126.147"*, i8 }>
 %"class.std::__1::__tree_end_node.127.148" = type { %"class.std::__1::__tree_node_base.126.147"* }
 %"class.std::__1::__tree_node_base.126.147" = type <{ %"class.std::__1::__tree_end_node.127.148", %"class.std::__1::__tree_node_base.126.147"*, %"class.std::__1::__tree_node_base.126.147"*, i8, [7 x i8] }>
 %"class.boost::serialization::extended_type_info.129.150" = type { i32 (...)**, i32, i8* }
 
 ; Function Attrs: noinline
-define void @_ZN5boost13serialization18extended_type_info4findEPKc() #0 align 2 {
+define void @_ZN5boost13serialization18extended_type_info4findEPKc() #0 align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br i1 undef, label %cond.true, label %cond.false
 
 ; CHECK: @_ZN5boost13serialization18extended_type_info4findEPKc
 
 cond.true:                                        ; preds = %entry
   br label %cond.end
 

 
 invoke.cont.2:                                    ; preds = %invoke.cont
   br i1 %cmp.i, label %if.then, label %if.end
 
 if.then:                                          ; preds = %invoke.cont.2
   br label %cleanup
 
 lpad:                                             ; preds = %cond.end
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 if.end:                                           ; preds = %invoke.cont.2
   br label %invoke.cont.4
 
 invoke.cont.4:                                    ; preds = %if.end
   br label %cleanup

llvm/trunk/test/CodeGen/PowerPC/glob-comp-aa-crash.ll

 %"class.std::__1::condition_variable" = type { %union.pthread_cond_t }
 %union.pthread_cond_t = type { %struct.anon }
 %struct.anon = type { i32, i32, i64, i64, i64, i8*, i32, i32 }
 %"class.std::__1::unique_lock" = type { %"class.std::__1::mutex"*, i8 }
 
 declare i32 @__gxx_personality_v0(...)
 
 ; Function Attrs: optsize
-define void @_ZNSt3__117__assoc_sub_state4copyEv(%"class.std::__1::__assoc_sub_state"* %this) #0 align 2 {
+define void @_ZNSt3__117__assoc_sub_state4copyEv(%"class.std::__1::__assoc_sub_state"* %this) #0 align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %__lk = alloca %"class.std::__1::unique_lock", align 8
   %ref.tmp = alloca %"class.std::__exception_ptr::exception_ptr", align 8
   %tmp = alloca { i64, i64 }, align 8
   %agg.tmp = alloca %"class.std::__exception_ptr::exception_ptr", align 8
   %__mut_ = getelementptr inbounds %"class.std::__1::__assoc_sub_state", %"class.std::__1::__assoc_sub_state"* %this, i64 0, i32 2
   %__m_.i.i = getelementptr inbounds %"class.std::__1::unique_lock", %"class.std::__1::unique_lock"* %__lk, i64 0, i32 0
   store %"class.std::__1::mutex"* %__mut_, %"class.std::__1::mutex"** %__m_.i.i, align 8, !tbaa !5
if.then:                                          ; preds = %invoke.cont
   call void @_ZNSt15__exception_ptr13exception_ptrC1ERKS0_(%"class.std::__exception_ptr::exception_ptr"* %agg.tmp, %"class.std::__exception_ptr::exception_ptr"* %__exception_) #5
   invoke void @_ZSt17rethrow_exceptionNSt15__exception_ptr13exception_ptrE(%"class.std::__exception_ptr::exception_ptr"* %agg.tmp) #6
           to label %invoke.cont4 unwind label %lpad3
 
 invoke.cont4:                                     ; preds = %if.then
   unreachable
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   %2 = extractvalue { i8*, i32 } %1, 0
   %3 = extractvalue { i8*, i32 } %1, 1
   br label %ehcleanup
 
 lpad3:                                            ; preds = %if.then
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   %5 = extractvalue { i8*, i32 } %4, 0
   %6 = extractvalue { i8*, i32 } %4, 1
   call void @_ZNSt15__exception_ptr13exception_ptrD1Ev(%"class.std::__exception_ptr::exception_ptr"* %agg.tmp) #5
   br label %ehcleanup
 
 if.end:                                           ; preds = %invoke.cont
   %7 = load i8, i8* %__owns_.i.i, align 8, !tbaa !6, !range !4

llvm/trunk/test/CodeGen/PowerPC/pr18663-2.ll

 
 declare void @_ZN4Foam7IOerrorclEPKcS2_iRKNS_8IOstreamE() #0
 
 declare void @_ZN4Foam7IOerror4exitEi() #0
 
 ; Function Attrs: inlinehint
 declare void @_ZN4Foam8fileName12stripInvalidEv() #2 align 2
 
-define void @_ZN4Foam3CSVINS_6VectorIdEEE4readEv() #0 align 2 {
+define void @_ZN4Foam3CSVINS_6VectorIdEEE4readEv() #0 align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_ZN4Foam6string6expandEb()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br i1 undef, label %if.then.i.i.i.i176, label %_ZN4Foam6stringC2ERKS0_.exit.i
 
 if.then.i.i.i.i176:                               ; preds = %invoke.cont
   invoke void @_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv()
           to label %.noexc unwind label %lpad
 
 .noexc:                                           ; preds = %if.then.i.i.i.i176
   unreachable
 
 _ZN4Foam6stringC2ERKS0_.exit.i:                   ; preds = %invoke.cont
   invoke void @_ZN4Foam8fileName12stripInvalidEv()
           to label %invoke.cont2 unwind label %lpad.i
 
 lpad.i:                                           ; preds = %_ZN4Foam6stringC2ERKS0_.exit.i
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 invoke.cont2:                                     ; preds = %_ZN4Foam6stringC2ERKS0_.exit.i
   invoke void @_ZN4Foam8IFstreamC1ERKNS_8fileNameENS_8IOstream12streamFormatENS4_13versionNumberE()
           to label %invoke.cont4 unwind label %lpad3
 
 invoke.cont4:                                     ; preds = %invoke.cont2
   br i1 undef, label %for.body, label %if.then
 
 if.then:                                          ; preds = %invoke.cont4
   invoke void @_ZN4Foam7IOerrorclEPKcS2_iRKNS_8IOstreamE()
           to label %invoke.cont8 unwind label %lpad5
 
 invoke.cont8:                                     ; preds = %if.then
   invoke void @_ZN4FoamlsERNS_7OstreamEPKc()
           to label %memptr.end.i unwind label %lpad5
 
 memptr.end.i:                                     ; preds = %invoke.cont8
   invoke void @_ZN4Foam7IOerror4exitEi()
           to label %if.end unwind label %lpad5
 
 lpad:                                             ; preds = %if.then.i.i.i.i176, %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 lpad3:                                            ; preds = %invoke.cont2
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 lpad5:                                            ; preds = %memptr.end.i, %invoke.cont8, %if.then
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 if.end:                                           ; preds = %memptr.end.i
   br i1 undef, label %for.body, label %vector.body
 
 for.body:                                         ; preds = %if.end, %invoke.cont4
   invoke void @_ZNKSt3__18ios_base6getlocEv()
           to label %.noexc205 unwind label %lpad19
 
 .noexc205:                                        ; preds = %for.body
   invoke void @_ZNKSt3__16locale9use_facetERNS0_2idE()
           to label %invoke.cont.i.i.i unwind label %lpad.i.i.i
 
 invoke.cont.i.i.i:                                ; preds = %.noexc205
   unreachable
 
 lpad.i.i.i:                                       ; preds = %.noexc205
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 lpad19:                                           ; preds = %for.body
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup142
 
 vector.body:                                      ; preds = %vector.body, %if.end
   %vec.phi = phi <8 x i32> [ %10, %vector.body ], [ undef, %if.end ]
   %vec.phi1302 = phi <8 x i32> [ %11, %vector.body ], [ undef, %if.end ]
   %vec.phi1303 = phi <8 x i32> [ %12, %vector.body ], [ undef, %if.end ]
   %vec.phi1304 = phi <8 x i32> [ %13, %vector.body ], [ undef, %if.end ]

llvm/trunk/test/CodeGen/PowerPC/preincprep-invoke.ll

 ; RUN: llc -mcpu=pwr7 < %s | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 @.str1 = external unnamed_addr constant [1 x i8], align 1
 @.str2 = external unnamed_addr constant [39 x i8], align 1
 
 declare void @_ZN13CStdOutStreamlsEPKc()
 
 declare void @_ZN13CStdOutStream5FlushEv()
 
 declare i32 @__gxx_personality_v0(...)
 
-define void @_Z11GetPasswordP13CStdOutStreamb() {
+define void @_Z11GetPasswordP13CStdOutStreamb() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br label %for.cond.i.i
 
 for.cond.i.i:                                     ; preds = %for.cond.i.i, %entry
   br i1 undef, label %_ZN11CStringBaseIcEC2EPKc.exit.critedge, label %for.cond.i.i
 
 _ZN11CStringBaseIcEC2EPKc.exit.critedge:          ; preds = %for.cond.i.i
   invoke void @_ZN13CStdOutStreamlsEPKc()

 for.cond.i.i30:                                   ; preds = %for.cond.i.i30, %invoke.cont4
   %indvars.iv.i.i26 = phi i64 [ %indvars.iv.next.i.i29, %for.cond.i.i30 ], [ 0, %invoke.cont4 ]
   %arrayidx.i.i27 = getelementptr inbounds i8, i8* %call7, i64 %indvars.iv.i.i26
   %0 = load i8, i8* %arrayidx.i.i27, align 1
   %indvars.iv.next.i.i29 = add nuw nsw i64 %indvars.iv.i.i26, 1
   br label %for.cond.i.i30
 
 lpad:                                             ; preds = %invoke.cont4, %invoke.cont, %_ZN11CStringBaseIcEC2EPKc.exit.critedge
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 }
 
 declare i8* @getpass()
 

llvm/trunk/test/CodeGen/SPARC/exception.ll

 ; V9PIC:        .cfi_register 15, 31
 ; V9PIC:        .section .gcc_except_table
 ; V9PIC-NOT:    .section
 ; V9PIC:        .word %r_disp32(.L_ZTIi.DW.stub)
 ; V9PIC:        .data
 ; V9PIC: .L_ZTIi.DW.stub:
 ; V9PIC-NEXT:   .xword _ZTIi
 
-define i32 @main(i32 %argc, i8** nocapture readnone %argv) unnamed_addr #0 {
+define i32 @main(i32 %argc, i8** nocapture readnone %argv) unnamed_addr #0 personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 entry:
   %0 = icmp eq i32 %argc, 2
   %1 = tail call i8* @__cxa_allocate_exception(i32 4) #1
   br i1 %0, label %"3", label %"4"
 
 "3":                                              ; preds = %entry
   %2 = bitcast i8* %1 to i32*
   store i32 0, i32* %2, align 4

 ; <label>:5                                       ; preds = %"4"
   unreachable
 
 "5":                                              ; preds = %"13", %"11"
   %6 = phi i32 [ 2, %"13" ], [ 0, %"11" ]
   ret i32 %6
 
 "8":                                              ; preds = %"4", %"3"
-  %exc = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %exc = landingpad { i8*, i32 }
           catch %struct.__fundamental_type_info_pseudo* @_ZTIi
           catch %struct.__fundamental_type_info_pseudo* @_ZTIf
   %exc_ptr12 = extractvalue { i8*, i32 } %exc, 0
   %filter13 = extractvalue { i8*, i32 } %exc, 1
   %typeid = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%struct.__fundamental_type_info_pseudo* @_ZTIi to i8*))
   %7 = icmp eq i32 %filter13, %typeid
   br i1 %7, label %"11", label %8
 

llvm/trunk/test/CodeGen/Thumb/sjljehprepare-lower-vector.ll

 ; RUN: llc -mtriple=thumbv7-apple-ios < %s
 ; SjLjEHPrepare shouldn't crash when lowering vectors.
 
 target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n32-S32"
 target triple = "thumbv7-apple-ios"
 
-define i8* @foo(<4 x i32> %c) {
+define i8* @foo(<4 x i32> %c) personality i8* bitcast (i32 (...)* @baz to i8*) {
 entry:
   invoke void @bar ()
     to label %unreachable unwind label %handler
 
 unreachable:
   unreachable
 
 handler:
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @baz to i8*)
+  %tmp = landingpad { i8*, i32 }
   cleanup
   resume { i8*, i32 } undef
 }
 
 declare void @bar()
 declare i32 @baz(...)
 

llvm/trunk/test/CodeGen/Thumb2/constant-islands.ll

 declare i8* @_ZN13btConvexShapenwEm(i32) inlinehint ssp align 2
 
 declare void @_ZN13btConvexShapedlEPv(i8*) inlinehint ssp align 2
 
 declare %class.btCapsuleShape* @_ZN14btCapsuleShapeC1Eff(%class.btCapsuleShape*, float, float)
 
 declare %class.btMatrix3x3* @_ZN11btTransform8getBasisEv(%class.btTransform*) nounwind inlinehint ssp align 2
 
-define %class.RagDoll* @_ZN7RagDollC2EP15btDynamicsWorldRK9btVector3f(%class.RagDoll* %this, %class.btDynamicsWorld* %ownerWorld, %class.btVector3* %positionOffset, float %scale) unnamed_addr ssp align 2 {
+define %class.RagDoll* @_ZN7RagDollC2EP15btDynamicsWorldRK9btVector3f(%class.RagDoll* %this, %class.btDynamicsWorld* %ownerWorld, %class.btVector3* %positionOffset, float %scale) unnamed_addr ssp align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %retval = alloca %class.RagDoll*, align 4
   %this.addr = alloca %class.RagDoll*, align 4
   %ownerWorld.addr = alloca %class.btDynamicsWorld*, align 4
   %positionOffset.addr = alloca %class.btVector3*, align 4
   %scale.addr = alloca float, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32

 
 for.inc:                                          ; preds = %for.body
   %66 = load i32, i32* %i, align 4
   %inc = add nsw i32 %66, 1
   store i32 %inc, i32* %i, align 4
   br label %for.cond
 
 lpad:                                             ; preds = %entry
-  %67 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %67 = landingpad { i8*, i32 }
           cleanup
   %68 = extractvalue { i8*, i32 } %67, 0
   store i8* %68, i8** %exn.slot
   %69 = extractvalue { i8*, i32 } %67, 1
   store i32 %69, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call)
           to label %invoke.cont4 unwind label %terminate.lpad
 
 invoke.cont4:                                     ; preds = %lpad
   br label %eh.resume
 
 lpad8:                                            ; preds = %invoke.cont
-  %70 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %70 = landingpad { i8*, i32 }
           cleanup
   %71 = extractvalue { i8*, i32 } %70, 0
   store i8* %71, i8** %exn.slot
   %72 = extractvalue { i8*, i32 } %70, 1
   store i32 %72, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call5)
           to label %invoke.cont11 unwind label %terminate.lpad
 
 invoke.cont11:                                    ; preds = %lpad8
   br label %eh.resume
 
 lpad17:                                           ; preds = %invoke.cont9
-  %73 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %73 = landingpad { i8*, i32 }
           cleanup
   %74 = extractvalue { i8*, i32 } %73, 0
   store i8* %74, i8** %exn.slot
   %75 = extractvalue { i8*, i32 } %73, 1
   store i32 %75, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call14)
           to label %invoke.cont20 unwind label %terminate.lpad
 
 invoke.cont20:                                    ; preds = %lpad17
   br label %eh.resume
 
 lpad26:                                           ; preds = %invoke.cont18
-  %76 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %76 = landingpad { i8*, i32 }
           cleanup
   %77 = extractvalue { i8*, i32 } %76, 0
   store i8* %77, i8** %exn.slot
   %78 = extractvalue { i8*, i32 } %76, 1
   store i32 %78, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call23)
           to label %invoke.cont29 unwind label %terminate.lpad
 
 invoke.cont29:                                    ; preds = %lpad26
   br label %eh.resume
 
 lpad35:                                           ; preds = %invoke.cont27
-  %79 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %79 = landingpad { i8*, i32 }
           cleanup
   %80 = extractvalue { i8*, i32 } %79, 0
   store i8* %80, i8** %exn.slot
   %81 = extractvalue { i8*, i32 } %79, 1
   store i32 %81, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call32)
           to label %invoke.cont38 unwind label %terminate.lpad
 
 invoke.cont38:                                    ; preds = %lpad35
   br label %eh.resume
 
 lpad44:                                           ; preds = %invoke.cont36
-  %82 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %82 = landingpad { i8*, i32 }
           cleanup
   %83 = extractvalue { i8*, i32 } %82, 0
   store i8* %83, i8** %exn.slot
   %84 = extractvalue { i8*, i32 } %82, 1
   store i32 %84, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call41)
           to label %invoke.cont47 unwind label %terminate.lpad
 
 invoke.cont47:                                    ; preds = %lpad44
   br label %eh.resume
 
 lpad53:                                           ; preds = %invoke.cont45
-  %85 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %85 = landingpad { i8*, i32 }
           cleanup
   %86 = extractvalue { i8*, i32 } %85, 0
   store i8* %86, i8** %exn.slot
   %87 = extractvalue { i8*, i32 } %85, 1
   store i32 %87, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call50)
           to label %invoke.cont56 unwind label %terminate.lpad
 
 invoke.cont56:                                    ; preds = %lpad53
   br label %eh.resume
 
 lpad62:                                           ; preds = %invoke.cont54
-  %88 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %88 = landingpad { i8*, i32 }
           cleanup
   %89 = extractvalue { i8*, i32 } %88, 0
   store i8* %89, i8** %exn.slot
   %90 = extractvalue { i8*, i32 } %88, 1
   store i32 %90, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call59)
           to label %invoke.cont65 unwind label %terminate.lpad
 
 invoke.cont65:                                    ; preds = %lpad62
   br label %eh.resume
 
 lpad71:                                           ; preds = %invoke.cont63
-  %91 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %91 = landingpad { i8*, i32 }
           cleanup
   %92 = extractvalue { i8*, i32 } %91, 0
   store i8* %92, i8** %exn.slot
   %93 = extractvalue { i8*, i32 } %91, 1
   store i32 %93, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call68)
           to label %invoke.cont74 unwind label %terminate.lpad
 
 invoke.cont74:                                    ; preds = %lpad71
   br label %eh.resume
 
 lpad80:                                           ; preds = %invoke.cont72
-  %94 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %94 = landingpad { i8*, i32 }
           cleanup
   %95 = extractvalue { i8*, i32 } %94, 0
   store i8* %95, i8** %exn.slot
   %96 = extractvalue { i8*, i32 } %94, 1
   store i32 %96, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call77)
           to label %invoke.cont83 unwind label %terminate.lpad
 
 invoke.cont83:                                    ; preds = %lpad80
   br label %eh.resume
 
 lpad89:                                           ; preds = %invoke.cont81
-  %97 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %97 = landingpad { i8*, i32 }
           cleanup
   %98 = extractvalue { i8*, i32 } %97, 0
   store i8* %98, i8** %exn.slot
   %99 = extractvalue { i8*, i32 } %97, 1
   store i32 %99, i32* %ehselector.slot
   invoke void @_ZN13btConvexShapedlEPv(i8* %call86)
           to label %invoke.cont92 unwind label %terminate.lpad
 
invoke.cont517:                                   ; preds = %invoke.cont488
   %m_joints524 = getelementptr inbounds %class.RagDoll, %class.RagDoll* %this1, i32 0, i32 4
   %arrayidx525 = getelementptr inbounds [10 x %class.btTypedConstraint*], [10 x %class.btTypedConstraint*]* %m_joints524, i32 0, i32 9
   %199 = load %class.btTypedConstraint*, %class.btTypedConstraint** %arrayidx525, align 4
   call void %198(%class.btDynamicsWorld* %196, %class.btTypedConstraint* %199, i1 zeroext true)
   %200 = load %class.RagDoll*, %class.RagDoll** %retval
   ret %class.RagDoll* %200
 
 lpad258:                                          ; preds = %for.end
-  %201 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %201 = landingpad { i8*, i32 }
           cleanup
   %202 = extractvalue { i8*, i32 } %201, 0
   store i8* %202, i8** %exn.slot
   %203 = extractvalue { i8*, i32 } %201, 1
   store i32 %203, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call253) nounwind
   br label %eh.resume
 
 lpad284:                                          ; preds = %invoke.cont259
-  %204 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %204 = landingpad { i8*, i32 }
           cleanup
   %205 = extractvalue { i8*, i32 } %204, 0
   store i8* %205, i8** %exn.slot
   %206 = extractvalue { i8*, i32 } %204, 1
   store i32 %206, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call279) nounwind
   br label %eh.resume
 
 lpad313:                                          ; preds = %invoke.cont285
-  %207 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %207 = landingpad { i8*, i32 }
           cleanup
   %208 = extractvalue { i8*, i32 } %207, 0
   store i8* %208, i8** %exn.slot
   %209 = extractvalue { i8*, i32 } %207, 1
   store i32 %209, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call308) nounwind
   br label %eh.resume
 
 lpad342:                                          ; preds = %invoke.cont314
-  %210 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %210 = landingpad { i8*, i32 }
           cleanup
   %211 = extractvalue { i8*, i32 } %210, 0
   store i8* %211, i8** %exn.slot
   %212 = extractvalue { i8*, i32 } %210, 1
   store i32 %212, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call337) nounwind
   br label %eh.resume
 
 lpad371:                                          ; preds = %invoke.cont343
-  %213 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %213 = landingpad { i8*, i32 }
           cleanup
   %214 = extractvalue { i8*, i32 } %213, 0
   store i8* %214, i8** %exn.slot
   %215 = extractvalue { i8*, i32 } %213, 1
   store i32 %215, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call366) nounwind
   br label %eh.resume
 
 lpad400:                                          ; preds = %invoke.cont372
-  %216 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %216 = landingpad { i8*, i32 }
           cleanup
   %217 = extractvalue { i8*, i32 } %216, 0
   store i8* %217, i8** %exn.slot
   %218 = extractvalue { i8*, i32 } %216, 1
   store i32 %218, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call395) nounwind
   br label %eh.resume
 
 lpad429:                                          ; preds = %invoke.cont401
-  %219 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %219 = landingpad { i8*, i32 }
           cleanup
   %220 = extractvalue { i8*, i32 } %219, 0
   store i8* %220, i8** %exn.slot
   %221 = extractvalue { i8*, i32 } %219, 1
   store i32 %221, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call424) nounwind
   br label %eh.resume
 
 lpad458:                                          ; preds = %invoke.cont430
-  %222 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %222 = landingpad { i8*, i32 }
           cleanup
   %223 = extractvalue { i8*, i32 } %222, 0
   store i8* %223, i8** %exn.slot
   %224 = extractvalue { i8*, i32 } %222, 1
   store i32 %224, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call453) nounwind
   br label %eh.resume
 
 lpad487:                                          ; preds = %invoke.cont459
-  %225 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %225 = landingpad { i8*, i32 }
           cleanup
   %226 = extractvalue { i8*, i32 } %225, 0
   store i8* %226, i8** %exn.slot
   %227 = extractvalue { i8*, i32 } %225, 1
   store i32 %227, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call482) nounwind
   br label %eh.resume
 
 lpad516:                                          ; preds = %invoke.cont488
-  %228 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %228 = landingpad { i8*, i32 }
           cleanup
   %229 = extractvalue { i8*, i32 } %228, 0
   store i8* %229, i8** %exn.slot
   %230 = extractvalue { i8*, i32 } %228, 1
   store i32 %230, i32* %ehselector.slot
   call void @_ZdlPv(i8* %call511) nounwind
   br label %eh.resume
 
 eh.resume:                                        ; preds = %lpad516, %lpad487, %lpad458, %lpad429, %lpad400, %lpad371, %lpad342, %lpad313, %lpad284, %lpad258, %invoke.cont92, %invoke.cont83, %invoke.cont74, %invoke.cont65, %invoke.cont56, %invoke.cont47, %invoke.cont38, %invoke.cont29, %invoke.cont20, %invoke.cont11, %invoke.cont4
   %exn = load i8*, i8** %exn.slot
   %sel = load i32, i32* %ehselector.slot
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn, 0
   %lpad.val526 = insertvalue { i8*, i32 } %lpad.val, i32 %sel, 1
   resume { i8*, i32 } %lpad.val526
 
 terminate.lpad:                                   ; preds = %lpad89, %lpad80, %lpad71, %lpad62, %lpad53, %lpad44, %lpad35, %lpad26, %lpad17, %lpad8, %lpad
-  %231 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %231 = landingpad { i8*, i32 }
           catch i8* null
   call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 }
 
 declare void @_ZmlRKfRK9btVector3(%class.btVector3* noalias sret, float*, %class.btVector3*) inlinehint ssp
 
 declare %class.btRigidBody* @_ZN7RagDoll20localCreateRigidBodyEfRK11btTransformP16btCollisionShape(%class.RagDoll*, float, %class.btTransform*, %class.btCollisionShape*) ssp align 2

llvm/trunk/test/CodeGen/WinEH/cppeh-alloca-sink.ll

 
 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 @llvm.eh.handlertype.H.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 
 ; Function Attrs: uwtable
-define void @sink_alloca_to_catch() #0 {
+define void @sink_alloca_to_catch() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %0 = alloca i32
   %only_used_in_catch = alloca i32, align 4
   invoke void @may_throw()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
   %2 = extractvalue { i8*, i32 } %1, 1
   %3 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)) #3
   %matches = icmp eq i32 %2, %3
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
   %4 = extractvalue { i8*, i32 } %1, 0

 }
 
 ; CHECK-LABEL: define void @sink_alloca_to_catch()
 ; CHECK: call void (...) @llvm.frameescape(i32* %only_used_in_catch)
 
 declare void @use_catch_var(i32*) #1
 
 ; Function Attrs: uwtable
-define void @dont_sink_alloca_to_catch(i32 %n) #0 {
+define void @dont_sink_alloca_to_catch(i32 %n) #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %0 = alloca i32
   %n.addr = alloca i32, align 4
   %live_in_out_catch = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 %n, i32* %n.addr, align 4
   br label %while.cond
 
 while.cond:                                       ; preds = %try.cont, %entry
   %1 = load i32, i32* %n.addr, align 4
   %cmp = icmp sgt i32 %1, 0
   br i1 %cmp, label %while.body, label %while.end
 
 while.body:                                       ; preds = %while.cond
   invoke void @may_throw()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %while.body
   br label %try.cont
 
 lpad:                                             ; preds = %while.body
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
   %3 = extractvalue { i8*, i32 } %2, 0
   store i8* %3, i8** %exn.slot
   %4 = extractvalue { i8*, i32 } %2, 1
   store i32 %4, i32* %ehselector.slot
   br label %catch.dispatch
 
 catch.dispatch:                                   ; preds = %lpad

 try.cont:                                         ; preds = %invoke.cont2, %invoke.cont
   %6 = load i32, i32* %0
   %7 = load i32, i32* %n.addr, align 4
   %dec = add nsw i32 %7, -1
   store i32 %dec, i32* %n.addr, align 4
   br label %while.cond
 
 lpad1:                                            ; preds = %catch
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %8 = landingpad { i8*, i32 }
           cleanup
   %9 = extractvalue { i8*, i32 } %8, 0
   store i8* %9, i8** %exn.slot
   %10 = extractvalue { i8*, i32 } %8, 1
   store i32 %10, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #3
   br label %eh.resume
 

llvm/trunk/test/CodeGen/WinEH/cppeh-catch-all.ll

 
 ; The function entry in this case remains unchanged.
 ; CHECK: define void @_Z4testv()
 ; CHECK: entry:
 ; CHECK:   invoke void @_Z9may_throwv()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @_Z4testv() #0 {
+define void @_Z4testv() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* null
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @_Z4testv.catch)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont]
 
 lpad:                                             ; preds = %entry
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp = landingpad { i8*, i32 }
           catch i8* null
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   br label %catch
 
 ; CHECK-NOT: catch:

llvm/trunk/test/CodeGen/WinEH/cppeh-catch-and-throw.ll

 ; This is just a minimal check to verify that main was handled by WinEHPrepare.
 ; CHECK: define void @"\01?test@@YAXXZ"()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape
 ; CHECK:   invoke void @_CxxThrowException
 ; CHECK: }
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %o = alloca %class.Obj, align 1
   %tmp = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 1, i32* %tmp
   %0 = bitcast i32* %tmp to i8*
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #3
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   call void @"\01??1Obj@@QEAA@XZ"(%class.Obj* %o) #2
   br label %catch
 
 catch:                                            ; preds = %lpad
   %exn = load i8*, i8** %exn.slot
   call void @llvm.eh.begincatch(i8* %exn, i8* null) #2
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #3
           to label %unreachable unwind label %lpad1
 
 lpad1:                                            ; preds = %catch
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   %5 = extractvalue { i8*, i32 } %4, 0
   store i8* %5, i8** %exn.slot
   %6 = extractvalue { i8*, i32 } %4, 1
   store i32 %6, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 

 ; CHECK:   call i8* @llvm.framerecover
 ; CHECK:   call void @"\01??1Obj@@QEAA@XZ"
 ; CHECK:   invoke void @llvm.donothing()
 ; CHECK:           to label %[[SPLIT_LABEL:.+]] unwind label %[[LPAD_LABEL:.+]]
 ;
 ; CHECK: [[SPLIT_LABEL]]
 ;
 ; CHECK: [[LPAD_LABEL]]
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK:           cleanup
 ; CHECK:   unreachable
 ; CHECK: }
 
 declare void @_CxxThrowException(i8*, %eh.ThrowInfo*)
 
 declare i32 @__CxxFrameHandler3(...)
 

llvm/trunk/test/CodeGen/WinEH/cppeh-catch-scalar.ll

 ; CHECK: define void @_Z4testv()
 ; CHECK: entry:
 ; CHECK:   [[I_PTR:\%.+]] = alloca i32, align 4
 ; CHECK:   call void (...) @llvm.frameescape(i32* [[I_PTR]])
 ; CHECK:   invoke void @_Z9may_throwv()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @_Z4testv() #0 {
+define void @_Z4testv() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %i = alloca i32, align 4
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont]
 
 lpad:                                             ; preds = %entry
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   br label %catch.dispatch
 
 ; CHECK-NOT: catch-dispatch:

llvm/trunk/test/CodeGen/WinEH/cppeh-catch-unwind.ll

 %class.SomeClass = type { i8 }
 
 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 
 
-; CHECK-LABEL: define void @"\01?test@@YAXXZ"() #0 {
+; CHECK-LABEL: define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: entry:
 ; CHECK:   [[OBJ_PTR:\%.+]] = alloca %class.SomeClass
 ; CHECK:   [[TMP0:\%.+]] = alloca i32, align 4
 ; CHECK:   [[TMP1:\%.+]] = alloca i32, align 4
 ; CHECK:   call void (...) @llvm.frameescape(i32* [[TMP1]], %class.SomeClass* [[OBJ_PTR]], i32* [[TMP0]])
 ; CHECK:   %call = invoke %class.SomeClass* @"\01??0SomeClass@@QEAA@XZ"(%class.SomeClass* %obj)
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %obj = alloca %class.SomeClass, align 1
   %0 = alloca i32, align 4
   %1 = alloca i32, align 4
   %call = invoke %class.SomeClass* @"\01??0SomeClass@@QEAA@XZ"(%class.SomeClass* %obj)
           to label %invoke.cont unwind label %lpad
 
 ; CHECK: invoke.cont:
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
 
 invoke.cont:                                      ; preds = %entry
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont2 unwind label %lpad1
 
 ; CHECK: invoke.cont2:
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %try.cont unwind label %[[LPAD3_LABEL:lpad[0-9]*]]
 
 invoke.cont2:                                     ; preds = %invoke.cont
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %try.cont unwind label %lpad3
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont15]
 
 lpad:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %3 = extractvalue { i8*, i32 } %2, 0
   %4 = extractvalue { i8*, i32 } %2, 1
   br label %catch.dispatch7
 
 ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %invoke.cont
-; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER1]], [label %try.cont15]
 
 lpad1:                                            ; preds = %invoke.cont
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %5 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %6 = extractvalue { i8*, i32 } %5, 0
   %7 = extractvalue { i8*, i32 } %5, 1
   br label %ehcleanup
 
 ; CHECK: [[LPAD3_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
-; CHECK:   [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD3_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1", i32 0, void (i8*, i8*)* @"\01?test@@YAXXZ.cleanup")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont15]
 
 lpad3:                                            ; preds = %invoke.cont2
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %8 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %9 = extractvalue { i8*, i32 } %8, 0
   %10 = extractvalue { i8*, i32 } %8, 1
   %11 = call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #3
   %matches = icmp eq i32 %10, %11
   br i1 %matches, label %catch, label %ehcleanup
 
invoke.cont6:                                     ; preds = %catch
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %invoke.cont6
   call void @"\01??1SomeClass@@QEAA@XZ"(%class.SomeClass* %obj) #3
   br label %try.cont15
 
 ; CHECK-NOT: lpad5:
 lpad5:                                            ; preds = %catch
-  %13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %13 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %14 = extractvalue { i8*, i32 } %13, 0
   %15 = extractvalue { i8*, i32 } %13, 1
   call void @llvm.eh.endcatch() #3
   br label %ehcleanup
 
 ; CHECK-NOT: ehcleanup

 ; CHECK:   [[TMP0_PTR:\%.+]] = bitcast i8* [[RECOVER_TMP0]] to i32*
 ; CHECK:   invoke void @"\01?handle_exception@@YAXXZ"()
 ; CHECK:           to label %invoke.cont6 unwind label %[[LPAD5_LABEL:lpad[0-9]+]]
 ;
 ; CHECK: invoke.cont6:                                     ; preds = %entry
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ;
 ; CHECK: [[LPAD5_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   [[LPAD5_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD5_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK:           cleanup
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK: }
 
 declare %class.SomeClass* @"\01??0SomeClass@@QEAA@XZ"(%class.SomeClass* returned) #1
 
 declare i32 @__CxxFrameHandler3(...)
 

llvm/trunk/test/CodeGen/WinEH/cppeh-cleanup-invoke.ll

 %struct.HasDtor = type { i8 }
 
 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 @llvm.eh.handlertype.H.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %o = alloca %struct.HasDtor, align 1
   invoke void @may_throw()
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %invoke.cont
   call void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* %o)
   br label %try.cont
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   br label %catch.dispatch
 
 lpad1:                                            ; preds = %invoke.cont
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
   %4 = extractvalue { i8*, i32 } %3, 0
   %5 = extractvalue { i8*, i32 } %3, 1
   invoke void @"\01??1HasDtor@@QEAA@XZ"(%struct.HasDtor* %o)
     to label %catch.dispatch unwind label %lpad
 
 catch.dispatch:                                   ; preds = %lpad1, %lpad

llvm/trunk/test/CodeGen/WinEH/cppeh-demote-liveout.ll

 declare void @llvm.eh.begincatch(i8*, i8*)
 declare void @llvm.eh.endcatch()
 declare void @might_throw()
 declare i32 @__CxxFrameHandler3(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 
 @typeinfo.int = external global i32
 
-define i32 @liveout_catch(i32 %p) {
+define i32 @liveout_catch(i32 %p) personality i32 (...)* @__CxxFrameHandler3 {
 entry:
   %val.entry = add i32 %p, 1
   invoke void @might_throw()
       to label %ret unwind label %lpad
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__CxxFrameHandler3
+  %ehvals = landingpad { i8*, i32 }
       cleanup
       catch i32* @typeinfo.int
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %sel = extractvalue { i8*, i32 } %ehvals, 1
   %int_sel = call i32 @llvm.eh.typeid.for(i8* bitcast (i32* @typeinfo.int to i8*))
   %match = icmp eq i32 %sel, %int_sel
   br i1 %match, label %catchit, label %resume
 

llvm/trunk/test/CodeGen/WinEH/cppeh-frame-vars.ll

 ; CHECK:   store i32 0, i32* [[NUMEXCEPTIONS_PTR]], align 4
 ; CHECK:   [[TMP:\%.+]] = bitcast %struct.SomeData* [[DATA_PTR]] to i8*
 ; CHECK:   call void @llvm.memset(i8* [[TMP]], i8 0, i64 8, i32 4, i1 false)
 ; CHECK:   store i32 0, i32* [[I_PTR]], align 4
 ; CHECK:   call void (...) @llvm.frameescape(i32* [[E_PTR]], i32* [[NUMEXCEPTIONS_PTR]], [10 x i32]* [[EXCEPTIONVAL_PTR]], i32* [[I_PTR]], %struct.SomeData* [[DATA_PTR]])
 ; CHECK:   br label %for.cond
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %NumExceptions = alloca i32, align 4
   %ExceptionVal = alloca [10 x i32], align 16
   %Data = alloca %struct.SomeData, align 4
   %i = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
invoke.cont:                                      ; preds = %for.body
   %tmp2 = load i32, i32* %i, align 4
   %a = getelementptr inbounds %struct.SomeData, %struct.SomeData* %Data, i32 0, i32 0
   %tmp3 = load i32, i32* %a, align 4
   %add = add nsw i32 %tmp3, %tmp2
   store i32 %add, i32* %a, align 4
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %for.body
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont]
 
 lpad:                                             ; preds = %for.body
-  %tmp4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp4 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %tmp5 = extractvalue { i8*, i32 } %tmp4, 0
   store i8* %tmp5, i8** %exn.slot
   %tmp6 = extractvalue { i8*, i32 } %tmp4, 1
   store i32 %tmp6, i32* %ehselector.slot
   br label %catch.dispatch
 
 ; CHECK-NOT: catch.dispatch:

llvm/trunk/test/CodeGen/WinEH/cppeh-inalloca.ll

 ; CHECK:   store <{ %struct.A }>* %0, <{ %struct.A }>** [[TMP_REGMEM]]
 ; CHECK:   [[RETVAL:\%.+]] = alloca i32, align 4
 ; CHECK:   [[E_PTR:\%.+]] = alloca i32, align 4
 ; CHECK:   [[CLEANUP_SLOT:\%.+]] = alloca i32
 ; CHECK:   call void (...) @llvm.frameescape(i32* %e, <{ %struct.A }>** [[TMP_REGMEM]], i32* [[RETVAL]], i32* [[CLEANUP_SLOT]])
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
-define i32 @"\01?test@@YAHUA@@@Z"(<{ %struct.A }>* inalloca) #0 {
+define i32 @"\01?test@@YAHUA@@@Z"(<{ %struct.A }>* inalloca) #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %retval = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   %cleanup.dest.slot = alloca i32
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%recover.*]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAHUA@@@Z.catch", i32 0, void (i8*, i8*)* @"\01?test@@YAHUA@@@Z.cleanup")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %cleanup]
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   br label %catch.dispatch
 

llvm/trunk/test/CodeGen/WinEH/cppeh-min-unwind.ll

 ; CHECK: entry:
 ; CHECK:   [[OBJ_PTR:\%.+]] = alloca %class.SomeClass, align 4
 ; CHECK:   call void @_ZN9SomeClassC1Ev(%class.SomeClass* [[OBJ_PTR]])
 ; CHECK:   call void (...) @llvm.frameescape(%class.SomeClass* [[OBJ_PTR]])
 ; CHECK:   invoke void @_Z9may_throwv()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @_Z4testv() #0 {
+define void @_Z4testv() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %obj = alloca %class.SomeClass, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   call void @_ZN9SomeClassC1Ev(%class.SomeClass* %obj)
   invoke void @_Z9may_throwv()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   call void @_ZN9SomeClassD1Ev(%class.SomeClass* %obj)
   ret void
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @_Z4testv.cleanup)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], []
 
 lpad:                                             ; preds = %entry
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp = landingpad { i8*, i32 }
           cleanup
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   call void @_ZN9SomeClassD1Ev(%class.SomeClass* %obj)
   br label %eh.resume
 

llvm/trunk/test/CodeGen/WinEH/cppeh-mixed-catch-and-cleanup.ll

 ; This just verifies that the function was processed by WinEHPrepare.
 ;
 ; CHECK-LABEL: define void @"\01?test@@YAXXZ"()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape
 ; CHECK: }
 
 ; Function Attrs: nounwind uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %o = alloca %class.Obj, align 1
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   call void @"\01??1Obj@@QEAA@XZ"(%class.Obj* %o) #3
   br label %try.cont
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot
   call void @"\01??1Obj@@QEAA@XZ"(%class.Obj* %o) #3
   %exn = load i8*, i8** %exn.slot
   call void @llvm.eh.begincatch(i8* %exn, i8* null) #3

llvm/trunk/test/CodeGen/WinEH/cppeh-multi-catch.ll

 @__ImageBase = external constant i8
 @llvm.eh.handlermapentry.H = private unnamed_addr constant %eh.HandlerMapEntry { i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section "llvm.metadata"
 @"\01??_R0_J@8" = linkonce_odr global %rtti.TypeDescriptor3 { i8** @"\01??_7type_info@@6B@", i8* null, [4 x i8] c"._J\00" }, comdat
 @llvm.eh.handlermapentry._J = private unnamed_addr constant %eh.HandlerMapEntry { i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor3* @"\01??_R0_J@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section "llvm.metadata"
 @"\01??_R0?AVSomeClass@@@8" = linkonce_odr global %rtti.TypeDescriptor15 { i8** @"\01??_7type_info@@6B@", i8* null, [16 x i8] c".?AVSomeClass@@\00" }, comdat
 @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" = private unnamed_addr constant %eh.HandlerMapEntry { i32 8, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor15* @"\01??_R0?AVSomeClass@@@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section "llvm.metadata"
 
 
-; CHECK: define void @"\01?test@@YAXXZ"() #0 {
+; CHECK: define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 ; CHECK: entry:
 ; CHECK:   [[OBJ_PTR:\%.+]] = alloca %class.SomeClass*, align 8
 ; CHECK:   [[LL_PTR:\%.+]] = alloca i64, align 8
 ; CHECK:   [[I_PTR:\%.+]] = alloca i32, align 4
 ; CHECK:   call void (...) @llvm.frameescape(i32* [[I_PTR]], i64* [[LL_PTR]], %class.SomeClass** [[OBJ_PTR]])
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %obj = alloca %class.SomeClass*, align 8
   %ll = alloca i64, align 8
   %i = alloca i32, align 4
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H
 ; CHECK-NEXT:           catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J
 ; CHECK-NEXT:           catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@"
 ; CHECK-NEXT:           catch i8* null
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(
 ; CHECK-SAME:      i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry.H to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch",
 ; CHECK-SAME:        i32 1, i8* bitcast (%eh.HandlerMapEntry* @llvm.eh.handlermapentry._J to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1",
 ; CHECK-SAME:        i32 1, i8* bitcast (%eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.2",
 ; CHECK-SAME:        i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.3")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %ret]
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry.H
           catch %eh.HandlerMapEntry* @llvm.eh.handlermapentry._J
           catch %eh.HandlerMapEntry* @"llvm.eh.handlermapentry.reference.?AVSomeClass@@"
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-1.ll

 ; CHECK: entry:
 ; CHECK:   %i = alloca i32, align 4
 ; CHECK:   %f = alloca float, align 4
 ; CHECK:   call void (...) @llvm.frameescape(float* %f, i32* %i)
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %i = alloca i32, align 4
   %f = alloca float, align 4
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
 ; CHECK:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont, label %try.cont10]
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot
   br label %catch.dispatch
 
invoke.cont2:                                     ; preds = %catch
   call void @llvm.eh.endcatch() #3
   br label %try.cont
 
 try.cont:                                         ; preds = %invoke.cont2, %invoke.cont
   br label %try.cont10
 
 ; CHECK-NOT: lpad1:
 lpad1:                                            ; preds = %catch
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %6 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %7 = extractvalue { i8*, i32 } %6, 0
   store i8* %7, i8** %exn.slot
   %8 = extractvalue { i8*, i32 } %6, 1
   store i32 %8, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #3
   br label %catch.dispatch3
 

 ; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
 ; CHECK:   invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
 ; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: invoke.cont2:
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 ;
 ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
 ; CHECK:   [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK:   indirectbr i8* [[RECOVER1]], []
 ;
 ; CHECK: }
 
 
 declare void @"\01?may_throw@@YAXXZ"() #1

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-2.ll

 ; CHECK:   %inner = alloca %class.Inner, align 1
 ; CHECK:   %i = alloca i32, align 4
 ; CHECK:   %f = alloca float, align 4
 ; CHECK:   call void (...) @llvm.frameescape(float* %f, i32* %i, %class.Outer* %outer, %class.Inner* %inner)
 ; CHECK:   invoke void @_ZN5OuterC1Ev(%class.Outer* %outer)
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @_Z4testv() #0 {
+define void @_Z4testv() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %outer = alloca %class.Outer, align 1
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %inner = alloca %class.Inner, align 1
   %i = alloca i32, align 4
   %f = alloca float, align 4
   invoke void @_ZN5OuterC1Ev(%class.Outer* %outer)

 
 ; CHECK: invoke.cont5:
 ; CHECK:   br label %try.cont
 
 invoke.cont5:                                     ; preds = %invoke.cont4
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIf to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont19]
 
 lpad:                                             ; preds = %try.cont, %entry
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIf to i8*)
   %tmp1 = extractvalue { i8*, i32 } %tmp, 0
   store i8* %tmp1, i8** %exn.slot
   %tmp2 = extractvalue { i8*, i32 } %tmp, 1
   store i32 %tmp2, i32* %ehselector.slot
   br label %catch.dispatch11
 
 ; CHECK: [[LPAD1_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIf to i8*)
 ; CHECK-NEXT:   [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(
 ; CHECK-SAME:       i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch.1,
 ; CHECK-SAME:       i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
 ; CHECK-SAME:       i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER1]], [label %try.cont, label %try.cont19]
 
 lpad1:                                            ; preds = %invoke.cont4, %invoke.cont
-  %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp3 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
           catch i8* bitcast (i8** @_ZTIf to i8*)
   %tmp4 = extractvalue { i8*, i32 } %tmp3, 0
   store i8* %tmp4, i8** %exn.slot
   %tmp5 = extractvalue { i8*, i32 } %tmp3, 1
   store i32 %tmp5, i32* %ehselector.slot
   br label %catch.dispatch
 
 ; CHECK: [[LPAD3_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           cleanup
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT:           catch i8* bitcast (i8** @_ZTIf to i8*)
 ; CHECK-NEXT:   [[RECOVER3:\%.+]] = call i8* (...) @llvm.eh.actions(
 ; CHECK-SAME:       i32 0, void (i8*, i8*)* @_Z4testv.cleanup.2,
 ; CHECK-SAME:       i32 1, i8* bitcast (i8** @_ZTIi to i8*), i32 1, i8* (i8*, i8*)* @_Z4testv.catch.1,
 ; CHECK-SAME:       i32 0, void (i8*, i8*)* @_Z4testv.cleanup,
 ; CHECK-SAME:       i32 1, i8* bitcast (i8** @_ZTIf to i8*), i32 0, i8* (i8*, i8*)* @_Z4testv.catch)
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER3]], [label %try.cont, label %try.cont19]
 
 lpad3:                                            ; preds = %invoke.cont2
-  %tmp6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp6 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
           catch i8* bitcast (i8** @_ZTIf to i8*)
   %tmp7 = extractvalue { i8*, i32 } %tmp6, 0
   store i8* %tmp7, i8** %exn.slot
   %tmp8 = extractvalue { i8*, i32 } %tmp6, 1
   store i32 %tmp8, i32* %ehselector.slot
   call void @_ZN5InnerD1Ev(%class.Inner* %inner)
invoke void @_ZN5OuterD1Ev(%class.Outer* %outer)
           to label %invoke.cont9 unwind label %lpad
 
 invoke.cont9:                                     ; preds = %try.cont
   br label %try.cont19
 
 ; CHECK-NOT: lpad7:
 
 lpad7:                                            ; preds = %catch
-  %tmp14 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %tmp14 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i8** @_ZTIf to i8*)
   %tmp15 = extractvalue { i8*, i32 } %tmp14, 0
   store i8* %tmp15, i8** %exn.slot
   %tmp16 = extractvalue { i8*, i32 } %tmp14, 1
   store i32 %tmp16, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #4
   br label %ehcleanup

 ; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
 ; CHECK:   invoke void @_Z10handle_inti(i32 [[TMP1]])
 ; CHECK:           to label %invoke.cont8 unwind label %[[LPAD7_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: invoke.cont8:                                     ; preds = %entry
 ; CHECK:   ret i8* blockaddress(@_Z4testv, %try.cont)
 ;
 ; CHECK: [[LPAD7_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   [[LPAD7_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD7_VAL:\%.+]] = landingpad { i8*, i32 }
 ; (FIXME) The nested handler body isn't being populated yet.
 ; CHECK: }
 
 ; This cleanup handler should be outlined.
 ; CHECK: define internal void @_Z4testv.cleanup(i8*, i8*)
 ; CHECK: entry:
 ; CHECK:   [[RECOVER_OUTER:\%.+]] = call i8* @llvm.framerecover(i8* bitcast (void ()* @_Z4testv to i8*), i8* %1, i32 2)
 ; CHECK:   [[OUTER_PTR:\%.+]] = bitcast i8* [[RECOVER_OUTER]] to %class.Outer*

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-3.ll

 ; CHECK:   %i = alloca i32, align 4
 ; CHECK:   %j = alloca i32, align 4
 ; CHECK:   %f = alloca float, align 4
 ; CHECK:   call void (...) @llvm.frameescape(i32* %j, i32* %i, float* %f)
 ; CHECK:   invoke void @"\01?may_throw@@YAXXZ"()
 ; CHECK:           to label %invoke.cont unwind label %[[LPAD_LABEL:lpad[0-9]*]]
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %i = alloca i32, align 4
   %j = alloca i32, align 4
   %f = alloca float, align 4
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont10
 
 ; CHECK: [[LPAD_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
 ; CHECK:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.2", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
 ; CHECK:   indirectbr i8* [[RECOVER]], [label %try.cont10, label %try.cont19]
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot
   br label %catch.dispatch
 
invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont2 unwind label %lpad1
 
 ; CHECK-NOT: invoke.cont2:
 invoke.cont2:                                     ; preds = %catch
   br label %try.cont
 
 ; CHECK-NOT: lpad1:
 lpad1:                                            ; preds = %catch
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %5 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %6 = extractvalue { i8*, i32 } %5, 0
   store i8* %6, i8** %exn.slot
   %7 = extractvalue { i8*, i32 } %5, 1
   store i32 %7, i32* %ehselector.slot
   br label %catch.dispatch3
 
invoke.cont9:                                     ; preds = %try.cont
   call void @llvm.eh.endcatch() #3
   br label %try.cont10
 
 try.cont10:                                       ; preds = %invoke.cont9, %invoke.cont
   br label %try.cont19
 
 ; CHECK-NOT: lpad8:
 lpad8:                                            ; preds = %try.cont
-  %12 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %12 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
   %13 = extractvalue { i8*, i32 } %12, 0
   store i8* %13, i8** %exn.slot
   %14 = extractvalue { i8*, i32 } %12, 1
   store i32 %14, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #3
   br label %catch.dispatch11
 

 ; CHECK:           to label %invoke.cont2 unwind label %[[LPAD1_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: invoke.cont2:                                     ; preds = %[[LPAD1_LABEL]], %entry
 ; CHECK:   [[TMP1:\%.+]] = load i32, i32* [[I_PTR]], align 4
 ; CHECK:   invoke void @"\01?handle_int@@YAXH@Z"(i32 [[TMP1]])
 ; CHECK:           to label %invoke.cont9 unwind label %[[LPAD8_LABEL:lpad[0-9]*]]
 ;
 ; CHECK: [[LPAD1_LABEL]]:{{[ ]+}}; preds = %entry
-; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD1_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
 ; CHECK:   [[RECOVER1:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
 ; CHECK:   indirectbr i8* [[RECOVER1]], [label %invoke.cont2]
 ;
 ; CHECK: invoke.cont9:
 ; CHECK:   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
 ;
 ; CHECK: [[LPAD8_LABEL]]:{{[ ]+}}; preds = %invoke.cont2
-; CHECK:   [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   [[LPAD8_VAL:\%.+]] = landingpad { i8*, i32 }
 ; CHECK:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*)
 ; CHECK:   [[RECOVER2:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0M@8" to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch.1")
 ; CHECK:   indirectbr i8* [[RECOVER2]], []
 ;
 ; CHECK: }
 
 declare void @"\01?may_throw@@YAXXZ"() #1
 

llvm/trunk/test/CodeGen/WinEH/cppeh-nested-rethrow.ll

 @_CTA1H = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0H@84" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat
 @_TI1H = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1H to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat
 
 ; CHECK-LABEL: define void @"\01?test1@@YAXXZ"()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape
 
 ; Function Attrs: nounwind uwtable
-define void @"\01?test1@@YAXXZ"() #0 {
+define void @"\01?test1@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %tmp = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 1, i32* %tmp
   %0 = bitcast i32* %tmp to i8*
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #2
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   br label %catch
 
 catch:                                            ; preds = %lpad
   %exn = load i8*, i8** %exn.slot
   call void @llvm.eh.begincatch(i8* %exn, i8* null) #1
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #2
           to label %unreachable unwind label %lpad1
 
 lpad1:                                            ; preds = %catch
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   store i8* %5, i8** %exn.slot
   %6 = extractvalue { i8*, i32 } %4, 1
   store i32 %6, i32* %ehselector.slot
   br label %catch2
 
 catch2:                                           ; preds = %lpad1

 ; Function Attrs: nounwind
 declare void @llvm.eh.endcatch() #1
 
 ; CHECK-LABEL: define void @"\01?test2@@YAXXZ"()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape
 
 ; Function Attrs: nounwind uwtable
-define void @"\01?test2@@YAXXZ"() #0 {
+define void @"\01?test2@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %tmp = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 1, i32* %tmp
   %0 = bitcast i32* %tmp to i8*
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #2
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   br label %catch
 
 catch:                                            ; preds = %lpad
   %exn = load i8*, i8** %exn.slot
   call void @llvm.eh.begincatch(i8* %exn, i8* null) #1
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #2
           to label %unreachable unwind label %lpad1
 
 lpad1:                                            ; preds = %catch
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch i8* null
   %5 = extractvalue { i8*, i32 } %4, 0
   store i8* %5, i8** %exn.slot
   %6 = extractvalue { i8*, i32 } %4, 1
   store i32 %6, i32* %ehselector.slot
   br label %catch2
 
 catch2:                                           ; preds = %lpad1

llvm/trunk/test/CodeGen/WinEH/cppeh-nonalloca-frame-values.ll

 ; CHECK:   [[A_PTR:\%.+]] = bitcast i64* [[DATA_PTR]] to i32*
 ; CHECK:   store i32* [[A_PTR]], i32** [[A_REGMEM]]
 ; CHECK:   [[B_PTR:\%.+]] = getelementptr inbounds %struct.SomeData, %struct.SomeData* [[TMPCAST]], i64 0, i32 1
 ; CHECK:   store i32* [[B_PTR]], i32** [[B_REGMEM]]
 ; CHECK:   call void (...) @llvm.frameescape(i32* %e, i32* %NumExceptions.020.reg2mem, [10 x i32]* [[EXCEPTIONVAL]], i32* %inc.reg2mem, i32* [[I_REGMEM]], i32** [[A_REGMEM]], i32** [[B_REGMEM]])
 ; CHECK:   br label %for.body
 
 ; Function Attrs: uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %e = alloca i32, align 4
   %ExceptionVal = alloca [10 x i32], align 16
   %Data = alloca i64, align 8
   %tmpcast = bitcast i64* %Data to %struct.SomeData*
   %0 = bitcast [10 x i32]* %ExceptionVal to i8*
   call void @llvm.lifetime.start(i64 40, i8* %0) #1
   store i64 0, i64* %Data, align 8

 ; CHECK:   br label %try.cont
 invoke.cont:                                      ; preds = %for.body
   %1 = load i32, i32* %a, align 8, !tbaa !2
   %add = add nsw i32 %1, %i.019
   store i32 %add, i32* %a, align 8, !tbaa !2
   br label %try.cont
 
 ; CHECK: [[LPAD_LABEL:lpad[0-9]*]]:{{[ ]+}}; preds = %for.body
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %[[SPLIT_RECOVER_BB:.*]]]
 
 lpad:                                             ; preds = %for.body
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)
   %3 = extractvalue { i8*, i32 } %2, 1
   %4 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*)) #1
   %matches = icmp eq i32 %3, %4
   br i1 %matches, label %catch, label %eh.resume
 
 ; CHECK-NOT: catch:
 

llvm/trunk/test/CodeGen/WinEH/cppeh-prepared-catch-all.ll

 ; }
 
 declare void @may_throw() #1
 declare i32 @__CxxFrameHandler3(...)
 declare void @llvm.eh.begincatch(i8* nocapture, i8* nocapture) #2
 declare void @llvm.eh.endcatch() #2
 
 ; Function Attrs: nounwind uwtable
-define void @test_catch_all() #0 {
+define void @test_catch_all() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @may_throw()
           to label %try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @llvm.eh.begincatch(i8* %1, i8* null) #2
   tail call void @llvm.eh.endcatch() #2
   br label %try.cont
 
 try.cont:                                         ; preds = %entry, %lpad
   ret void

llvm/trunk/test/CodeGen/WinEH/cppeh-prepared-catch-reordered.ll

 @_CTA1H = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0H@84" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat
 @_TI1H = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1H to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat
 @llvm.eh.handlertype.H.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 @"\01??_C@_06PNOAJMHG@e?3?5?$CFd?6?$AA@" = linkonce_odr unnamed_addr constant [7 x i8] c"e: %d\0A\00", comdat, align 1
 
 declare void @_CxxThrowException(i8*, %eh.ThrowInfo*)
 
 ; Function Attrs: uwtable
-define i32 @main() #1 {
+define i32 @main() #1 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %tmp.i = alloca i32, align 4
   %e = alloca i32, align 4
   %0 = bitcast i32* %tmp.i to i8*
   store i32 42, i32* %tmp.i, align 4, !tbaa !2
   call void (...) @llvm.frameescape(i32* %e)
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #6
           to label %.noexc unwind label %lpad1
 
 .noexc:                                           ; preds = %entry
   unreachable
 
 lpad1:                                            ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
   %recover = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*), i32 0, i8* (i8*, i8*)* @main.catch)
   indirectbr i8* %recover, [label %try.cont.split]
 
 try.cont.split:                                   ; preds = %lpad1
   ret i32 0
 }
 

 declare void @llvm.eh.endcatch() #3
 
 ; Function Attrs: nounwind
 declare void @llvm.lifetime.start(i64, i8* nocapture) #3
 
 ; Function Attrs: nounwind
 declare i8* @llvm.eh.actions(...) #3
 
-define internal i8* @main.catch(i8*, i8*) #5 {
+define internal i8* @main.catch(i8*, i8*) #5 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %e.i8 = call i8* @llvm.framerecover(i8* bitcast (i32 ()* @main to i8*), i8* %1, i32 0)
   %e = bitcast i8* %e.i8 to i32*
   %2 = bitcast i32* %e to i8*
   %3 = load i32, i32* %e, align 4, !tbaa !2
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @"\01??_C@_06PNOAJMHG@e?3?5?$CFd?6?$AA@", i64 0, i64 0), i32 %3)
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret i8* blockaddress(@main, %try.cont.split)
 
 stub:                                             ; preds = %entry
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
 ; CHECK-LABEL: main.catch:
 ; CHECK:        .seh_handlerdata
 ; CHECK:        .long   ($cppxdata$main)@IMGREL

llvm/trunk/test/CodeGen/WinEH/cppeh-prepared-catch.ll

 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0N@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".N\00" }, comdat
 @llvm.eh.handlertype.N.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0N@8" to i8*) }, section "llvm.metadata"
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 @llvm.eh.handlertype.H.8 = private unnamed_addr constant %eh.CatchHandlerType { i32 8, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 
-define internal i8* @"\01?f@@YAXXZ.catch"(i8*, i8*) #4 {
+define internal i8* @"\01?f@@YAXXZ.catch"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?f@@YAXXZ" to i8*), i8* %1, i32 0)
   %bc2 = bitcast i8* %.i8 to i32**
   %bc3 = bitcast i32** %bc2 to i8*
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %entry
   ret i8* blockaddress(@"\01?f@@YAXXZ", %try.cont)
 
 lpad1:                                            ; preds = %entry
-  %lp4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %lp4 = landingpad { i8*, i32 }
           cleanup
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.N.0
   %recover = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.N.0 to i8*), i32 1, i8* (i8*, i8*)* @"\01?f@@YAXXZ.catch1")
   indirectbr i8* %recover, [label %invoke.cont2]
 }
 
 ; CHECK-LABEL: "?f@@YAXXZ.catch":
 ; No code should be generated for the indirectbr.
 ; CHECK-NOT: jmpq *
 ; CHECK:        .seh_handlerdata
 ; CHECK:        .long   ("$cppxdata$?f@@YAXXZ")@IMGREL
 
 
-define internal i8* @"\01?f@@YAXXZ.catch1"(i8*, i8*) #4 {
+define internal i8* @"\01?f@@YAXXZ.catch1"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?f@@YAXXZ" to i8*), i8* %1, i32 1)
   %2 = bitcast i8* %.i8 to double*
   %3 = bitcast double* %2 to i8*
   invoke void (...) @llvm.donothing()
           to label %done unwind label %lpad
 
 done:
   ret i8* blockaddress(@"\01?f@@YAXXZ", %try.cont8)
 
 lpad:                                             ; preds = %entry
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
 ; CHECK-LABEL: "?f@@YAXXZ.catch1":
 ; No code should be generated for the indirectbr.
 ; CHECK-NOT: jmpq *
 ; CHECK: ".L?f@@YAXXZ.catch1$parent_frame_offset" = 16
 ; CHECK:         movq    %rdx, 16(%rsp)
 ; CHECK:        .seh_handlerdata
 ; CHECK:        .long   ("$cppxdata$?f@@YAXXZ")@IMGREL
 
-define void @"\01?f@@YAXXZ"() #0 {
+define void @"\01?f@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %0 = alloca i32*, align 8
   %1 = alloca double, align 8
   call void (...) @llvm.frameescape(i32** %0, double* %1)
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont unwind label %lpad2
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 lpad2:                                            ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.8
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.N.0
   %recover = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.8 to i8*), i32 0, i8* (i8*, i8*)* @"\01?f@@YAXXZ.catch", i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.N.0 to i8*), i32 1, i8* (i8*, i8*)* @"\01?f@@YAXXZ.catch1")
   indirectbr i8* %recover, [label %try.cont, label %try.cont8]
 
 try.cont:                                         ; preds = %lpad2, %invoke.cont
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %try.cont8 unwind label %lpad1
 
 lpad1:
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.N.0
   %recover2 = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.N.0 to i8*), i32 1, i8* (i8*, i8*)* @"\01?f@@YAXXZ.catch1")
   indirectbr i8* %recover2, [label %try.cont8]
 
 try.cont8:                                        ; preds = %lpad2, %try.cont
   ret void
 }
 

llvm/trunk/test/CodeGen/WinEH/cppeh-prepared-cleanups.ll

 ; CHECK-NEXT:        .long   -1
 ; CHECK-NEXT:        .long   "?test1@@YAXXZ.cleanup"@IMGREL
 ; CHECK-NEXT:"$ip2state$?test1@@YAXXZ":
 ; CHECK-NEXT:        .long   .Lfunc_begin0@IMGREL
 ; CHECK-NEXT:        .long   -1
 ; CHECK-NEXT:        .long   .Ltmp0@IMGREL
 ; CHECK-NEXT:        .long   0
 
-define void @"\01?test1@@YAXXZ"() #0 {
+define void @"\01?test1@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %unwindhelp = alloca i64
   %tmp = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 0, i32* %tmp
   %0 = bitcast i32* %tmp to i8*
   call void (...) @llvm.frameescape()
   store volatile i64 -2, i64* %unwindhelp
   %1 = bitcast i64* %unwindhelp to i8*
   call void @llvm.eh.unwindhelp(i8* %1)
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #8
           to label %unreachable unwind label %lpad1
 
 lpad1:                                            ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @"\01?test1@@YAXXZ.cleanup")
   indirectbr i8* %recover, []
 
 unreachable:                                      ; preds = %entry
   unreachable
 }
 

 ; CHECK-NEXT:        .long   -1
 ; CHECK-NEXT:        .long   .Ltmp7@IMGREL
 ; CHECK-NEXT:        .long   0
 ; CHECK-NEXT:        .long   .Ltmp9@IMGREL
 ; CHECK-NEXT:        .long   1
 ; CHECK-NEXT:        .long   .Ltmp12@IMGREL
 ; CHECK-NEXT:        .long   0
 
-define void @"\01?test2@@YAX_N@Z"(i1 zeroext %b) #2 {
+define void @"\01?test2@@YAX_N@Z"(i1 zeroext %b) #2 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
   %b.addr = alloca i8, align 1
   %s = alloca %struct.S, align 1
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %s1 = alloca %struct.S, align 1
   %frombool = zext i1 %b to i8
   store i8 %frombool, i8* %b.addr, align 1
   call void (...) @llvm.frameescape(%struct.S* %s, %struct.S* %s1)
if.then:                                          ; preds = %invoke.cont
   invoke void @"\01?may_throw@@YAXXZ"()
           to label %invoke.cont3 unwind label %lpad3
 
 invoke.cont3:                                     ; preds = %if.then
   call void @"\01??_DS@@QEAA@XZ"(%struct.S* %s1) #4
   br label %if.end
 
 lpad1:                                            ; preds = %entry, %if.end
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @"\01?test2@@[e-mail]")
   indirectbr i8* %recover, []
 
 lpad3:                                            ; preds = %if.then
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   %recover4 = call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @"\01?test2@@[e-mail]1", i32 0, void (i8*, i8*)* @"\01?test2@@[e-mail]")
   indirectbr i8* %recover4, []
 
 if.else:                                          ; preds = %invoke.cont
   call void @"\01?dont_throw@@YAXXZ"() #4
   br label %if.end
 

 declare void @llvm.frameescape(...) #4
 
 ; Function Attrs: nounwind readnone
 declare i8* @llvm.framerecover(i8*, i8*, i32) #6
 
 ; Function Attrs: nounwind
 declare void @llvm.eh.unwindhelp(i8*) #4
 
-define internal void @"\01?test2@@[e-mail]"(i8*, i8*) #7 {
+define internal void @"\01?test2@@[e-mail]"(i8*, i8*) #7 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %s.i8 = call i8* @llvm.framerecover(i8* bitcast (void (i1)* @"\01?test2@@YAX_N@Z" to i8*), i8* %1, i32 0)
   %s = bitcast i8* %s.i8 to %struct.S*
   call void @"\01??_DS@@QEAA@XZ"(%struct.S* %s) #4
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret void
 
 stub:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   unreachable
 }
 
-define internal void @"\01?test2@@[e-mail]1"(i8*, i8*) #7 {
+define internal void @"\01?test2@@[e-mail]1"(i8*, i8*) #7 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %s1.i8 = call i8* @llvm.framerecover(i8* bitcast (void (i1)* @"\01?test2@@YAX_N@Z" to i8*), i8* %1, i32 1)
   %s1 = bitcast i8* %s1.i8 to %struct.S*
   call void @"\01??_DS@@QEAA@XZ"(%struct.S* %s1) #4
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret void
 
 stub:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   unreachable
 }
 
 declare void @llvm.donothing()
 
 attributes #0 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" "wineh-parent"="␁?test1@@YAXXZ" }
 attributes #1 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #2 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" "wineh-parent"="␁?test2@@YAX_N@Z" }
 attributes #3 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #4 = { nounwind }
 attributes #5 = { "wineh-parent"="␁?test1@@YAXXZ" }
 attributes #6 = { nounwind readnone }
 attributes #7 = { "wineh-parent"="␁?test2@@YAX_N@Z" }
 attributes #8 = { noreturn }

llvm/trunk/test/CodeGen/WinEH/cppeh-shared-empty-catch.ll

 @llvm.eh.handlertype.H.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 
 ; CHECK-LABEL: define void @"\01?f@@YAXXZ"()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape()
 ; CHECK:   invoke void @"\01?g@@YAXXZ"()
 
 ; Function Attrs: nounwind
-define void @"\01?f@@YAXXZ"() #0 {
+define void @"\01?f@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @"\01?g@@YAXXZ"()
           to label %invoke.cont unwind label %lpad
 
 ; CHECK-LABEL: invoke.cont:
 ; CHECK:   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null)
 ; CHECK:           to label %unreachable unwind label %[[LPAD1_LABEL:lpad[0-9]+]]
 
 invoke.cont:                                      ; preds = %entry
   invoke void @_CxxThrowException(i8* null, %eh.ThrowInfo* null) #4
           to label %unreachable unwind label %lpad1
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   br label %catch2
 
 ; Note: Even though this landing pad has two catch clauses, it only has one action because both
 ;       handlers do the same thing.
 ; CHECK: [[LPAD1_LABEL]]:
-; CHECK:   landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+; CHECK:   landingpad { i8*, i32 }
 ; CHECK-NEXT:           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
 ; CHECK-NEXT:           catch i8* null
 ; CHECK-NEXT:   [[RECOVER:\%.+]] = call i8* (...) @llvm.eh.actions(i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?f@@YAXXZ.catch")
 ; CHECK-NEXT:   indirectbr i8* [[RECOVER]], [label %try.cont4]
 
 lpad1:                                            ; preds = %invoke.cont
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %3 = extractvalue { i8*, i32 } %2, 0
   br label %catch2
 
 catch2:                                           ; preds = %lpad1, %lpad
   %exn.slot.0 = phi i8* [ %3, %lpad1 ], [ %1, %lpad ]
   tail call void @llvm.eh.begincatch(i8* %exn.slot.0, i8* null) #3

llvm/trunk/test/CodeGen/WinEH/cppeh-similar-catch-blocks.ll

 ; This is just a minimal check to verify that main was handled by WinEHPrepare.
 ; CHECK: define i32 @main()
 ; CHECK: entry:
 ; CHECK:   call void (...) @llvm.frameescape(i32* [[X_PTR:\%.+]], i32* [[X2_PTR:\%.+]], i8* [[C2_PTR:\%.+]], i8* [[C3_PTR:\%.+]], i8* [[C_PTR:\%.+]])
 ; CHECK:   invoke void @_CxxThrowException
 ; CHECK: }
 
 ; Function Attrs: uwtable
-define i32 @main() #0 {
+define i32 @main() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %retval = alloca i32, align 4
   %tmp = alloca i8, align 1
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %c = alloca i8, align 1
   %tmp3 = alloca i32, align 4
   %x = alloca i32, align 4
   %tmp20 = alloca i8, align 1
   %c28 = alloca i8, align 1
   %tmp34 = alloca i32, align 4
   %c48 = alloca i8, align 1
   %x56 = alloca i32, align 4
   store i32 0, i32* %retval
   store i8 97, i8* %tmp
   invoke void @_CxxThrowException(i8* %tmp, %eh.ThrowInfo* @_TI1D) #4
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.D.0
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot
   br label %catch.dispatch

 
 try.cont:                                         ; preds = %invoke.cont
   store i32 1, i32* %tmp3
   %5 = bitcast i32* %tmp3 to i8*
   invoke void @_CxxThrowException(i8* %5, %eh.ThrowInfo* @_TI1H) #4
           to label %unreachable unwind label %lpad4
 
 lpad2:                                            ; preds = %catch
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %6 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %7 = extractvalue { i8*, i32 } %6, 0
   store i8* %7, i8** %exn.slot
   %8 = extractvalue { i8*, i32 } %6, 1
   store i32 %8, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %catch.dispatch5
 
 lpad4:                                            ; preds = %try.cont
-  %9 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %9 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %10 = extractvalue { i8*, i32 } %9, 0
   store i8* %10, i8** %exn.slot
   %11 = extractvalue { i8*, i32 } %9, 1
   store i32 %11, i32* %ehselector.slot
   br label %catch.dispatch5
 
catch8:                                           ; preds = %catch.dispatch5
   %call12 = invoke i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"\01??_C@_04MPPNMCOK@?4?4?4?6?$AA@", i32 0, i32 0))
           to label %invoke.cont11 unwind label %lpad10
 
 invoke.cont11:                                    ; preds = %catch8
   call void @llvm.eh.endcatch() #2
   br label %try.cont19
 
 lpad10:                                           ; preds = %catch8
-  %15 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %15 = landingpad { i8*, i32 }
           cleanup
   %16 = extractvalue { i8*, i32 } %15, 0
   store i8* %16, i8** %exn.slot
   %17 = extractvalue { i8*, i32 } %15, 1
   store i32 %17, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 
 lpad16:                                           ; preds = %catch13
-  %18 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %18 = landingpad { i8*, i32 }
           cleanup
   %19 = extractvalue { i8*, i32 } %18, 0
   store i8* %19, i8** %exn.slot
   %20 = extractvalue { i8*, i32 } %18, 1
   store i32 %20, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 
 lpad21:                                           ; preds = %try.cont19
-  %21 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %21 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.D.0 to i8*)
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
           catch i8* null
   %22 = extractvalue { i8*, i32 } %21, 0
   store i8* %22, i8** %exn.slot
   %23 = extractvalue { i8*, i32 } %21, 1
   store i32 %23, i32* %ehselector.slot
   br label %catch.dispatch22

 
 try.cont33:                                       ; preds = %invoke.cont31
   store i32 2, i32* %tmp34
   %26 = bitcast i32* %tmp34 to i8*
   invoke void @_CxxThrowException(i8* %26, %eh.ThrowInfo* @_TI1H) #4
           to label %unreachable unwind label %lpad35
 
 lpad30:                                           ; preds = %catch25
-  %27 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %27 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.D.0 to i8*)
           catch i8* null
   %28 = extractvalue { i8*, i32 } %27, 0
   store i8* %28, i8** %exn.slot
   %29 = extractvalue { i8*, i32 } %27, 1
   store i32 %29, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %catch.dispatch36
 
 lpad35:                                           ; preds = %try.cont33
-  %30 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %30 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.D.0 to i8*)
           catch i8* null
   %31 = extractvalue { i8*, i32 } %30, 0
   store i8* %31, i8** %exn.slot
   %32 = extractvalue { i8*, i32 } %30, 1
   store i32 %32, i32* %ehselector.slot
   br label %catch.dispatch36
catch40:                                          ; preds = %catch.fallthrough
   %call44 = invoke i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"\01??_C@_04MPPNMCOK@?4?4?4?6?$AA@", i32 0, i32 0))
           to label %invoke.cont43 unwind label %lpad42
 
 invoke.cont43:                                    ; preds = %catch40
   call void @llvm.eh.endcatch() #2
   br label %try.cont60
 
 lpad42:                                           ; preds = %catch40
-  %38 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %38 = landingpad { i8*, i32 }
           cleanup
   %39 = extractvalue { i8*, i32 } %38, 0
   store i8* %39, i8** %exn.slot
   %40 = extractvalue { i8*, i32 } %38, 1
   store i32 %40, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 
 lpad50:                                           ; preds = %catch45
-  %41 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %41 = landingpad { i8*, i32 }
           cleanup
   %42 = extractvalue { i8*, i32 } %41, 0
   store i8* %42, i8** %exn.slot
   %43 = extractvalue { i8*, i32 } %41, 1
   store i32 %43, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 
 lpad57:                                           ; preds = %catch53
-  %44 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %44 = landingpad { i8*, i32 }
           cleanup
   %45 = extractvalue { i8*, i32 } %44, 0
   store i8* %45, i8** %exn.slot
   %46 = extractvalue { i8*, i32 } %44, 1
   store i32 %46, i32* %ehselector.slot
   call void @llvm.eh.endcatch() #2
   br label %eh.resume
 

llvm/trunk/test/CodeGen/WinEH/cppeh-state-calc-1.ll

 @"_CT??_R0H@84" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 1, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32), i32 0, i32 -1, i32 0, i32 4, i32 0 }, section ".xdata", comdat
 @_CTA1H = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0H@84" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat
 @_TI1H = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1H to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat
 @"_CT??_R0D@81" = linkonce_odr unnamed_addr constant %eh.CatchableType { i32 1, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%rtti.TypeDescriptor2* @"\01??_R0D@8" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32), i32 0, i32 -1, i32 0, i32 1, i32 0 }, section ".xdata", comdat
 @_CTA1D = linkonce_odr unnamed_addr constant %eh.CatchableTypeArray.1 { i32 1, [1 x i32] [i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableType* @"_CT??_R0D@81" to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32)] }, section ".xdata", comdat
 @_TI1D = linkonce_odr unnamed_addr constant %eh.ThrowInfo { i32 0, i32 0, i32 0, i32 trunc (i64 sub nuw nsw (i64 ptrtoint (%eh.CatchableTypeArray.1* @_CTA1D to i64), i64 ptrtoint (i8* @__ImageBase to i64)) to i32) }, section ".xdata", comdat
 
 ; Function Attrs: nounwind uwtable
-define void @"\01?test@@YAXXZ"() #0 {
+define void @"\01?test@@YAXXZ"() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %tmp = alloca i32, align 4
   %x = alloca i32, align 4
   %tmp2 = alloca i8, align 1
   %c = alloca i8, align 1
   %tmp11 = alloca i32, align 4
   %x21 = alloca i32, align 4
   call void @"\01?two@@YAXXZ"() #3
   store i32 2, i32* %tmp
   %0 = bitcast i32* %tmp to i8*
   call void (...) @llvm.frameescape(i32* %x, i8* %c, i32* %x21)
   invoke void @_CxxThrowException(i8* %0, %eh.ThrowInfo* @_TI1H) #5
           to label %unreachable unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.D.0
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %recover = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*), i32 0, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch", i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.D.0 to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch3")
   indirectbr i8* %recover, [label %try.cont, label %try.cont10, label %try.cont22]
 
 try.cont:                                         ; preds = %lpad
   call void @"\01?a@@YAXXZ"() #3
   store i8 97, i8* %tmp2
   invoke void @_CxxThrowException(i8* %tmp2, %eh.ThrowInfo* @_TI1D) #5
           to label %unreachable unwind label %lpad3
 
 lpad3:                                            ; preds = %try.cont
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.D.0
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %recover1 = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.D.0 to i8*), i32 1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch1", i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch3")
   indirectbr i8* %recover1, [label %try.cont10, label %try.cont22]
 
 try.cont10:                                       ; preds = %lpad3, %lpad
   call void @"\01?one@@YAXXZ"() #3
   store i32 1, i32* %tmp11
   %3 = bitcast i32* %tmp11 to i8*
   invoke void @_CxxThrowException(i8* %3, %eh.ThrowInfo* @_TI1H) #5
           to label %unreachable unwind label %lpad12
 
 lpad12:                                           ; preds = %try.cont10
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %4 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
           catch i8* null
   %recover2 = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*), i32 2, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch2", i32 1, i8* null, i32 -1, i8* (i8*, i8*)* @"\01?test@@YAXXZ.catch3")
   indirectbr i8* %recover2, [label %try.cont22]
 
 try.cont22:                                       ; preds = %lpad12, %lpad3, %lpad
   ret void
 

 declare void @"\01?catch_all@@YAXXZ"() #1
 
 ; Function Attrs: nounwind
 declare void @"\01?catch_one@@YAXXZ"() #1
 
 ; Function Attrs: nounwind
 declare i8* @llvm.eh.actions(...) #3
 
-define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) #4 {
+define internal i8* @"\01?test@@YAXXZ.catch"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %x.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 0)
   %x = bitcast i8* %x.i8 to i32*
   %2 = bitcast i32* %x to i8*
   call void @"\01?catch_two@@YAXXZ"() #3
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont)
 
 stub:                                             ; preds = %entry
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.donothing() #2
 
-define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) #4 {
+define internal i8* @"\01?test@@YAXXZ.catch1"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   call void @"\01?catch_a@@YAXXZ"() #3
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont10)
 
 stub:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
-define internal i8* @"\01?test@@YAXXZ.catch2"(i8*, i8*) #4 {
+define internal i8* @"\01?test@@YAXXZ.catch2"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   %x21.i8 = call i8* @llvm.framerecover(i8* bitcast (void ()* @"\01?test@@YAXXZ" to i8*), i8* %1, i32 2)
   %x21 = bitcast i8* %x21.i8 to i32*
   %2 = bitcast i32* %x21 to i8*
   call void @"\01?catch_one@@YAXXZ"() #3
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont22)
 
 stub:                                             ; preds = %entry
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
-define internal i8* @"\01?test@@YAXXZ.catch3"(i8*, i8*) #4 {
+define internal i8* @"\01?test@@YAXXZ.catch3"(i8*, i8*) #4 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   call void @"\01?catch_all@@YAXXZ"() #3
   invoke void @llvm.donothing()
           to label %entry.split unwind label %stub
 
 entry.split:                                      ; preds = %entry
   ret i8* blockaddress(@"\01?test@@YAXXZ", %try.cont22)
 
 stub:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %recover = call i8* (...) @llvm.eh.actions()
   unreachable
 }
 
 ; Function Attrs: nounwind
 declare void @llvm.frameescape(...) #3
 

llvm/trunk/test/CodeGen/WinEH/seh-catch-all.ll

 }
 
 declare i32 @__C_specific_handler(...)
 
 ; Function Attrs: nounwind readnone
 declare i8* @llvm.frameaddress(i32)
 
 ; Function Attrs: uwtable
-define void @seh_catch_all() {
+define void @seh_catch_all() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   invoke void @may_crash()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   br label %__try.cont
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   store i8* %1, i8** %exn.slot
   %2 = extractvalue { i8*, i32 } %0, 1
   store i32 %2, i32* %ehselector.slot
   br label %__except
 
 __except:                                         ; preds = %lpad

llvm/trunk/test/CodeGen/WinEH/seh-inlined-finally.ll

 declare void @may_crash()
 declare i32 @__C_specific_handler(...)
 declare i8* @llvm.framerecover(i8*, i8*, i32) #1
 declare i8* @llvm.frameaddress(i32)
 declare void @llvm.frameescape(...)
 declare dllimport void @EnterCriticalSection(%struct._RTL_CRITICAL_SECTION*)
 declare dllimport void @LeaveCriticalSection(%struct._RTL_CRITICAL_SECTION*)
 
-define void @use_finally() {
+define void @use_finally() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   invoke void @may_crash()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %call.i = tail call i32 @puts(i8* null)
   ret void
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   %call.i2 = tail call i32 @puts(i8* null)
   resume { i8*, i32 } %0
 }
 
 ; CHECK-LABEL: define void @use_finally()
 ; CHECK: invoke void @may_crash()
 ;
 ; CHECK: landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: call i8* (...) @llvm.eh.actions(i32 0, void (i8*, i8*)* @use_finally.cleanup)
 ; CHECK-NEXT: indirectbr i8* %recover, []
 
 ; Function Attrs: nounwind uwtable
-define i32 @call_may_crash_locked() {
+define i32 @call_may_crash_locked() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %p = alloca %struct._RTL_CRITICAL_SECTION, align 8
   call void (...) @llvm.frameescape(%struct._RTL_CRITICAL_SECTION* %p)
   call void @EnterCriticalSection(%struct._RTL_CRITICAL_SECTION* %p)
   invoke void @may_crash()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %tmp2 = call i8* @llvm.frameaddress(i32 0)
   %tmp3 = call i8* @llvm.framerecover(i8* bitcast (i32 ()* @call_may_crash_locked to i8*), i8* %tmp2, i32 0) #2
   %tmp6 = bitcast i8* %tmp3 to %struct._RTL_CRITICAL_SECTION*
   call void @LeaveCriticalSection(%struct._RTL_CRITICAL_SECTION* %tmp6)
   ret i32 42
 
 lpad:                                             ; preds = %entry
-  %tmp7 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %tmp7 = landingpad { i8*, i32 }
             cleanup
   %tmp8 = call i8* @llvm.frameaddress(i32 0)
   %tmp9 = call i8* @llvm.framerecover(i8* bitcast (i32 ()* @call_may_crash_locked to i8*), i8* %tmp8, i32 0)
   %tmp12 = bitcast i8* %tmp9 to %struct._RTL_CRITICAL_SECTION*
   call void @LeaveCriticalSection(%struct._RTL_CRITICAL_SECTION* %tmp12)
   resume { i8*, i32 } %tmp7
 }
 

llvm/trunk/test/CodeGen/WinEH/seh-outlined-finally.ll

 ; Function Attrs: nounwind uwtable
 define void @may_crash() #0 {
 entry:
   store volatile i32 42, i32* null, align 4
   ret void
 }
 
 ; Function Attrs: uwtable
-define i32 @main() #1 {
+define i32 @main() #1 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %myres = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 0, i32* %myres, align 4
   invoke void @may_crash() #4
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %0 = call i8* @llvm.frameaddress(i32 0)
   invoke void @"\01?fin$1@0@main@@"(i1 zeroext false, i8* %0) #4
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %invoke.cont
   %1 = call i8* @llvm.frameaddress(i32 0)
   call void @"\01?fin$0@0@main@@"(i1 zeroext false, i8* %1)
   ret i32 0
 
 lpad:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   %3 = extractvalue { i8*, i32 } %2, 0
   store i8* %3, i8** %exn.slot
   %4 = extractvalue { i8*, i32 } %2, 1
   store i32 %4, i32* %ehselector.slot
   %5 = call i8* @llvm.frameaddress(i32 0)
   invoke void @"\01?fin$1@0@main@@"(i1 zeroext true, i8* %5) #4
           to label %invoke.cont3 unwind label %lpad1
 
 lpad1:                                            ; preds = %lpad, %invoke.cont
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %6 = landingpad { i8*, i32 }
           cleanup
   %7 = extractvalue { i8*, i32 } %6, 0
   store i8* %7, i8** %exn.slot
   %8 = extractvalue { i8*, i32 } %6, 1
   store i32 %8, i32* %ehselector.slot
   br label %ehcleanup
 
 invoke.cont3:                                     ; preds = %lpad

llvm/trunk/test/CodeGen/WinEH/seh-prepared-basic.ll

 ;   } __except(filt(_exception_code())) {
 ;   }
 ; }
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 ; Function Attrs: uwtable
-define void @do_except() #0 {
+define void @do_except() #0 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   call void (...) @llvm.frameescape()
   invoke void @g() #5
           to label %__try.cont unwind label %lpad1
 
 lpad1:                                            ; preds = %entry
-  %ehvals = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %ehvals = landingpad { i8*, i32 }
           catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@do_except@@" to i8*)
   %recover = call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@do_except@@" to i8*), i32 -1, i8* blockaddress(@do_except, %__try.cont))
   indirectbr i8* %recover, [label %__try.cont]
 
 __try.cont:                                       ; preds = %lpad1, %entry
   ret void
 }
 

llvm/trunk/test/CodeGen/WinEH/seh-resume-phi.ll

 ; RUN: opt -S -winehprepare < %s | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 declare void @might_crash(i8* %ehptr)
 declare i32 @filt()
 declare void @cleanup()
 declare i32 @__C_specific_handler(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 
-define void @resume_phi() {
+define void @resume_phi() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @might_crash(i8* null)
           to label %return unwind label %lpad1
 
 lpad1:
-  %ehvals1 = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals1 = landingpad { i8*, i32 }
           catch i32 ()* @filt
   %ehptr1 = extractvalue { i8*, i32 } %ehvals1, 0
   %ehsel1 = extractvalue { i8*, i32 } %ehvals1, 1
   %filt_sel = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @filt to i8*))
   %matches = icmp eq i32 %ehsel1, %filt_sel
   br i1 %matches, label %__except, label %eh.resume
 
 __except:
   invoke void @might_crash(i8* %ehptr1)
           to label %return unwind label %lpad2
 
 lpad2:
-  %ehvals2 = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals2 = landingpad { i8*, i32 }
           cleanup
   %ehptr2 = extractvalue { i8*, i32 } %ehvals2, 0
   %ehsel2 = extractvalue { i8*, i32 } %ehvals2, 1
   call void @cleanup()
   br label %eh.resume
 
 return:
   ret void

llvm/trunk/test/CodeGen/WinEH/seh-simple.ll

 ; RUN: opt -S -winehprepare -mtriple=x86_64-windows-msvc < %s \
 ; RUN:    | FileCheck %s --check-prefix=CHECK --check-prefix=X64
 
 ; This test should also pass in 32-bit using _except_handler3.
 ; RUN: sed -e 's/__C_specific_handler/_except_handler3/' %s \
 ; RUN:    | opt -S -winehprepare -mtriple=i686-windows-msvc \
 ; RUN:    | FileCheck %s --check-prefix=CHECK --check-prefix=X86
 
 declare void @cleanup()
 declare i32 @filt()
 declare void @might_crash()
 declare i32 @__C_specific_handler(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 
-define i32 @simple_except_store() {
+define i32 @simple_except_store() personality i32 (...)* @__C_specific_handler {
 entry:
   %retval = alloca i32
   store i32 0, i32* %retval
   invoke void @might_crash()
           to label %return unwind label %lpad
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
           catch i32 ()* @filt
   %sel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_sel = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @filt to i8*))
   %matches = icmp eq i32 %sel, %filt_sel
   br i1 %matches, label %__except, label %eh.resume
 
 __except:
   store i32 1, i32* %retval
   br label %return
 
 return:
   %r = load i32, i32* %retval
   ret i32 %r
 
 eh.resume:
   resume { i8*, i32 } %ehvals
 }
 
 ; CHECK-LABEL: define i32 @simple_except_store()
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK-NEXT: catch i32 ()* @filt
 ; CHECK-NEXT: call i8* (...) @llvm.eh.actions(i32 1, i8* bitcast (i32 ()* @filt to i8*), i32 -1, i8* blockaddress(@simple_except_store, %__except))
 ; CHECK-NEXT: indirectbr {{.*}} [label %__except]
 
-define i32 @catch_all() {
+define i32 @catch_all() personality i32 (...)* @__C_specific_handler {
 entry:
   %retval = alloca i32
   store i32 0, i32* %retval
   invoke void @might_crash()
           to label %return unwind label %lpad
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
           catch i8* null
   store i32 1, i32* %retval
   br label %return
 
 return:
   %r = load i32, i32* %retval
   ret i32 %r
 }
 
 ; CHECK-LABEL: define i32 @catch_all()
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK-NEXT: catch i8* null
 ; CHECK-NEXT: call i8* (...) @llvm.eh.actions(i32 1, i8* null, i32 -1, i8* blockaddress(@catch_all, %lpad.split))
 ; CHECK-NEXT: indirectbr {{.*}} [label %lpad.split]
 ;
 ; CHECK: lpad.split:
 ; CHECK: store i32 1, i32* %retval
 
 
-define i32 @except_phi() {
+define i32 @except_phi() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @might_crash()
           to label %return unwind label %lpad
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
           catch i32 ()* @filt
   %sel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_sel = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @filt to i8*))
   %matches = icmp eq i32 %sel, %filt_sel
   br i1 %matches, label %return, label %eh.resume
 
 return:
   %r = phi i32 [0, %entry], [1, %lpad]

 ;
 ; CHECK: lpad.return_crit_edge:
 ; CHECK: br label %return
 ;
 ; CHECK: return:
 ; CHECK-NEXT: %r = phi i32 [ 0, %entry ], [ 1, %lpad.return_crit_edge ]
 ; CHECK-NEXT: ret i32 %r
 
-define i32 @lpad_phi() {
+define i32 @lpad_phi() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @might_crash()
           to label %cont unwind label %lpad
 
 cont:
   invoke void @might_crash()
           to label %return unwind label %lpad
 
 lpad:
   %ncalls.1 = phi i32 [ 0, %entry ], [ 1, %cont ]
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
           catch i32 ()* @filt
   %sel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_sel = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @filt to i8*))
   %matches = icmp eq i32 %sel, %filt_sel
   br i1 %matches, label %return, label %eh.resume
 
 return:
   %r = phi i32 [2, %cont], [%ncalls.1, %lpad]

 ; CHECK: lpad.return_crit_edge:
 ; CHECK: load i32, i32*
 ; CHECK: br label %return
 ;
 ; CHECK: return:
 ; CHECK-NEXT: %r = phi i32 [ 2, %cont ], [ %{{.*}}, %lpad.return_crit_edge ]
 ; CHECK-NEXT: ret i32 %r
 
-define i32 @cleanup_and_except() {
+define i32 @cleanup_and_except() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @might_crash()
           to label %return unwind label %lpad
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
           cleanup
           catch i32 ()* @filt
   call void @cleanup()
   %sel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_sel = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @filt to i8*))
   %matches = icmp eq i32 %sel, %filt_sel
   br i1 %matches, label %return, label %eh.resume
 

llvm/trunk/test/CodeGen/X86/2007-05-05-Personality.ll

 ; RUN: llc < %s -mtriple=i686-pc-linux-gnu -o -     | FileCheck %s  --check-prefix=LIN
 ; RUN: llc < %s -mtriple=i386-pc-mingw32 -o -       | FileCheck %s  --check-prefix=WIN
 ; RUN: llc < %s -mtriple=i686-pc-windows-gnu -o -   | FileCheck %s  --check-prefix=WIN
 ; RUN: llc < %s -mtriple=x86_64-pc-windows-gnu -o - | FileCheck %s  --check-prefix=WIN64
 
 ; LIN: .cfi_personality 0, __gnat_eh_personality
 ; LIN: .cfi_lsda 0, .Lexception0
 ; WIN: .cfi_personality 0, ___gnat_eh_personality
 ; WIN: .cfi_lsda 0, Lexception0
 ; WIN64: .seh_handler __gnat_eh_personality
 ; WIN64: .seh_handlerdata
 
 @error = external global i8
 
-define void @_ada_x() {
+define void @_ada_x() personality i8* bitcast (i32 (...)* @__gnat_eh_personality to i8*) {
 entry:
   invoke void @raise()
           to label %eh_then unwind label %unwind
 
 unwind:                                           ; preds = %entry
-  %eh_ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gnat_eh_personality to i8*)
+  %eh_ptr = landingpad { i8*, i32 }
               catch i8* @error
   %eh_select = extractvalue { i8*, i32 } %eh_ptr, 1
   %eh_typeid = tail call i32 @llvm.eh.typeid.for(i8* @error)
   %tmp2 = icmp eq i32 %eh_select, %eh_typeid
   br i1 %tmp2, label %eh_then, label %Unwind
 
 eh_then:                                          ; preds = %unwind, %entry
   ret void

llvm/trunk/test/CodeGen/X86/2008-04-17-CoalescerBug.ll

 ; RUN: llc < %s -mtriple=i386-apple-darwin | grep xorl | grep "%e"
 ; Make sure xorl operands are 32-bit registers.
 
   %struct.tm = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8* }
   %struct.wxDateTime = type { %struct.wxLongLong }
   %"struct.wxDateTime::TimeZone" = type { i32 }
   %struct.wxLongLong = type { i64 }
   %struct.wxString = type { %struct.wxStringBase }
   %struct.wxStringBase = type { i32* }
 @.str = external constant [27 x i32]    ; <[27 x i32]*> [#uses=1]
 @.str4 = external constant [14 x i32]    ; <[14 x i32]*> [#uses=1]
 @_ZZNK10wxDateTime5GetTmERKNS_8TimeZoneEE12__FUNCTION__ = external constant [6 x i8]    ; <[6 x i8]*> [#uses=1]
 @.str33 = external constant [29 x i32]    ; <[29 x i32]*> [#uses=1]
 @.str89 = external constant [5 x i32]    ; <[5 x i32]*> [#uses=1]
 
-define void @_ZNK10wxDateTime6FormatEPKwRKNS_8TimeZoneE(%struct.wxString* noalias sret  %agg.result, %struct.wxDateTime* %this, i32* %format, %"struct.wxDateTime::TimeZone"* %tz, i1 %foo) {
+define void @_ZNK10wxDateTime6FormatEPKwRKNS_8TimeZoneE(%struct.wxString* noalias sret  %agg.result, %struct.wxDateTime* %this, i32* %format, %"struct.wxDateTime::TimeZone"* %tz, i1 %foo) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br i1 %foo, label %bb116.i, label %bb115.critedge.i
 bb115.critedge.i:   ; preds = %entry
   ret void
 bb116.i:    ; preds = %entry
   br i1 %foo, label %bb52.i.i, label %bb3118
 bb3118:   ; preds = %bb116.i
   ret void

 bb7806:   ; preds = %bb3314
   %tmp7814 = invoke %struct.wxStringBase* @_ZN12wxStringBase6appendEmw( %struct.wxStringBase* null, i32 1, i32 0 )
       to label %bb7834 unwind label %lpad   ; <%struct.wxStringBase*> [#uses=0]
 bb7819:   ; preds = %bb3314
   ret void
 bb7834:   ; preds = %bb7806, %invcont5831
   br label %bb3261
 lpad:   ; preds = %bb7806, %bb5968, %invcont5814, %bb440.i8663, %bb155.i8541, %bb5657, %bb3306
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   ret void
 lpad8185:   ; preds = %invcont5831
-        %exn8185 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn8185 = landingpad {i8*, i32}
                  cleanup
   ret void
 }
 
 declare void @_Z10wxOnAssertPKwiPKcS0_S0_(i32*, i32, i8*, i32*, i32*)
 
 declare zeroext  i8 @_ZN12wxStringBase10ConcatSelfEmPKwm(%struct.wxStringBase*, i32, i32*, i32) 
 

llvm/trunk/test/CodeGen/X86/2008-05-28-LocalRegAllocBug.ll

 ; RUN: llc < %s -mtriple=i386-apple-darwin -regalloc=fast -optimize-regalloc=0
 
 @_ZTVN10Evaluation10GridOutputILi3EEE = external constant [5 x i32 (...)*]    ; <[5 x i32 (...)*]*> [#uses=1]
 
 declare i8* @_Znwm(i32)
 
 declare i8* @__cxa_begin_catch(i8*) nounwind 
 
-define i32 @main(i32 %argc, i8** %argv) {
+define i32 @main(i32 %argc, i8** %argv) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br i1 false, label %bb37, label %bb34
 
 bb34:   ; preds = %entry
   ret i32 1
 
 bb37:   ; preds = %entry
   %tmp12.i.i.i.i.i66 = invoke i8* @_Znwm( i32 12 )
       to label %tmp12.i.i.i.i.i.noexc65 unwind label %lpad243   ; <i8*> [#uses=0]
 
 tmp12.i.i.i.i.i.noexc65:    ; preds = %bb37
   unreachable
 
 lpad243:    ; preds = %bb37
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   %eh_ptr244 = extractvalue { i8*, i32 } %exn, 0
   store i32 (...)** getelementptr ([5 x i32 (...)*], [5 x i32 (...)*]* @_ZTVN10Evaluation10GridOutputILi3EEE, i32 0, i32 2), i32 (...)*** null, align 8
   %tmp133 = call i8* @__cxa_begin_catch( i8* %eh_ptr244 ) nounwind     ; <i8*> [#uses=0]
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/2009-03-13-PHIElimBug.ll

 ; RUN: llc < %s -mtriple=i686-linux | FileCheck %s
 ; Check the register copy comes after the call to f and before the call to g
 ; PR3784
 
 declare i32 @f()
 
 declare i32 @g()
 
-define i32 @phi() {
+define i32 @phi() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %a = call i32 @f()    ; <i32> [#uses=1]
   %b = invoke i32 @g()
       to label %cont unwind label %lpad   ; <i32> [#uses=1]
 
 cont:   ; preds = %entry
   %x = phi i32 [ %b, %entry ]    ; <i32> [#uses=0]
   %aa = call i32 @g()   ; <i32> [#uses=1]
   %bb = invoke i32 @g()
       to label %cont2 unwind label %lpad    ; <i32> [#uses=1]
 
 cont2:    ; preds = %cont
   %xx = phi i32 [ %bb, %cont ]    ; <i32> [#uses=1]
   ret i32 %xx
 
 lpad:   ; preds = %cont, %entry
   %y = phi i32 [ %a, %entry ], [ %aa, %cont ]    ; <i32> [#uses=1]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   ret i32 %y
 }
 
 ; CHECK: call{{.*}}f
 ; CHECK: movl %eax, %esi
 ; CHECK: call{{.*}}g
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/2009-03-16-PHIElimInLPad.ll

 ; RUN: llc < %s -mtriple=i686-linux -asm-verbose | FileCheck %s
 ; Check that register copies in the landing pad come after the EH_LABEL
 
 declare i32 @f()
 
-define i32 @phi(i32 %x) {
+define i32 @phi(i32 %x) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %a = invoke i32 @f()
       to label %cont unwind label %lpad   ; <i32> [#uses=1]
 
 cont:   ; preds = %entry
   %b = invoke i32 @f()
       to label %cont2 unwind label %lpad    ; <i32> [#uses=1]
 
 cont2:    ; preds = %cont
   ret i32 %b
 
 lpad:   ; preds = %cont, %entry
   %v = phi i32 [ %x, %entry ], [ %a, %cont ]    ; <i32> [#uses=1]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   ret i32 %v
 }
 
 ; CHECK: lpad
 ; CHECK-NEXT: Ltmp
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/2009-09-10-LoadFoldingBug.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin10.0 -relocation-model=pic -disable-fp-elim | FileCheck %s
 
 ; It's not legal to fold a load from 32-bit stack slot into a 64-bit
 ; instruction. If done, the instruction does a 64-bit load and that's not
 ; safe. This can happen we a subreg_to_reg 0 has been coalesced. One
 ; exception is when the instruction that folds the load is a move, then we
 ; can simply turn it into a 32-bit load from the stack slot.
 ; rdar://7170444
 
 %struct.ComplexType = type { i32 }
 
-define i32 @t(i32 %clientPort, i32 %pluginID, i32 %requestID, i32 %objectID, i64 %serverIdentifier, i64 %argumentsData, i32 %argumentsLength) ssp {
+define i32 @t(i32 %clientPort, i32 %pluginID, i32 %requestID, i32 %objectID, i64 %serverIdentifier, i64 %argumentsData, i32 %argumentsLength) ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
 ; CHECK: _t:
 ; CHECK: movl 16(%rbp),
   %0 = zext i32 %argumentsLength to i64           ; <i64> [#uses=1]
   %1 = zext i32 %clientPort to i64                ; <i64> [#uses=1]
   %2 = inttoptr i64 %1 to %struct.ComplexType*    ; <%struct.ComplexType*> [#uses=1]
   %3 = invoke i8* @pluginInstance(i8* undef, i32 %pluginID)
           to label %invcont unwind label %lpad    ; <i8*> [#uses=1]
 
 invcont:                                          ; preds = %entry
   %4 = add i32 %requestID, %pluginID              ; <i32> [#uses=0]
   %5 = invoke zeroext i8 @invoke(i8* %3, i32 %objectID, i8* undef, i64 %argumentsData, i32 %argumentsLength, i64* undef, i32* undef)
           to label %invcont1 unwind label %lpad   ; <i8> [#uses=0]
 
 invcont1:                                         ; preds = %invcont
   %6 = getelementptr inbounds %struct.ComplexType, %struct.ComplexType* %2, i64 0, i32 0 ; <i32*> [#uses=1]
   %7 = load i32, i32* %6, align 4                      ; <i32> [#uses=1]
   invoke void @booleanAndDataReply(i32 %7, i32 undef, i32 %requestID, i32 undef, i64 undef, i32 undef)
           to label %invcont2 unwind label %lpad
 
 invcont2:                                         ; preds = %invcont1
   ret i32 0
 
 lpad:                                             ; preds = %invcont1, %invcont, %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   %8 = call i32 @vm_deallocate(i32 undef, i64 0, i64 %0) ; <i32> [#uses=0]
   unreachable
 }
 
 declare i32 @vm_deallocate(i32, i64, i64)
 
 declare i8* @pluginInstance(i8*, i32)
 
 declare zeroext i8 @invoke(i8*, i32, i8*, i64, i32, i64*, i32*)
 
 declare void @booleanAndDataReply(i32, i32, i32, i32, i64, i32)
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll

 %"struct.std::_Vector_base<ASN1Object*,std::allocator<ASN1Object*> >" = type { %"struct.std::_Vector_base<ASN1Object*,std::allocator<ASN1Object*> >::_Vector_impl" }
 %"struct.std::_Vector_base<ASN1Object*,std::allocator<ASN1Object*> >::_Vector_impl" = type { %struct.ASN1Object**, %struct.ASN1Object**, %struct.ASN1Object** }
 %struct.xmstream = type { i8*, i64, i64, i64, i8 }
 
 declare void @_ZNSt6vectorIP10ASN1ObjectSaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%"struct.std::ASN1ObjList"* nocapture, i64, %struct.ASN1Object** nocapture)
 
 declare i32 @_Z17LoadObjectFromBERR8xmstreamPP10ASN1ObjectPPF10ASN1StatusP13ASN1ObjHeaderS3_E(%struct.xmstream*, %struct.ASN1Object**, i32 (%struct.ASN1ObjHeader*, %struct.ASN1Object**)**)
 
-define i32 @_ZN8ASN1Unit4loadER8xmstreamjm18ASN1LengthEncoding(%struct.ASN1Unit* %this, %struct.xmstream* nocapture %stream, i32 %numObjects, i64 %size, i32 %lEncoding) {
+define i32 @_ZN8ASN1Unit4loadER8xmstreamjm18ASN1LengthEncoding(%struct.ASN1Unit* %this, %struct.xmstream* nocapture %stream, i32 %numObjects, i64 %size, i32 %lEncoding) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br label %meshBB85
 
 bb5:                                              ; preds = %bb13.fragment.cl135, %bb13.fragment.cl, %bb.i.i.bbcl.disp, %bb13.fragment
   %0 = invoke i32 @_Z17LoadObjectFromBERR8xmstreamPP10ASN1ObjectPPF10ASN1StatusP13ASN1ObjHeaderS3_E(%struct.xmstream* undef, %struct.ASN1Object** undef, i32 (%struct.ASN1ObjHeader*, %struct.ASN1Object**)** undef)
           to label %meshBB81.bbcl.disp unwind label %lpad ; <i32> [#uses=0]
 
 bb10.fragment:                                    ; preds = %bb13.fragment.bbcl.disp

 bb.i4:                                            ; preds = %bb.i4.bbcl.disp, %bb1.i.fragment.bbcl.disp
   ret i32 undef
 
 bb1.i5:                                           ; preds = %bb.i1
   ret i32 undef
 
 lpad:                                             ; preds = %bb1.i.fragment.cl, %bb1.i.fragment, %bb5
   %.SV10.phi807 = phi i8* [ undef, %bb1.i.fragment.cl ], [ undef, %bb1.i.fragment ], [ undef, %bb5 ] ; <i8*> [#uses=1]
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   %1 = load i8, i8* %.SV10.phi807, align 8            ; <i8> [#uses=0]
   br i1 undef, label %meshBB81.bbcl.disp, label %bb13.fragment.bbcl.disp
 
 bb.i1:                                            ; preds = %bb.i.i.bbcl.disp
   br i1 undef, label %meshBB81.bbcl.disp, label %bb1.i5
 
 meshBB81:                                         ; preds = %meshBB81.bbcl.disp, %bb.i.i.bbcl.disp

llvm/trunk/test/CodeGen/X86/2010-04-06-SSEDomainFixCrash.ll

 ; RUN: llc < %s -O3 -relocation-model=pic -disable-fp-elim -mcpu=nocona
 ;
 ; This test case is reduced from Bullet. It crashes SSEDomainFix.
 ;
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 target triple = "i386-apple-darwin10.0"
 
 declare i32 @_ZN11HullLibrary16CreateConvexHullERK8HullDescR10HullResult(i8*, i8* nocapture, i8* nocapture) ssp align 2
 
-define void @_ZN17btSoftBodyHelpers4DrawEP10btSoftBodyP12btIDebugDrawi(i8* %psb, i8* %idraw, i32 %drawflags) ssp align 2 {
+define void @_ZN17btSoftBodyHelpers4DrawEP10btSoftBodyP12btIDebugDrawi(i8* %psb, i8* %idraw, i32 %drawflags) ssp align 2 personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br i1 undef, label %bb92, label %bb58
 
 bb58:                                             ; preds = %entry
   %0 = invoke i32 @_ZN11HullLibrary16CreateConvexHullERK8HullDescR10HullResult(i8* undef, i8* undef, i8* undef)
           to label %invcont64 unwind label %lpad159 ; <i32> [#uses=0]
 
 invcont64:                                        ; preds = %bb58
bb.i265:                                          ; preds = %bb.i265, %invcont65
   %7 = fsub float 0.000000e+00, %6                ; <float> [#uses=1]
   store float %7, float* undef, align 4
   br label %bb.i265
 
 bb92:                                             ; preds = %entry
   unreachable
 
 lpad159:                                          ; preds = %bb58
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/2010-04-30-LocalAlloc-LandingPad.ll

 ; RUN: llc < %s -O0 -regalloc=fast -relocation-model=pic -disable-fp-elim | FileCheck %s
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 target triple = "i386-apple-darwin10.0.0"
 
 %struct.S = type { [2 x i8*] }
 
 @_ZTIi = external constant i8*                    ; <i8**> [#uses=1]
 @.str = internal constant [4 x i8] c"%p\0A\00"    ; <[4 x i8]*> [#uses=1]
 @llvm.used = appending global [1 x i8*] [i8* bitcast (i8* (%struct.S*, i32, %struct.S*)* @_Z4test1SiS_ to i8*)], section "llvm.metadata" ; <[1 x i8*]*> [#uses=0]
 
 ; Verify that %esi gets spilled before the call.
 ; CHECK: Z4test1SiS
 ; CHECK: movl %esi,{{.*}}(%ebp) 
 ; CHECK: calll __Z6throwsv
 
-define i8* @_Z4test1SiS_(%struct.S* byval %s1, i32 %n, %struct.S* byval %s2) ssp {
+define i8* @_Z4test1SiS_(%struct.S* byval %s1, i32 %n, %struct.S* byval %s2) ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %retval = alloca i8*, align 4                   ; <i8**> [#uses=2]
   %n.addr = alloca i32, align 4                   ; <i32*> [#uses=1]
   %_rethrow = alloca i8*                          ; <i8**> [#uses=4]
   %0 = alloca i32, align 4                        ; <i32*> [#uses=1]
   %cleanup.dst = alloca i32                       ; <i32*> [#uses=3]
   %cleanup.dst7 = alloca i32                      ; <i32*> [#uses=6]
   store i32 %n, i32* %n.addr
   invoke void @_Z6throwsv()
           to label %invoke.cont unwind label %try.handler
 
 invoke.cont:                                      ; preds = %entry
   store i32 1, i32* %cleanup.dst7
   br label %finally
 
 terminate.handler:                                ; preds = %match.end
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
            cleanup
   call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 
 try.handler:                                      ; preds = %entry
-  %exc1.ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %exc1.ptr = landingpad { i8*, i32 }
            catch i8* null
   %exc1 = extractvalue { i8*, i32 } %exc1.ptr, 0
   %selector = extractvalue { i8*, i32 } %exc1.ptr, 1
   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) ; <i32> [#uses=1]
   %3 = icmp eq i32 %selector, %2                  ; <i1> [#uses=1]
   br i1 %3, label %match, label %catch.next
 
 match:                                            ; preds = %try.handler
   %4 = call i8* @__cxa_begin_catch(i8* %exc1)     ; <i8*> [#uses=1]
   %5 = bitcast i8* %4 to i32*                     ; <i32*> [#uses=1]
   %6 = load i32, i32* %5                               ; <i32> [#uses=1]
   store i32 %6, i32* %0
   %call = invoke i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), %struct.S* %s2)
           to label %invoke.cont2 unwind label %match.handler ; <i32> [#uses=0]
 
 invoke.cont2:                                     ; preds = %match
   store i32 1, i32* %cleanup.dst
   br label %match.end
 
 match.handler:                                    ; preds = %match
-  %exc3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %exc3 = landingpad { i8*, i32 }
            cleanup
   %7 = extractvalue { i8*, i32 } %exc3, 0
   store i8* %7, i8** %_rethrow
   store i32 2, i32* %cleanup.dst
   br label %match.end
 
 cleanup.pad:                                      ; preds = %cleanup.switch
   store i32 1, i32* %cleanup.dst7

llvm/trunk/test/CodeGen/X86/2010-08-04-MingWCrash.ll

 ; RUN: llc < %s -mtriple=i386-pc-mingw32
 
-define void @func() nounwind {
+define void @func() nounwind personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 invoke.cont:
   %call = tail call i8* @malloc()
   %a = invoke i32 @bar()
           to label %bb1 unwind label %lpad
 
 bb1:
   ret void
 
 lpad:
-  %exn.ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %exn.ptr = landingpad { i8*, i32 }
            catch i8* null
   %exn = extractvalue { i8*, i32 } %exn.ptr, 0
   %eh.selector = extractvalue { i8*, i32 } %exn.ptr, 1
   %ehspec.fails = icmp slt i32 %eh.selector, 0
   br i1 %ehspec.fails, label %ehspec.unexpected, label %cleanup
 
 cleanup:
   resume { i8*, i32 } %exn.ptr

llvm/trunk/test/CodeGen/X86/2012-01-10-UndefExceptionEdge.ll

 ; so the return value can spill.
 ;
 ; <rdar://problem/10664933>
 
 @Exception = external unnamed_addr constant { i8*, i8* }
 
 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
 
-define void @f(i32* nocapture %arg, i32* nocapture %arg1, i32* nocapture %arg2, i32* nocapture %arg3, i32 %arg4, i32 %arg5) optsize ssp {
+define void @f(i32* nocapture %arg, i32* nocapture %arg1, i32* nocapture %arg2, i32* nocapture %arg3, i32 %arg4, i32 %arg5) optsize ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 bb:
   br i1 undef, label %bb6, label %bb7
 
 bb6:                                              ; preds = %bb
   %tmp = select i1 false, i32 0, i32 undef
   br label %bb7
 
 bb7:                                              ; preds = %bb6, %bb
bb11:                                             ; preds = %bb7
   %tmp16 = getelementptr i32, i32* %tmp13, i32 undef
   %tmp17 = zext i32 %tmp9 to i64
   %tmp18 = add i64 %tmp17, -1
   %tmp19 = icmp ugt i64 %tmp18, 4294967295
   br i1 %tmp19, label %bb29, label %bb31
 
 bb20:                                             ; preds = %bb43, %bb41, %bb29, %bb7
   %tmp21 = phi i32 [ undef, %bb7 ], [ %tmp12, %bb43 ], [ %tmp12, %bb29 ], [ %tmp12, %bb41 ]
-  %tmp22 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp22 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8* }* @Exception to i8*)
   br i1 undef, label %bb23, label %bb69
 
 bb23:                                             ; preds = %bb38, %bb20
   %tmp24 = phi i32 [ %tmp12, %bb38 ], [ %tmp21, %bb20 ]
   %tmp25 = icmp eq i32 %tmp24, 0
   br i1 %tmp25, label %bb28, label %bb26
 

llvm/trunk/test/CodeGen/X86/2012-05-19-CoalescerCrash.ll

 ; RUN: llc < %s -verify-coalescing
 ; PR12892
 ;
 ; Dead code elimination during coalesing causes a live range to split into two
 ; virtual registers. Stale identity copies that had already been joined were
 ; interfering with the liveness computations.
 
 target triple = "i386-pc-linux-gnu"
 
-define void @_ZN4llvm17AsmMatcherEmitter3runERNS_11raw_ostreamE() align 2 {
+define void @_ZN4llvm17AsmMatcherEmitter3runERNS_11raw_ostreamE() align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @_ZNK4llvm13CodeGenTarget12getAsmParserEv()
           to label %1 unwind label %5
 
 ; <label>:1                                       ; preds = %0
   invoke void @_ZNK4llvm6Record16getValueAsStringENS_9StringRefE()
           to label %4 unwind label %2
 
 ; <label>:2                                       ; preds = %1
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 ; <label>:4                                       ; preds = %1
   invoke void @_ZN4llvm18isCurrentDebugTypeEPKc()
           to label %12 unwind label %7
 
 ; <label>:5                                       ; preds = %0
-  %6 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %6 = landingpad { i8*, i32 }
           cleanup
   br label %33
 
 ; <label>:7                                       ; preds = %4
-  %8 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %8 = landingpad { i8*, i32 }
           cleanup
   br label %9
 
 ; <label>:9                                       ; preds = %28, %7
   %10 = phi { i8*, i32 } [ %29, %28 ], [ %8, %7 ]
   %11 = extractvalue { i8*, i32 } %10, 1
   invoke fastcc void @_ZN12_GLOBAL__N_114AsmMatcherInfoD2Ev()
           to label %32 unwind label %35
 
 ; <label>:12                                      ; preds = %4
   invoke void @_ZNK4llvm13CodeGenTarget10getRegBankEv()
           to label %13 unwind label %16
 
 ; <label>:13                                      ; preds = %12
   br label %14
 
 ; <label>:14                                      ; preds = %20, %13
   %15 = icmp eq i32 undef, 0
   br i1 %15, label %20, label %18
 
 ; <label>:16                                      ; preds = %12
-  %17 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %17 = landingpad { i8*, i32 }
           cleanup
   br label %26
 
 ; <label>:18                                      ; preds = %14
   invoke void @_ZNSs4_Rep9_S_createEjjRKSaIcE()
           to label %19 unwind label %21
 
 ; <label>:19                                      ; preds = %18
   unreachable
 
 ; <label>:20                                      ; preds = %14
   br label %14
 
 ; <label>:21                                      ; preds = %18
-  %22 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %22 = landingpad { i8*, i32 }
           cleanup
   %23 = extractvalue { i8*, i32 } %22, 1
   br i1 undef, label %26, label %24
 
 ; <label>:24                                      ; preds = %21
   br i1 undef, label %25, label %26
 
 ; <label>:25                                      ; preds = %24
   unreachable
 
 ; <label>:26                                      ; preds = %24, %21, %16
   %27 = phi i32 [ 0, %16 ], [ %23, %21 ], [ %23, %24 ]
   invoke void @_ZNSt6vectorISt4pairISsSsESaIS1_EED1Ev()
           to label %28 unwind label %30
 
 ; <label>:28                                      ; preds = %26
   %29 = insertvalue { i8*, i32 } undef, i32 %27, 1
   br label %9
 
 ; <label>:30                                      ; preds = %26
-  %31 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %31 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 
 ; <label>:32                                      ; preds = %9
   br label %33
 
 ; <label>:33                                      ; preds = %32, %5
   %34 = phi i32 [ undef, %5 ], [ %11, %32 ]
   unreachable
 
 ; <label>:35                                      ; preds = %9
-  %36 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %36 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 declare void @_ZNK4llvm13CodeGenTarget12getAsmParserEv()
 
 declare i32 @__gxx_personality_v0(...)
 

llvm/trunk/test/CodeGen/X86/2012-11-30-misched-dbg.ll

 ;
 ; CHECK: @main
 ; CHECK: DEBUG_VALUE: main:X
 ; CHECK: call
 
 %"class.__gnu_cxx::hash_map" = type { %"class.__gnu_cxx::hashtable" }
 %"class.__gnu_cxx::hashtable" = type { i64, i64, i64, i64, i64, i64 }
 
-define void @main() uwtable ssp {
+define void @main() uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %X = alloca %"class.__gnu_cxx::hash_map", align 8
   br i1 undef, label %cond.true, label %cond.end
 
 cond.true:                                        ; preds = %entry
   unreachable
 
 cond.end:                                         ; preds = %entry
   call void @llvm.dbg.declare(metadata %"class.__gnu_cxx::hash_map"* %X, metadata !31, metadata !DIExpression()), !dbg !DILocation(scope: !37)
   %_M_num_elements.i.i.i.i = getelementptr inbounds %"class.__gnu_cxx::hash_map", %"class.__gnu_cxx::hash_map"* %X, i64 0, i32 0, i32 5
   invoke void @_Znwm()
           to label %exit.i unwind label %lpad2.i.i.i.i
 
 exit.i:                                           ; preds = %cond.end
   unreachable
 
 lpad2.i.i.i.i:                                    ; preds = %cond.end
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   br i1 undef, label %lpad.body.i.i, label %if.then.i.i.i.i.i.i.i.i
 
 if.then.i.i.i.i.i.i.i.i:                          ; preds = %lpad2.i.i.i.i
   unreachable
 
 lpad.body.i.i:                                    ; preds = %lpad2.i.i.i.i
   resume { i8*, i32 } %0

llvm/trunk/test/CodeGen/X86/asm-label2.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin10 -O0 < %s | FileCheck %s
 
 ; test that we print a label that we use. We had a bug where
 ; we would print the jump, but not the label because it was considered
 ; a fall through.
 
 ; CHECK:        jmp     LBB0_1
 ; CHECK: LBB0_1:
 
-define void @foobar()  {
+define void @foobar() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_zed()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   ret void
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare void @_zed() ssp align 2
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/block-placement.ll

exit:
   %result2 = call i32 @h(i32 %result)
   ret i32 %result
 }
 
 !2 = !{!"branch_weights", i32 3, i32 1}
 
 declare i32 @__gxx_personality_v0(...)
 
-define void @test_eh_lpad_successor() {
+define void @test_eh_lpad_successor() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; Some times the landing pad ends up as the first successor of an invoke block.
 ; When this happens, a strange result used to fall out of updateTerminators: we
 ; didn't correctly locate the fallthrough successor, assuming blindly that the
 ; first one was the fallthrough successor. As a result, we would add an
 ; erroneous jump to the landing pad thinking *that* was the default successor.
 ; CHECK: test_eh_lpad_successor
 ; CHECK: %entry
 ; CHECK-NOT: jmp
 ; CHECK: %loop
 
 entry:
   invoke i32 @f() to label %preheader unwind label %lpad
 
 preheader:
   br label %loop
 
 lpad:
-  %lpad.val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %lpad.val = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } %lpad.val
 
 loop:
   br label %loop
 }
 
 declare void @fake_throw() noreturn
 
-define void @test_eh_throw() {
+define void @test_eh_throw() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; For blocks containing a 'throw' (or similar functionality), we have
 ; a no-return invoke. In this case, only EH successors will exist, and
 ; fallthrough simply won't occur. Make sure we don't crash trying to update
 ; terminators for such constructs.
 ;
 ; CHECK: test_eh_throw
 ; CHECK: %entry
 ; CHECK: %cleanup
 
 entry:
   invoke void @fake_throw() to label %continue unwind label %cleanup
 
 continue:
   unreachable
 
 cleanup:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   unreachable
 }
 
 define void @test_unnatural_cfg_backwards_inner_loop() {
 ; Test that when we encounter an unnatural CFG structure after having formed
 ; a chain for an inner loop which happened to be laid out backwards we don't
 ; attempt to merge onto the wrong end of the inner loop just because we find it

llvm/trunk/test/CodeGen/X86/branchfolding-landingpads.ll

 declare void @foo()
 
 ; Function Attrs: noreturn
 declare void @_throw()
 
 ; CHECK-LABEL: @main
 ; CHECK: %unreachable
 
-define i32 @main(i8* %cleanup) {
+define i32 @main(i8* %cleanup) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_throw() #0
           to label %unreachable unwind label %catch.dispatch9
 
 catch.dispatch9:                                  ; preds = %entry
-  %tmp13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp13 = landingpad { i8*, i32 }
           cleanup
           catch i8* null
   invoke void @_throw() #0
           to label %unreachable unwind label %lpad31
 
 lpad31:                                           ; preds = %catch.dispatch9
-  %tmp20 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp20 = landingpad { i8*, i32 }
           cleanup
           catch i8* null
   call void @foo()
   unreachable
 
 unreachable:                                      ; preds = %catch.dispatch9, %entry
   unreachable
 }
 
 attributes #0 = { noreturn }
 

llvm/trunk/test/CodeGen/X86/catch.ll

 ; RUN: llc < %s -mtriple=x86_64-pc-linux -relocation-model=pic | FileCheck %s
 
 ; PR18390
 ; We used to assert creating this label. The name itself is not critical. It
 ; just needs to be a unique local symbol.
 ; CHECK:      .L.Lstr.DW.stub:
 ; CHECK-NEXT: .quad   .Lstr
 
 @str = private unnamed_addr constant [12 x i8] c"NSException\00"
-define void @f() {
+define void @f() personality i8* bitcast (void ()* @h to i8*) {
   invoke void @g()
           to label %invoke.cont unwind label %lpad
 invoke.cont:
   ret void
 lpad:
-  %tmp14 = landingpad { i8*, i32 } personality i8* bitcast (void ()* @h to i8*)
+  %tmp14 = landingpad { i8*, i32 }
            catch i8* getelementptr inbounds ([12 x i8], [12 x i8]* @str, i64 0, i64 0)
   ret void
 }
 declare void @g()
 declare void @h()

llvm/trunk/test/CodeGen/X86/cfi.ll

 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck --check-prefix=STATIC %s
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -relocation-model=pic | FileCheck --check-prefix=PIC %s
 
 ; STATIC: .cfi_personality 3, __gxx_personality_v0
 ; STATIC: .cfi_lsda 3, .Lexception0
 
 ; PIC: .cfi_personality 155, DW.ref.__gxx_personality_v0
 ; PIC: .cfi_lsda 27, .Lexception0
 
 
-define void @bar() {
+define void @bar() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %call = invoke i32 @foo()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             catch i8* null
   ret void
 }
 
 declare i32 @foo()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/code_placement_eh.ll

 ; RUN: llc < %s
 
 ; CodePlacementOpt shouldn't try to modify this loop because
 ; it involves EH edges.
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 target triple = "i386-apple-darwin10.0"
 
-define void @foo() {
+define void @foo() personality i32 (...)* @__gxx_personality_v0 {
 invcont5:
   br label %bb15
 
 .noexc3:                                          ; preds = %bb15
   br i1 undef, label %bb18.i5.i, label %bb15
 
 .noexc6.i.i:                                      ; preds = %bb18.i5.i
   %tmp2021 = invoke float @cosf(float 0.000000e+00) readonly
           to label %bb18.i5.i unwind label %lpad.i.i ; <float> [#uses=0]
 
 bb18.i5.i:                                        ; preds = %.noexc6.i.i, %bb51.i
   %tmp2019 = invoke float @sinf(float 0.000000e+00) readonly
           to label %.noexc6.i.i unwind label %lpad.i.i ; <float> [#uses=0]
 
 lpad.i.i:                                         ; preds = %bb18.i5.i, %.noexc6.i.i
-  %lpadval.i.i = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpadval.i.i = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 
 lpad59.i:                                         ; preds = %bb15
-  %lpadval60.i.i = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpadval60.i.i = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 
 bb15:                                             ; preds = %.noexc3, %invcont5
   invoke fastcc void @_ZN28btHashedOverlappingPairCacheC2Ev()
           to label %.noexc3 unwind label %lpad59.i
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare float @sinf(float) readonly
 
 declare float @cosf(float) readonly
 
 declare fastcc void @_ZN28btHashedOverlappingPairCacheC2Ev() align 2

llvm/trunk/test/CodeGen/X86/dwarf-eh-prepare.ll

 ; RUN: opt -mtriple=x86_64-linux-gnu -dwarfehprepare < %s -S | FileCheck %s
 
 ; Check basic functionality of IR-to-IR DWARF EH preparation. This should
 ; eliminate resumes. This pass requires a TargetMachine, so we put it under X86
 ; and provide an x86 triple.
 
 @int_typeinfo = global i8 0
 
 declare void @might_throw()
 declare void @cleanup()
 
-define i32 @simple_cleanup_catch() {
+define i32 @simple_cleanup_catch() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %cont unwind label %lpad
 
 ; CHECK-LABEL: define i32 @simple_cleanup_catch()
 ; CHECK: invoke void @might_throw()
 
 cont:
   ret i32 0
 
 ; CHECK: ret i32 0
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %ehvals = landingpad { i8*, i32 }
       cleanup
       catch i8* @int_typeinfo
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   call void @cleanup()
   %int_sel = call i32 @llvm.eh.typeid.for(i8* @int_typeinfo)
   %int_match = icmp eq i32 %ehsel, %int_sel
   br i1 %int_match, label %catch_int, label %eh.resume
 
 ; CHECK: lpad:
-; CHECK: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: landingpad { i8*, i32 }
 ; CHECK: call void @cleanup()
 ; CHECK: call i32 @llvm.eh.typeid.for
 ; CHECK: br i1
 
 catch_int:
   ret i32 1
 
 ; CHECK: catch_int:
 ; CHECK: ret i32 1
 
 eh.resume:
   %tmp_ehvals = insertvalue { i8*, i32 } undef, i8* %ehptr, 0
   %new_ehvals = insertvalue { i8*, i32 } %tmp_ehvals, i32 %ehsel, 1
   resume { i8*, i32 } %new_ehvals
 
 ; CHECK: eh.resume:
 ; CHECK-NEXT: call void @_Unwind_Resume(i8* %ehptr)
 }
 
 
-define i32 @catch_no_resume() {
+define i32 @catch_no_resume() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %cont unwind label %lpad
 
 cont:
   ret i32 0
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %ehvals = landingpad { i8*, i32 }
       catch i8* @int_typeinfo
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   %int_sel = call i32 @llvm.eh.typeid.for(i8* @int_typeinfo)
   %int_match = icmp eq i32 %ehsel, %int_sel
   br i1 %int_match, label %catch_int, label %eh.resume
 
 catch_int:
   ret i32 1
 
 eh.resume:
   %tmp_ehvals = insertvalue { i8*, i32 } undef, i8* %ehptr, 0
   %new_ehvals = insertvalue { i8*, i32 } %tmp_ehvals, i32 %ehsel, 1
   resume { i8*, i32 } %new_ehvals
 }
 
 ; Check that we can prune the unreachable resume instruction.
 
-; CHECK-LABEL: define i32 @catch_no_resume() {
+; CHECK-LABEL: define i32 @catch_no_resume() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK: invoke void @might_throw()
 ; CHECK: ret i32 0
 ; CHECK: lpad:
-; CHECK: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: landingpad { i8*, i32 }
 ; CHECK-NOT: br i1
 ; CHECK: ret i32 1
 ; CHECK-NOT: call void @_Unwind_Resume
 ; CHECK: {{^[}]}}
 
 
-define i32 @catch_cleanup_merge() {
+define i32 @catch_cleanup_merge() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %inner_invoke unwind label %outer_lpad
 inner_invoke:
   invoke void @might_throw()
           to label %cont unwind label %inner_lpad
 cont:
   ret i32 0
 
 outer_lpad:
-  %ehvals1 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %ehvals1 = landingpad { i8*, i32 }
       catch i8* @int_typeinfo
   br label %catch.dispatch
 
 inner_lpad:
-  %ehvals2 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %ehvals2 = landingpad { i8*, i32 }
       cleanup
       catch i8* @int_typeinfo
   call void @cleanup()
   br label %catch.dispatch
 
 catch.dispatch:
   %ehvals = phi { i8*, i32 } [ %ehvals1, %outer_lpad ], [ %ehvals2, %inner_lpad ]
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0

 ; We can't prune this merge because one landingpad is a cleanup pad.
 
 ; CHECK-LABEL: define i32 @catch_cleanup_merge()
 ; CHECK: invoke void @might_throw()
 ; CHECK: invoke void @might_throw()
 ; CHECK: ret i32 0
 ;
 ; CHECK: outer_lpad:
-; CHECK: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: landingpad { i8*, i32 }
 ; CHECK: br label %catch.dispatch
 ;
 ; CHECK: inner_lpad:
-; CHECK: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: landingpad { i8*, i32 }
 ; CHECK: call void @cleanup()
 ; CHECK: br label %catch.dispatch
 ;
 ; CHECK: catch.dispatch:
 ; CHECK: call i32 @llvm.eh.typeid.for
 ; CHECK: br i1
 ; CHECK: catch_int:
 ; CHECK: ret i32 1
 ; CHECK: eh.resume:
 ; CHECK-NEXT: call void @_Unwind_Resume(i8* %ehptr)
 
 declare i32 @__gxx_personality_v0(...)
 declare i32 @llvm.eh.typeid.for(i8*)

llvm/trunk/test/CodeGen/X86/eh-label.ll

 ; RUN: llc < %s -mtriple=x86_64-pc-linux | FileCheck %s
 ; Test that we don't crashe if the .Lfunc_end0 name is taken.
 
 declare void @g()
 
-define void @f() {
+define void @f() personality i8* bitcast (void ()* @g to i8*) {
 bb0:
   call void asm ".Lfunc_end0:", ""()
 ; CHECK: #APP
 ; CHECK-NEXT: .Lfunc_end0:
 ; CHECK-NEXT: #NO_APP
 
   invoke void @g() to label %bb2 unwind label %bb1
 bb1:
-  landingpad { i8*, i32 } personality i8* bitcast (void ()* @g to i8*)
+  landingpad { i8*, i32 }
           catch i8* null
   call void @g()
   ret void
 bb2:
   ret void
 
 ; CHECK: [[END:.Lfunc_end.*]]:
 ; CHECK: .long  [[END]]-
 }

llvm/trunk/test/CodeGen/X86/exception-label.ll

 ; RUN: llc < %s -mtriple=x86_64-pc-linux | FileCheck %s
 
 ; Test that we can handle .Lexception0 being defined. We used to crash.
 
 ; CHECK: .cfi_lsda 3, [[LABEL:.*]]
 ; CHECK: [[LABEL]]:
 ; CHECK-NEXT: .byte   255                     # @LPStart Encoding = omit
 
 declare void @g()
 
-define void @f() {
+define void @f() personality i8* bitcast (void ()* @g to i8*) {
 bb0:
   call void asm ".Lexception0:", ""()
   invoke void @g()
           to label %bb2 unwind label %bb1
 bb1:
-  landingpad { i8*, i32 } personality i8* bitcast (void ()* @g to i8*)
+  landingpad { i8*, i32 }
           catch i8* null
   br label %bb2
 
 bb2:
   ret void
 }

llvm/trunk/test/CodeGen/X86/fast-isel-cmp-branch.ll

 ; RUN: llc -O0 -mtriple=x86_64-linux -asm-verbose=false < %s | FileCheck %s
 ; RUN: llc -O0 -mtriple=x86_64-windows-itanium -asm-verbose=false < %s | FileCheck %s
 ; rdar://8337108
 
 ; Fast-isel shouldn't try to look through the compare because it's in a
 ; different basic block, so its operands aren't necessarily exported
 ; for cross-block usage.
 
 ; CHECK: movb    %al, [[OFS:[0-9]*]](%rsp)
 ; CHECK: callq   {{_?}}bar
 ; CHECK: movb    [[OFS]](%rsp), %al
 
 declare void @bar()
 
-define void @foo(i32 %a, i32 %b) nounwind {
+define void @foo(i32 %a, i32 %b) nounwind personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %q = add i32 %a, 7
   %r = add i32 %b, 9
   %t = icmp ult i32 %q, %r
   invoke void @bar() to label %next unwind label %unw
 next:
   br i1 %t, label %true, label %return
 true:
   call void @bar()
   br label %return
 return:
   ret void
 unw:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/fast-isel-gep.ll

 ; X64: movslq %e[[A1]], %rax
 ; X64-NEXT: (%r[[A0]],%rax),
 ; X64: ret
 }
 
 ; PR9500, rdar://9156159 - Don't do non-local address mode folding,
 ; because it may require values which wouldn't otherwise be live out
 ; of their blocks.
-define void @test6() {
+define void @test6() personality i32 (...)* @__gxx_personality_v0 {
 if.end:                                           ; preds = %if.then, %invoke.cont
   %tmp15 = load i64, i64* undef
   %dec = add i64 %tmp15, 13
   store i64 %dec, i64* undef
   %call17 = invoke i8* @_ZNK18G__FastAllocString4dataEv()
           to label %invoke.cont16 unwind label %lpad
 
 invoke.cont16:                                    ; preds = %if.then14
   %arrayidx18 = getelementptr inbounds i8, i8* %call17, i64 %dec
   store i8 0, i8* %arrayidx18
   unreachable
 
 lpad:                                             ; preds = %if.end19, %if.then14, %if.end, %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 declare i8* @_ZNK18G__FastAllocString4dataEv() nounwind
 
 
 ; PR10605 / rdar://9930964 - Don't fold loads incorrectly.  The load should
 ; happen before the store.  

llvm/trunk/test/CodeGen/X86/gcc_except_table.ll

 ; RUN: llc -mtriple x86_64-apple-darwin %s -o -   | FileCheck %s   --check-prefix=APPLE
 ; RUN: llc -mtriple x86_64-pc-windows-gnu %s -o - | FileCheck %s   --check-prefix=MINGW64
 ; RUN: llc -mtriple i686-pc-windows-gnu %s -o -   | FileCheck %s   --check-prefix=MINGW32
 @_ZTIi = external constant i8*
 
-define i32 @main() uwtable optsize ssp {
+define i32 @main() uwtable optsize ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; APPLE: .cfi_startproc
 ; APPLE: .cfi_personality 155, ___gxx_personality_v0
 ; APPLE: .cfi_lsda 16, Lexception0
 ; APPLE: .cfi_def_cfa_offset 16
 ; APPLE: callq __Unwind_Resume
 ; APPLE: .cfi_endproc
 ; APPLE: GCC_except_table0:
 ; APPLE: Lexception0:

 ; MINGW32: GCC_except_table0:
 ; MINGW32: Lexception0:
 
 entry:
   invoke void @_Z1fv() optsize
           to label %try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
   br label %eh.resume
 
 try.cont:
   ret i32 0
 
 eh.resume:
   resume { i8*, i32 } %0
 }
 
 declare void @_Z1fv() optsize
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/gcc_except_table_functions.ll

 ; RUN: llc -mtriple x86_64-pc-linux-gnu < %s | FileCheck %s
 
 ; This test demonstrates that it is possible to use functions for typeinfo
 ; instead of global variables. While __gxx_personality_v0 would never know what
 ; to do with them, other EH schemes such as SEH might use them.
 
 declare i32 @__gxx_personality_v0(...)
 declare void @filt0()
 declare void @filt1()
 declare void @_Z1fv()
 declare i32 @llvm.eh.typeid.for(i8*)
 
-define i32 @main() uwtable {
+define i32 @main() uwtable personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @_Z1fv()
           to label %try.cont unwind label %lpad
 
 try.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (void ()* @filt0 to i8*)
           catch i8* bitcast (void ()* @filt1 to i8*)
   %sel = extractvalue { i8*, i32 } %0, 1
   %id0 = call i32 @llvm.eh.typeid.for(i8* bitcast (void ()* @filt0 to i8*))
   %is_f0 = icmp eq i32 %sel, %id0
   br i1 %is_f0, label %try.cont, label %check_f1
 

llvm/trunk/test/CodeGen/X86/global-sections.ll

 
 ; LINUX-SECTIONS-PIC: .section        .text.F2,"ax",@progbits
 ; LINUX-SECTIONS-PIC: .size   F2,
 ; LINUX-SECTIONS-PIC-NEXT: .cfi_endproc
 ; LINUX-SECTIONS-PIC-NEXT: .section        .rodata.F2,"a",@progbits
 
 declare void @G()
 
-define void @F3(i32 %y) {
+define void @F3(i32 %y) personality i8* bitcast (void ()* @G to i8*) {
 bb0:
   invoke void @G()
           to label %bb2 unwind label %bb1
 bb1:
-  landingpad { i8*, i32 } personality i8* bitcast (void ()* @G to i8*)
+  landingpad { i8*, i32 }
           catch i8* null
   br label %bb2
 bb2:
 
 switch i32 %y, label %bb7 [
     i32 1, label %bb3
     i32 2, label %bb4
     i32 3, label %bb5

llvm/trunk/test/CodeGen/X86/inalloca-invoke.ll

 ; RUN: llc < %s -mtriple=i686-pc-win32 | FileCheck %s
 
 %Iter = type { i32, i32, i32 }
 
 %frame.reverse = type { %Iter, %Iter }
 
 declare i32 @pers(...)
 declare void @llvm.stackrestore(i8*)
 declare i8* @llvm.stacksave()
 declare void @begin(%Iter* sret)
 declare void @plus(%Iter* sret, %Iter*, i32)
 declare void @reverse(%frame.reverse* inalloca align 4)
 
-define i32 @main() {
+define i32 @main() personality i32 (...)* @pers {
   %temp.lvalue = alloca %Iter
   br label %blah
 
 blah:
   %inalloca.save = call i8* @llvm.stacksave()
   %rev_args = alloca inalloca %frame.reverse, align 4
   %beg = getelementptr %frame.reverse, %frame.reverse* %rev_args, i32 0, i32 0
   %end = getelementptr %frame.reverse, %frame.reverse* %rev_args, i32 0, i32 1
; CHECK:  calll _begin
   invoke void @reverse(%frame.reverse* inalloca align 4 %rev_args)
           to label %invoke.cont5 unwind label %lpad
 
 invoke.cont5:                                     ; preds = %invoke.cont
   call void @llvm.stackrestore(i8* %inalloca.save)
   ret i32 0
 
 lpad:                                             ; preds = %invoke.cont, %entry
-  %lp = landingpad { i8*, i32 } personality i32 (...)* @pers
+  %lp = landingpad { i8*, i32 }
           cleanup
   unreachable
 }

llvm/trunk/test/CodeGen/X86/indirect-hidden.ll

 ; RUN: llc -mtriple=i686-apple-macosx -o - %s | FileCheck %s
 
 ; x86 doesn't normally use indirect symbols, particularly hidden ones, but it
 ; can be tricked into it for exception-handling typeids.
 
 @hidden_typeid = external hidden constant i8*
 @normal_typeid = external constant i8*
 
 declare void @throws()
 
-define void @get_indirect_hidden() {
+define void @get_indirect_hidden() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @throws() to label %end unwind label %lpad
 lpad:
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @hidden_typeid to i8*)
   br label %end
 
 end:
   ret void
 }
 
-define void @get_indirect() {
+define void @get_indirect() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @throws() to label %end unwind label %lpad
 lpad:
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @normal_typeid to i8*)
   br label %end
 
 end:
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/large-gep-chain.ll

 ; RUN: llc < %s -O0 -march x86 -o /dev/null
 ; <rdar://problem/12445434>
 
 %0 = type { i32, float* }
 
 @0 = external unnamed_addr constant [27 x i8], align 1
 @1 = external unnamed_addr constant [26 x i8], align 1
 @2 = external unnamed_addr constant [18 x i8], align 1
 @3 = external unnamed_addr constant [15 x i8], align 1
 @4 = external unnamed_addr constant [20 x i8], align 1
 @5 = external unnamed_addr constant [21 x i8], align 1
 @6 = external unnamed_addr constant [12 x i8], align 1
 @7 = external unnamed_addr constant [27 x i8], align 1
 @8 = external unnamed_addr constant [63 x i8], align 1
 
-define void @main() uwtable ssp {
+define void @main() uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 bb:
   br i1 undef, label %bb1, label %bb2
 
 bb1:                                              ; preds = %bb
   br label %bb25362
 
 bb2:                                              ; preds = %bb
   %tmp = getelementptr inbounds float, float* null, i64 1

 bb25274:                                          ; preds = %bb25273
   invoke void @bar()
           to label %bb25275 unwind label %bb25276
 
 bb25275:                                          ; preds = %bb25274
   br label %bb25272
 
 bb25276:                                          ; preds = %bb25283, %bb25274, %bb25273
-  %tmp25277 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp25277 = landingpad { i8*, i32 }
           cleanup
   br label %bb25361
 
 bb25278:                                          ; preds = %bb25272
   br label %bb25279
 
 bb25279:                                          ; preds = %bb25284, %bb25278
   br i1 undef, label %bb25280, label %bb25285

 bb25296:                                          ; preds = %bb25295, %bb25294
   invoke void @baz()
           to label %bb25297 unwind label %bb25298
 
 bb25297:                                          ; preds = %bb25296
   br label %bb25300
 
 bb25298:                                          ; preds = %bb25296, %bb25295, %bb25290, %bb25287
-  %tmp25299 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp25299 = landingpad { i8*, i32 }
           cleanup
   br label %bb25360
 
 bb25300:                                          ; preds = %bb25297, %bb25289, %bb25288
   br i1 undef, label %bb25301, label %bb25302
 
 bb25301:                                          ; preds = %bb25300
   br label %bb25303

 bb25322:                                          ; preds = %bb25321, %bb25320
   br label %bb25326
 
 bb25323:                                          ; preds = %bb25319
   invoke void @qux()
           to label %bb25326 unwind label %bb25324
 
 bb25324:                                          ; preds = %bb25357, %bb25344, %bb25343, %bb25342, %bb25337, %bb25334, %bb25333, %bb25323, %bb25313, %bb25307, %bb25306
-  %tmp25325 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp25325 = landingpad { i8*, i32 }
           cleanup
   br label %bb25359
 
 bb25326:                                          ; preds = %bb25323, %bb25322, %bb25318, %bb25317
   br label %bb25327
 
 bb25327:                                          ; preds = %bb25328, %bb25326
   br i1 undef, label %bb25328, label %bb25329

 bb25353:                                          ; preds = %bb25352
   invoke void (...) @printf()
           to label %bb25354 unwind label %bb25355
 
 bb25354:                                          ; preds = %bb25353
   br label %bb25358
 
 bb25355:                                          ; preds = %bb25353, %bb25352, %bb25351
-  %tmp25356 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp25356 = landingpad { i8*, i32 }
           cleanup
   br label %bb25359
 
 bb25357:                                          ; preds = %bb25332
   invoke void (...) @printf()
           to label %bb25358 unwind label %bb25324
 
 bb25358:                                          ; preds = %bb25357, %bb25354

llvm/trunk/test/CodeGen/X86/patchpoint-invoke.ll

 ; RUN: llc -mtriple=x86_64-unknown-linux -mcpu=corei7                             < %s | FileCheck %s
 
 ; Test invoking of patchpoints
 ;
-define i64 @patchpoint_invoke(i64 %p1, i64 %p2) {
+define i64 @patchpoint_invoke(i64 %p1, i64 %p2) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK-LABEL: patchpoint_invoke:
 ; CHECK-NEXT:  [[FUNC_BEGIN:.L.*]]:
 ; CHECK-NEXT: .cfi_startproc
 ; CHECK:      .cfi_lsda 3, [[EXCEPTION_LABEL:.L[^ ]*]]
 ; CHECK:      pushq %rbp
 
 ; Unfortunately, hardcode the name of the label that begins the patchpoint:
 ; CHECK:      .Ltmp0:
 ; CHECK:      movabsq $-559038736, %r11
 ; CHECK-NEXT: callq *%r11
 ; CHECK-NEXT: xchgw %ax, %ax
 ; CHECK-NEXT: [[PP_END:.L.*]]:
 ; CHECK:      ret
   %resolveCall = inttoptr i64 -559038736 to i8*
   %result = invoke i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 2, i32 15, i8* %resolveCall, i32 1, i64 %p1, i64 %p2)
             to label %success unwind label %threw
 
 success:
   ret i64 %result
 
 threw:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i64 0
 }
 
 ; Verify that the exception table was emitted:
 ; CHECK:      [[EXCEPTION_LABEL]]:
 ; CHECK-NEXT: .byte 255
 ; CHECK-NEXT: .byte 3

llvm/trunk/test/CodeGen/X86/personality.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin9 | FileCheck %s -check-prefix=X64
 ; RUN: llc < %s -mtriple=i386-apple-darwin9 | FileCheck %s -check-prefix=X32
 ; PR1632
 
-define void @_Z1fv() {
+define void @_Z1fv() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z1gv()
           to label %return unwind label %unwind
 
 unwind:                                           ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   br i1 false, label %eh_then, label %cleanup20
 
 eh_then:                                          ; preds = %unwind
   invoke void @__cxa_end_catch()
           to label %return unwind label %unwind10
 
 unwind10:                                         ; preds = %eh_then
-  %exn10 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn10 = landingpad {i8*, i32}
             cleanup
   %upgraded.eh_select13 = extractvalue { i8*, i32 } %exn10, 1
   %upgraded.eh_select131 = sext i32 %upgraded.eh_select13 to i64
   %tmp18 = icmp slt i64 %upgraded.eh_select131, 0
   br i1 %tmp18, label %filter, label %cleanup20
 
 filter:                                           ; preds = %unwind10
   unreachable

llvm/trunk/test/CodeGen/X86/personality_size.ll

 ; RUN: llc < %s -relocation-model=pic -mtriple=x86_64-pc-solaris2.11 | FileCheck %s -check-prefix=X64
 ; RUN: llc < %s -relocation-model=pic -mtriple=i386-pc-solaris2.11 | FileCheck %s -check-prefix=X32
 ; PR1632
 
-define void @_Z1fv() {
+define void @_Z1fv() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z1gv()
           to label %return unwind label %unwind
 
 unwind:                                           ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   ret void
 
 return:                                           ; preds = %eh_then, %entry
   ret void
 }
 
 declare void @_Z1gv()

llvm/trunk/test/CodeGen/X86/pr3522.ll

 ; REQUIRES: asserts
 ; RUN: llc < %s -march=x86 -stats 2>&1 | not grep "instructions sunk"
 ; PR3522
 
 target triple = "i386-pc-linux-gnu"
 @.str = external constant [13 x i8]    ; <[13 x i8]*> [#uses=1]
 
-define void @_ada_c34018a() {
+define void @_ada_c34018a() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %0 = tail call i32 @report__ident_int(i32 90)    ; <i32> [#uses=1]
   %1 = trunc i32 %0 to i8    ; <i8> [#uses=1]
   invoke void @__gnat_rcheck_12(i8* getelementptr ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), i32 32) noreturn
       to label %invcont unwind label %lpad
 
 invcont:    ; preds = %entry
   unreachable
 
 bb22:   ; preds = %lpad
   ret void
 
 return:   ; preds = %lpad
   ret void
 
 lpad:   ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   %2 = icmp eq i8 %1, 90    ; <i1> [#uses=1]
   br i1 %2, label %return, label %bb22
 }
 
 declare void @__gnat_rcheck_12(i8*, i32) noreturn
 
 declare i32 @report__ident_int(i32)
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/scev-interchange.ll

 declare fastcc void @_ZN24TensorProductPolynomialsILi3EEC2IN11Polynomials10PolynomialIdEEEERKSt6vectorIT_SaIS6_EE(%"struct.PolynomialSpace<1>"* nocapture, %"struct.std::vector<Polynomials::Polynomial<double>,std::allocator<Polynomials::Polynomial<double> > >"* nocapture)
 
 declare fastcc void @_ZN7FE_PolyI24TensorProductPolynomialsILi3EELi3EEC2EjRKS1_RK17FiniteElementDataILi3EERKSt6vectorIbSaIbEERKS9_ISB_SaISB_EE(%"struct.FE_DGPNonparametric<3>"*, i32, %"struct.PolynomialSpace<1>"* nocapture, %"struct.FiniteElementData<1>"* nocapture, %"struct.std::vector<bool,std::allocator<bool> >"* nocapture, %"struct.std::vector<std::vector<bool, std::allocator<bool> >,std::allocator<std::vector<bool, std::allocator<bool> > > >"* nocapture)
 
 declare fastcc void @_ZN11FE_Q_Helper12_GLOBAL__N_116invert_numberingERKSt6vectorIjSaIjEE(%"struct.std::vector<int,std::allocator<int> >"* noalias nocapture sret, %"struct.std::vector<int,std::allocator<int> >"* nocapture)
 
 declare fastcc void @_ZN4FE_QILi3EE14get_dpo_vectorEj(%"struct.std::vector<int,std::allocator<int> >"* noalias nocapture sret, i32)
 
-define fastcc void @_ZN4FE_QILi3EEC1Ej(i32 %degree) {
+define fastcc void @_ZN4FE_QILi3EEC1Ej(i32 %degree) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke fastcc void @_ZNSt6vectorIbSaIbEEC1EmRKbRKS0_(%"struct.std::vector<bool,std::allocator<bool> >"* undef, i64 1, i8* undef)
       to label %invcont.i unwind label %lpad.i
 
 invcont.i:    ; preds = %entry
   invoke fastcc void @_ZN4FE_QILi3EE14get_dpo_vectorEj(%"struct.std::vector<int,std::allocator<int> >"* noalias sret undef, i32 %degree)
       to label %invcont1.i unwind label %lpad120.i
 

 bb.i.i.i262.i:    ; preds = %bb66.i
   br label %bb71.i
 
 bb71.i:   ; preds = %bb.i.i.i262.i, %bb66.i
   %tmp11.i.i29.i.i.i.i.i.i = invoke i8* @_Znwm(i64 12)
       to label %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i.i unwind label %lpad.i.i.i.i.i.i    ; <i8*> [#uses=0]
 
 lpad.i.i.i.i.i.i:   ; preds = %bb71.i
-        %exn.i.i.i.i.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i.i.i.i.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 _ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i.i:    ; preds = %bb71.i
   br i1 undef, label %_ZNSt6vectorIjSaIjEED1Ev.exit.i.i, label %bb.i.i.i.i94.i
 
 bb.i.i.i.i94.i:   ; preds = %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i.i
   unreachable
 
 _ZNSt6vectorIjSaIjEED1Ev.exit.i.i:    ; preds = %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i.i
   %tmp11.i.i29.i.i.i.i5.i.i = invoke i8* @_Znwm(i64 undef)
       to label %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i12.i.i unwind label %lpad.i.i.i.i8.i.i    ; <i8*> [#uses=0]
 
 lpad.i.i.i.i8.i.i:    ; preds = %_ZNSt6vectorIjSaIjEED1Ev.exit.i.i
-        %exn.i.i.i.i8.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i.i.i8.i.i = landingpad {i8*, i32}
                  cleanup
   invoke void @_Unwind_Resume(i8* undef)
       to label %.noexc.i9.i.i unwind label %lpad.i19.i.i
 
 .noexc.i9.i.i:    ; preds = %lpad.i.i.i.i8.i.i
   unreachable
 
 _ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i12.i.i:    ; preds = %_ZNSt6vectorIjSaIjEED1Ev.exit.i.i
   br i1 undef, label %bb50.i.i.i, label %bb.i.i.i.i.i.i.i.i.i.i
 
 bb.i.i.i.i.i.i.i.i.i.i:   ; preds = %bb.i.i.i.i.i.i.i.i.i.i, %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i12.i.i
   br i1 undef, label %bb50.i.i.i, label %bb.i.i.i.i.i.i.i.i.i.i
 
 bb50.i.i.i:   ; preds = %bb.i.i.i.i.i.i.i.i.i.i, %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i12.i.i
   invoke fastcc void @_ZN11FE_Q_Helper12_GLOBAL__N_116invert_numberingERKSt6vectorIjSaIjEE(%"struct.std::vector<int,std::allocator<int> >"* noalias sret undef, %"struct.std::vector<int,std::allocator<int> >"* undef)
       to label %bb83.i unwind label %lpad188.i
 
 lpad.i19.i.i:   ; preds = %lpad.i.i.i.i8.i.i
-        %exn.i19.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i19.i.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 bb83.i:   ; preds = %bb50.i.i.i
   br i1 undef, label %invcont84.i, label %bb.i.i.i221.i
 
 bb.i.i.i221.i:    ; preds = %bb83.i
   unreachable
 
 invcont84.i:    ; preds = %bb83.i
   %tmp11.i.i29.i.i.i.i.i = invoke i8* @_Znwm(i64 undef)
       to label %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i unwind label %lpad.i.i.i.i315.i    ; <i8*> [#uses=0]
 
 lpad.i.i.i.i315.i:    ; preds = %invcont84.i
-        %exn.i.i.i.i315.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i.i.i315.i = landingpad {i8*, i32}
                  cleanup
   invoke void @_Unwind_Resume(i8* undef)
       to label %.noexc.i316.i unwind label %lpad.i352.i
 
 .noexc.i316.i:    ; preds = %lpad.i.i.i.i315.i
   unreachable
 
 _ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i:    ; preds = %invcont84.i
   br i1 undef, label %bb50.i.i, label %bb.i.i.i.i.i.i.i.i320.i
 
 bb.i.i.i.i.i.i.i.i320.i:    ; preds = %bb.i.i.i.i.i.i.i.i320.i, %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i
   br i1 undef, label %bb50.i.i, label %bb.i.i.i.i.i.i.i.i320.i
 
 bb50.i.i:   ; preds = %bb.i.i.i.i.i.i.i.i320.i, %_ZNSt12_Vector_baseIjSaIjEEC2EmRKS0_.exit.i.i.i.i
   invoke fastcc void @_ZN11FE_Q_Helper12_GLOBAL__N_116invert_numberingERKSt6vectorIjSaIjEE(%"struct.std::vector<int,std::allocator<int> >"* noalias sret undef, %"struct.std::vector<int,std::allocator<int> >"* undef)
       to label %invcont86.i unwind label %lpad200.i
 
 lpad.i352.i:    ; preds = %lpad.i.i.i.i315.i
-        %exn.i352.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i352.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 invcont86.i:    ; preds = %bb50.i.i
   invoke fastcc void @_ZNSt6vectorIjSaIjEEaSERKS1_(%"struct.std::vector<int,std::allocator<int> >"* undef, %"struct.std::vector<int,std::allocator<int> >"* undef)
       to label %.noexc380.i unwind label %lpad204.i
 
 .noexc380.i:    ; preds = %invcont86.i
   br i1 undef, label %bb100.i, label %bb.i.i.i198.i
 
 bb.i.i.i198.i:    ; preds = %.noexc380.i
   unreachable
 
 bb100.i:    ; preds = %.noexc380.i
   br i1 undef, label %invcont101.i, label %bb.i.i.i190.i
 
 bb.i.i.i190.i:    ; preds = %bb100.i
   unreachable
 
 invcont101.i:   ; preds = %bb100.i
   invoke fastcc void @_ZN9TableBaseILi2EdE6reinitERK12TableIndicesILi2EE(%"struct.TableBase<2,double>"* undef, i32 undef, i32 undef)
       to label %_ZN10FullMatrixIdEC1Ejj.exit.i.i unwind label %lpad.i.i.i.i.i
 
 lpad.i.i.i.i.i:   ; preds = %invcont101.i
-        %exn.i.i.i.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i.i.i.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 _ZN10FullMatrixIdEC1Ejj.exit.i.i:   ; preds = %invcont101.i
   invoke fastcc void @_ZN9TableBaseILi2EdE6reinitERK12TableIndicesILi2EE(%"struct.TableBase<2,double>"* undef, i32 undef, i32 undef)
       to label %_ZN10FullMatrixIdEC1Ejj.exit28.i.i unwind label %lpad.i.i.i27.i.i
 
 lpad.i.i.i27.i.i:   ; preds = %_ZN10FullMatrixIdEC1Ejj.exit.i.i
-        %exn.i.i.i27.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i.i27.i.i = landingpad {i8*, i32}
                  cleanup
   invoke void @_Unwind_Resume(i8* undef)
       to label %.noexc.i.i unwind label %lpad.i.i
 
 .noexc.i.i:   ; preds = %lpad.i.i.i27.i.i
   unreachable
 
 _ZN10FullMatrixIdEC1Ejj.exit28.i.i:   ; preds = %_ZN10FullMatrixIdEC1Ejj.exit.i.i
   br i1 undef, label %bb58.i.i, label %bb.i.i.i304.i.i
 
 bb.i.i.i304.i.i:    ; preds = %_ZN10FullMatrixIdEC1Ejj.exit28.i.i
   unreachable
 
 bb58.i.i:   ; preds = %_ZN10FullMatrixIdEC1Ejj.exit28.i.i
   br i1 false, label %bb.i191.i, label %bb.i.i.i297.i.i
 
 bb.i.i.i297.i.i:    ; preds = %bb58.i.i
   unreachable
 
 lpad.i.i:   ; preds = %lpad.i.i.i27.i.i
-        %exn.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 bb.i191.i:    ; preds = %.noexc232.i, %bb58.i.i
   invoke fastcc void @_ZN9TableBaseILi2EdE6reinitERK12TableIndicesILi2EE(%"struct.TableBase<2,double>"* undef, i32 undef, i32 undef)
       to label %.noexc232.i unwind label %lpad196.i
 
 .noexc232.i:    ; preds = %bb.i191.i

 
 bb16.preheader.i.i:   ; preds = %bb17.i.i, %bb9.i216.i, %bb7.i215.i
   br i1 undef, label %bb17.i.i, label %bb15.i.i
 
 bb29.loopexit.i.i:    ; preds = %.noexc232.i
   br label %bb9.i216.i
 
 lpad.i:   ; preds = %entry
-        %exn.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad120.i:    ; preds = %invcont.i
-        %exn120.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn120.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad124.i:    ; preds = %invcont1.i
-        %exn124.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn124.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad128.i:    ; preds = %invcont3.i
-        %exn128.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn128.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad132.i:    ; preds = %invcont4.i
-        %exn132.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn132.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad136.i:    ; preds = %invcont6.i
-        %exn136.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn136.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad140.i:    ; preds = %bb21.i, %invcont7.i
-        %exn140.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn140.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad144.i:    ; preds = %bb10.i168.i, %invcont9.i
-        %exn144.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn144.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad148.i:    ; preds = %invcont10.i
-        %exn148.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn148.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad188.i:    ; preds = %bb50.i.i.i
-        %exn188.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn188.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad196.i:    ; preds = %bb.i191.i
-        %exn196 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn196 = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad200.i:    ; preds = %bb50.i.i
-        %exn200.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn200.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad204.i:    ; preds = %invcont86.i
-        %exn204.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn204.i = landingpad {i8*, i32}
                  cleanup
   unreachable
 }
 
 declare fastcc void @_ZN11Polynomials19LagrangeEquidistant23generate_complete_basisEj(%"struct.std::vector<Polynomials::Polynomial<double>,std::allocator<Polynomials::Polynomial<double> > >"* noalias nocapture sret, i32)
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/seh-catch-all-win32.ll

 ; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s
 
 ; 32-bit catch-all has to use a filter function because that's how it saves the
 ; exception code.
 
 @str = linkonce_odr unnamed_addr constant [27 x i8] c"GetExceptionCode(): 0x%lx\0A\00", align 1
 
 declare i32 @_except_handler3(...)
 declare void @crash()
 declare i32 @printf(i8* nocapture readonly, ...) nounwind
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @llvm.frameaddress(i32)
 declare i8* @llvm.framerecover(i8*, i8*, i32)
 declare void @llvm.frameescape(...)
 declare i8* @llvm.x86.seh.exceptioninfo(i8*, i8*)
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %__exceptioncode = alloca i32, align 4
   call void (...) @llvm.frameescape(i32* %__exceptioncode)
   invoke void @crash() #5
           to label %__try.cont unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @_except_handler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i32 ()* @"filt$main" to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @"filt$main" to i8*)) #4
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %__except, label %eh.resume
 
 __except:                                         ; preds = %lpad
   %3 = load i32, i32* %__exceptioncode, align 4

llvm/trunk/test/CodeGen/X86/seh-catch-all.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s
 
 @str = linkonce_odr unnamed_addr constant [27 x i8] c"GetExceptionCode(): 0x%lx\0A\00", align 1
 
 declare i32 @__C_specific_handler(...)
 declare void @crash()
 declare i32 @printf(i8* nocapture readonly, ...) nounwind
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   invoke void @crash()
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = ptrtoint i8* %1 to i64
   %3 = trunc i64 %2 to i32
   call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str, i64 0, i64 0), i32 %3)
   br label %__try.cont
 
 __try.cont:

llvm/trunk/test/CodeGen/X86/seh-except-finally.ll

 @"\01??_C@_09KJEHOMHG@__finally?$AA@" = linkonce_odr unnamed_addr constant [10 x i8] c"__finally\00", comdat, align 1
 @"\01??_C@_08MLCMLGHM@__except?$AA@" = linkonce_odr unnamed_addr constant [9 x i8] c"__except\00", comdat, align 1
 
 declare void @crash()
 
 declare i32 @filt()
 
 ; Function Attrs: nounwind uwtable
-define void @use_both() #1 {
+define void @use_both() #1 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   invoke void @crash() #5
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %0 = call i8* @llvm.frameaddress(i32 0)
   invoke void @"\01?fin$0@0@use_both@@"(i1 zeroext false, i8* %0) #5
           to label %invoke.cont2 unwind label %lpad1
 
 invoke.cont2:                                     ; preds = %invoke.cont
   br label %__try.cont
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@use_both@@" to i8*)
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   %4 = call i8* @llvm.frameaddress(i32 0)
   invoke void @"\01?fin$0@0@use_both@@"(i1 zeroext true, i8* %4) #5
           to label %invoke.cont3 unwind label %lpad1
 
 lpad1:                                            ; preds = %lpad, %invoke.cont
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %5 = landingpad { i8*, i32 }
           catch i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@use_both@@" to i8*)
   %6 = extractvalue { i8*, i32 } %5, 0
   store i8* %6, i8** %exn.slot
   %7 = extractvalue { i8*, i32 } %5, 1
   store i32 %7, i32* %ehselector.slot
   br label %catch.dispatch
 
 invoke.cont3:                                     ; preds = %lpad

llvm/trunk/test/CodeGen/X86/seh-filter.ll

 ; RUN: llc -O0 -mtriple=x86_64-windows-msvc < %s | FileCheck %s
 
 declare void @g()
-define void @f() {
+define void @f() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
   invoke void @g() to label %return unwind label %lpad
 
 return:
   ret void
 
 lpad:
-  %ehptrs = landingpad {i8*, i32} personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %ehptrs = landingpad {i8*, i32}
     filter [0 x i8*] zeroinitializer
   call void @__cxa_call_unexpected(i8* null)
   unreachable
 }
 declare i32 @__C_specific_handler(...)
 declare void @__cxa_call_unexpected(i8*)
 
 ; We don't emit entries for filters.
 ; CHECK: .seh_handlerdata
 ; CHECK: .long 0

llvm/trunk/test/CodeGen/X86/seh-finally.ll

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=X64
 ; RUN: sed -e 's/__C_specific_handler/_except_handler3/' %s | \
 ; RUN:        llc -mtriple=i686-windows-msvc | FileCheck %s --check-prefix=X86
 
 @str_recovered = internal unnamed_addr constant [10 x i8] c"recovered\00", align 1
 
 declare void @crash()
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   invoke void @crash()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %call = call i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str_recovered, i64 0, i64 0))
   call void @abort()
   ret i32 0
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   %call2 = invoke i32 @puts(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str_recovered, i64 0, i64 0))
           to label %invoke.cont1 unwind label %terminate.lpad
 
 invoke.cont1:                                     ; preds = %lpad
   resume { i8*, i32 } %0
 
 terminate.lpad:                                   ; preds = %lpad
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %3 = landingpad { i8*, i32 }
           catch i8* null
   call void @abort()
   unreachable
 }
 
 ; X64-LABEL: main:
 ; X64: retq
 

llvm/trunk/test/CodeGen/X86/seh-safe-div-win32.ll

 ;       r = -2;
 ;     }
 ;     return r;
 ;   }
 
 @str1 = internal constant [27 x i8] c"EXCEPTION_ACCESS_VIOLATION\00"
 @str2 = internal constant [29 x i8] c"EXCEPTION_INT_DIVIDE_BY_ZERO\00"
 
-define i32 @safe_div(i32* %n, i32* %d) {
+define i32 @safe_div(i32* %n, i32* %d) personality i8* bitcast (i32 (...)* @_except_handler3 to i8*) {
 entry:
   %r = alloca i32, align 4
   store i32 42, i32* %r
   invoke void @try_body(i32* %r, i32* %n, i32* %d)
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %vals = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @_except_handler3 to i8*)
+  %vals = landingpad { i8*, i32 }
           catch i8* bitcast (i32 ()* @safe_div_filt0 to i8*)
           catch i8* bitcast (i32 ()* @safe_div_filt1 to i8*)
   %ehptr = extractvalue { i8*, i32 } %vals, 0
   %sel = extractvalue { i8*, i32 } %vals, 1
   %filt0_val = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @safe_div_filt0 to i8*))
   %is_filt0 = icmp eq i32 %sel, %filt0_val
   br i1 %is_filt0, label %handler0, label %eh.dispatch1
 

llvm/trunk/test/CodeGen/X86/seh-safe-div.ll

 ;       r = -2;
 ;     }
 ;     return r;
 ;   }
 
 @str1 = internal constant [27 x i8] c"EXCEPTION_ACCESS_VIOLATION\00"
 @str2 = internal constant [29 x i8] c"EXCEPTION_INT_DIVIDE_BY_ZERO\00"
 
-define i32 @safe_div(i32* %n, i32* %d) {
+define i32 @safe_div(i32* %n, i32* %d) personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %r = alloca i32, align 4
   invoke void @try_body(i32* %r, i32* %n, i32* %d)
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %vals = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %vals = landingpad { i8*, i32 }
           catch i8* bitcast (i32 (i8*, i8*)* @safe_div_filt0 to i8*)
           catch i8* bitcast (i32 (i8*, i8*)* @safe_div_filt1 to i8*)
   %ehptr = extractvalue { i8*, i32 } %vals, 0
   %sel = extractvalue { i8*, i32 } %vals, 1
   %filt0_val = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @safe_div_filt0 to i8*))
   %is_filt0 = icmp eq i32 %sel, %filt0_val
   br i1 %is_filt0, label %handler0, label %eh.dispatch1
 

llvm/trunk/test/CodeGen/X86/setjmp-spills.ll

second:
   call void @use_val(i32 %a8)
   ret void
 }
 
 
 ; This is the same as above, but using "invoke" rather than "call" to
 ; call setjmp().
 
-define void @setjmp_invoker() {
+define void @setjmp_invoker() personality void ()* @personality {
 ; X86-32-LABEL: setjmp_invoker:
 ; X86-64-LABEL: setjmp_invoker:
   %a1 = call i32 @get_val()
   %a2 = call i32 @get_val()
   %a3 = call i32 @get_val()
   %a4 = call i32 @get_val()
   %a5 = call i32 @get_val()
   %a6 = call i32 @get_val()
   %a7 = call i32 @get_val()
   %a8 = call i32 @get_val()
 ; X86-32: movl %eax, [[SPILL_SLOT:[0-9]+]](%esp)
 ; X86-32: calll get_val
 ; X86-64: movl %eax, [[SPILL_SLOT:[0-9]+]](%rsp)
 ; X86-64: callq get_val
 
   %setjmp_result = invoke i1 @setjmp() returns_twice
       to label %cont unwind label %lpad
 ; X86-32: calll setjmp
 ; X86-64: callq setjmp
 
 cont:
   br i1 %setjmp_result, label %second, label %first
 
 lpad:
-  %lp = landingpad { i8*, i32 } personality void ()* @personality cleanup
+  %lp = landingpad { i8*, i32 } cleanup
   unreachable
 
 first:
   %b1 = call i32 @get_val()
   %b2 = call i32 @get_val()
   %b3 = call i32 @get_val()
   %b4 = call i32 @get_val()
   %b5 = call i32 @get_val()

llvm/trunk/test/CodeGen/X86/split-eh-lpad-edges.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin | not grep jmp
 ; rdar://6647639
 
   %struct.FetchPlanHeader = type { i8*, i8*, i32, i8*, i8*, i8*, i8*, i8*, %struct.NSObject* (%struct.NSObject*, %struct.objc_selector*, ...)*, %struct.__attributeDescriptionFlags }
   %struct.NSArray = type { %struct.NSObject }
   %struct.NSAutoreleasePool = type { %struct.NSObject, i8*, i8*, i8*, i8* }
   %struct.NSObject = type { %struct.NSObject* }
   %struct.__attributeDescriptionFlags = type <{ i32 }>
   %struct._message_ref_t = type { %struct.NSObject* (%struct.NSObject*, %struct._message_ref_t*, ...)*, %struct.objc_selector* }
   %struct.objc_selector = type opaque
 @"\01l_objc_msgSend_fixup_alloc" = external global %struct._message_ref_t, align 16    ; <%struct._message_ref_t*> [#uses=2]
 
-define %struct.NSArray* @newFetchedRowsForFetchPlan_MT(%struct.FetchPlanHeader* %fetchPlan, %struct.objc_selector* %selectionMethod, %struct.NSObject* %selectionParameter) ssp {
+define %struct.NSArray* @newFetchedRowsForFetchPlan_MT(%struct.FetchPlanHeader* %fetchPlan, %struct.objc_selector* %selectionMethod, %struct.NSObject* %selectionParameter) ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %0 = invoke %struct.NSObject* null(%struct.NSObject* null, %struct._message_ref_t* @"\01l_objc_msgSend_fixup_alloc")
       to label %invcont unwind label %lpad    ; <%struct.NSObject*> [#uses=1]
 
 invcont:    ; preds = %entry
   %1 = invoke %struct.NSObject* (%struct.NSObject*, %struct.objc_selector*, ...) @objc_msgSend(%struct.NSObject* %0, %struct.objc_selector* null)
       to label %invcont26 unwind label %lpad    ; <%struct.NSObject*> [#uses=0]
 
 invcont26:    ; preds = %invcont
   %2 = invoke %struct.NSObject* null(%struct.NSObject* null, %struct._message_ref_t* @"\01l_objc_msgSend_fixup_alloc")
       to label %invcont27 unwind label %lpad    ; <%struct.NSObject*> [#uses=0]
 
 invcont27:    ; preds = %invcont26
   unreachable
 
 lpad:   ; preds = %invcont26, %invcont, %entry
   %pool.1 = phi %struct.NSAutoreleasePool* [ null, %entry ], [ null, %invcont ], [ null, %invcont26 ]    ; <%struct.NSAutoreleasePool*> [#uses=0]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   unreachable
 }
 
 declare %struct.NSObject* @objc_msgSend(%struct.NSObject*, %struct.objc_selector*, ...)
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/CodeGen/X86/stack-protector.ll

; DARWIN-X64: callq ___stack_chk_fail
   %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr)
   ret void
 }
 
 ; test18a: Addr-of a variable passed into an invoke instruction.
 ;          no ssp attribute
 ; Requires no protector.
-define i32 @test18a()  {
+define i32 @test18a() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test18a:
 ; LINUX-I386-NOT: calll __stack_chk_fail
 ; LINUX-I386: .cfi_endproc
 
 ; LINUX-X64-LABEL: test18a:
 ; LINUX-X64-NOT: callq __stack_chk_fail
 ; LINUX-X64: .cfi_endproc
; DARWIN-X64: .cfi_endproc
   store i32 0, i32* %a, align 4
   invoke void @_Z3exceptPi(i32* %a)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test18b: Addr-of a variable passed into an invoke instruction.
 ;          ssp attribute
 ; Requires no protector.
 ; Function Attrs: ssp 
-define i32 @test18b() #0 {
+define i32 @test18b() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test18b:
 ; LINUX-I386-NOT: calll __stack_chk_fail
 ; LINUX-I386: .cfi_endproc
 
 ; LINUX-X64-LABEL: test18b:
 ; LINUX-X64-NOT: callq __stack_chk_fail
 ; LINUX-X64: .cfi_endproc
; DARWIN-X64: .cfi_endproc
   store i32 0, i32* %a, align 4
   invoke void @_Z3exceptPi(i32* %a)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test18c: Addr-of a variable passed into an invoke instruction.
 ;          sspstrong attribute
 ; Requires protector.
 ; Function Attrs: sspstrong 
-define i32 @test18c() #1 {
+define i32 @test18c() #1 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test18c:
 ; LINUX-I386: mov{{l|q}} %gs:
 ; LINUX-I386: calll __stack_chk_fail
 
 ; LINUX-X64-LABEL: test18c:
 ; LINUX-X64: mov{{l|q}} %fs:
 ; LINUX-X64: callq __stack_chk_fail
; DARWIN-X64: callq ___stack_chk_fail
   store i32 0, i32* %a, align 4
   invoke void @_Z3exceptPi(i32* %a)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test18d: Addr-of a variable passed into an invoke instruction.
 ;          sspreq attribute
 ; Requires protector.
 ; Function Attrs: sspreq 
-define i32 @test18d() #2 {
+define i32 @test18d() #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test18d:
 ; LINUX-I386: mov{{l|q}} %gs:
 ; LINUX-I386: calll __stack_chk_fail
 
 ; LINUX-X64-LABEL: test18d:
 ; LINUX-X64: mov{{l|q}} %fs:
 ; LINUX-X64: callq __stack_chk_fail
; DARWIN-X64: callq ___stack_chk_fail
   store i32 0, i32* %a, align 4
   invoke void @_Z3exceptPi(i32* %a)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 ; test19a: Addr-of a struct element passed into an invoke instruction.
 ;           (GEP followed by an invoke)
 ;          no ssp attribute
 ; Requires no protector.
-define i32 @test19a()  {
+define i32 @test19a() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test19a:
 ; LINUX-I386-NOT: calll __stack_chk_fail
 ; LINUX-I386: .cfi_endproc
 
 ; LINUX-X64-LABEL: test19a:
 ; LINUX-X64-NOT: callq __stack_chk_fail
 ; LINUX-X64: .cfi_endproc
; DARWIN-X64: .cfi_endproc
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test19b: Addr-of a struct element passed into an invoke instruction.
 ;           (GEP followed by an invoke)
 ;          ssp attribute
 ; Requires no protector.
 ; Function Attrs: ssp 
-define i32 @test19b() #0 {
+define i32 @test19b() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test19b:
 ; LINUX-I386-NOT: calll __stack_chk_fail
 ; LINUX-I386: .cfi_endproc
 
 ; LINUX-X64-LABEL: test19b:
 ; LINUX-X64-NOT: callq __stack_chk_fail
 ; LINUX-X64: .cfi_endproc
; DARWIN-X64: .cfi_endproc
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test19c: Addr-of a struct element passed into an invoke instruction.
 ;           (GEP followed by an invoke)
 ;          sspstrong attribute
 ; Requires protector.
 ; Function Attrs: sspstrong 
-define i32 @test19c() #1 {
+define i32 @test19c() #1 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test19c:
 ; LINUX-I386: mov{{l|q}} %gs:
 ; LINUX-I386: calll __stack_chk_fail
 
 ; LINUX-X64-LABEL: test19c:
 ; LINUX-X64: mov{{l|q}} %fs:
 ; LINUX-X64: callq __stack_chk_fail
; DARWIN-X64: callq ___stack_chk_fail
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test19d: Addr-of a struct element passed into an invoke instruction.
 ;           (GEP followed by an invoke)
 ;          sspreq attribute
 ; Requires protector.
 ; Function Attrs: sspreq 
-define i32 @test19d() #2 {
+define i32 @test19d() #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; LINUX-I386-LABEL: test19d:
 ; LINUX-I386: mov{{l|q}} %gs:
 ; LINUX-I386: calll __stack_chk_fail
 ; LINUX-I386-NOT: calll __stack_chk_fail
 
 ; LINUX-X64-LABEL: test19d:
 ; LINUX-X64: mov{{l|q}} %fs:
; DARWIN-X64-NOT: callq ___stack_chk_fail
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 ; test20a: Addr-of a pointer
 ;          no ssp attribute
 ; Requires no protector.
 define void @test20a() {

llvm/trunk/test/CodeGen/X86/statepoint-invoke.ll

 ; RUN: llc < %s 2>&1 | FileCheck %s
 
 target triple = "x86_64-pc-linux-gnu"
 
 declare void @"some_call"(i64 addrspace(1)*)
 declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*)
 
 declare i32 @"personality_function"()
 
 define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj,
                                      i64 addrspace(1)* %obj1)
-gc "statepoint-example" {
+gc "statepoint-example" personality i32 ()* @"personality_function" {
 entry:
   ; CHECK: Ltmp{{[0-9]+}}:
   ; CHECK: callq some_call
   ; CHECK: Ltmp{{[0-9]+}}:
   %0 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
           to label %invoke_safepoint_normal_dest unwind label %exceptional_return
 
 invoke_safepoint_normal_dest:
   ; CHECK: movq
   %obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %0, i32 13, i32 13)
   %obj1.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %0, i32 14, i32 14)
   br label %normal_return
 
 normal_return:
   ; CHECK: retq
   ret i64 addrspace(1)* %obj.relocated
 
 exceptional_return:
   ; CHECK: Ltmp{{[0-9]+}}:
   ; CHECK: movq
   ; CHECK: retq
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %obj.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
   %obj1.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
   ret i64 addrspace(1)* %obj1.relocated1
 }
 ; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
 ; CHECK: .long  .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
 ; CHECK: .long  .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
 ; CHECK: .byte  0
 ; CHECK: .align 4
 
 define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj,
                                       i64 addrspace(1)* %obj1)
-  gc "statepoint-example" {
+  gc "statepoint-example" personality i32 ()* @personality_function {
 entry:
   ; CHECK: .Ltmp{{[0-9]+}}:
   ; CHECK: callq some_other_call
   ; CHECK: .Ltmp{{[0-9]+}}:
   %0 = invoke i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 0, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @some_other_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
           to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ; CHECK: popq 
   ; CHECK: retq
   %ret_val = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %0)
   ret i64 addrspace(1)* %ret_val
 
 exceptional_return:
   ; CHECK: .Ltmp{{[0-9]+}}:
   ; CHECK: movq
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @personality_function
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
   ret i64 addrspace(1)* %obj.relocated
 }
 ; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
 ; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
 ; CHECK: .long .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
 ; CHECK: .byte 0
 ; CHECK: .align 4
 
 define i64 addrspace(1)* @test_same_val(i1 %cond, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3)
-  gc "statepoint-example" {
+  gc "statepoint-example" personality i32 ()* @"personality_function" {
 entry:
   br i1 %cond, label %left, label %right
 
 left:
   ; CHECK-LABEL: %left
   ; CHECK: movq %rdx, 8(%rsp)
   ; CHECK: movq
   ; CHECK: callq some_call
normal_return:
   ; CHECK: cmoveq {{.*}}[[REGVAL2]]{{.*}}
   ; CHECK retq
   %a1 = phi i64 addrspace(1)* [%val1.relocated, %left.relocs], [%val3.relocated, %right.relocs]
   %a2 = phi i64 addrspace(1)* [%val2.relocated_left, %left.relocs], [%val2.relocated_right, %right.relocs]
   %ret = select i1 %cond, i64 addrspace(1)* %a1, i64 addrspace(1)* %a2
   ret i64 addrspace(1)* %ret
 
 exceptional_return.left:
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %val.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
   ret i64 addrspace(1)* %val.relocated2
 
 exceptional_return.right:
-  %landing_pad1 = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad1 = landingpad { i8*, i32 }
           cleanup
   %relocate_token1 = extractvalue { i8*, i32 } %landing_pad1, 1
   %val.relocated3 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token1, i32 13, i32 13)
   ret i64 addrspace(1)* %val.relocated3
 }
 
 define i64 addrspace(1)* @test_null_undef(i64 addrspace(1)* %val1)
-       gc "statepoint-example" {
+       gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: test_null_undef:
 entry:
   ; CHECK: callq some_call
   %sp1 = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* null, i64 addrspace(1)* undef)
            to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ; CHECK-LABEL: %normal_return
   ; CHECK: xorl %eax, %eax
   ; CHECK-NEXT: popq
   ; CHECK-NEXT: retq
   %null.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 13, i32 13)
   %undef.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %sp1, i32 14, i32 14)
   ret i64 addrspace(1)* %null.relocated
 
 exceptional_return:
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %null.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 13, i32 13)
   %undef.relocated2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
   ret i64 addrspace(1)* %null.relocated2
 }
 
 define i64 addrspace(1)* @test_alloca_and_const(i64 addrspace(1)* %val1)
-       gc "statepoint-example" {
+       gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: test_alloca_and_const:
 entry:
   %a = alloca i32
   %aa = addrspacecast i32* %a to i32 addrspace(1)*
   %c = inttoptr i64 15 to i64 addrspace(1)*
   ; CHECK: callq
   %sp = invoke i32 (i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)*)* @some_call, i32 1, i32 0, i64 addrspace(1)* %val1, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %aa, i64 addrspace(1)* %c)
            to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ; CHECK: leaq
   ; CHECK-NEXT: popq
   ; CHECK-NEXT: retq
   %aa.rel = call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %sp, i32 13, i32 13)
   %aa.converted = bitcast i32 addrspace(1)* %aa.rel to i64 addrspace(1)*
   ret i64 addrspace(1)* %aa.converted
 
 exceptional_return:
   ; CHECK: movl $15
   ; CHECK-NEXT: popq
   ; CHECK-NEXT: retq
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %aa.rel2 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %relocate_token, i32 14, i32 14)
   ret i64 addrspace(1)* %aa.rel2
 }
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)*)*, i32, i32, ...)
 declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...)
 
 declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)
 declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32)

llvm/trunk/test/CodeGen/X86/statepoint-stack-usage.ll

; CHECK-NOT: movq
   %a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 14)
   %b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 13)
   %c2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 12)
 ; CHECK: callq
   ret i32 1
 }
 
 ; Test that stack slots are reused for invokes
-define i32 @back_to_back_invokes(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" {
+define i32 @back_to_back_invokes(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: back_to_back_invokes
 entry:
   ; The exact stores don't matter, but there need to be three stack slots created
   ; CHECK: movq %rdi, 16(%rsp)
   ; CHECK: movq %rdx, 8(%rsp)
   ; CHECK: movq %rsi, (%rsp)
   ; CHECK: callq
   %safepoint_token = invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c)

 
 normal_return2:
   %a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 14)
   %b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 13)
   %c2 = tail call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token2, i32 12, i32 12)
   ret i32 1
 
 exceptional_return:
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   ret i32 0
 
 exceptional_return2:
-  %landing_pad2 = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad2 = landingpad { i8*, i32 }
           cleanup
   ret i32 0
 }
 
 ; Function Attrs: nounwind
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3
 declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32) #3
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
 
 declare i32 @"personality_function"()
 
 attributes #1 = { uwtable }

llvm/trunk/test/CodeGen/X86/win32-eh-states.ll

 declare i32 @llvm.eh.typeid.for(i8*)
 
 $"\01??_R0H@8" = comdat any
 
 @"\01??_7type_info@@6B@" = external constant i8*
 @"\01??_R0H@8" = linkonce_odr global %rtti.TypeDescriptor2 { i8** @"\01??_7type_info@@6B@", i8* null, [3 x i8] c".H\00" }, comdat
 @llvm.eh.handlertype.H.0 = private unnamed_addr constant %eh.CatchHandlerType { i32 0, i8* bitcast (%rtti.TypeDescriptor2* @"\01??_R0H@8" to i8*) }, section "llvm.metadata"
 
-define void @f() #0 {
+define void @f() #0 personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*) {
 entry:
   invoke void @may_throw(i32 1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   invoke void @may_throw(i32 2)
           to label %try.cont.9 unwind label %lpad.1
 
 try.cont.9:                                       ; preds = %invoke.cont.3, %invoke.cont, %catch.7
   ; FIXME: Something about our CFG breaks TailDuplication. This empy asm blocks
   ; it so we can focus on testing the state numbering.
   call void asm sideeffect "", "~{dirflag},~{fpsr},~{flags}"()
   ret void
 
 lpad:                                             ; preds = %catch, %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch %eh.CatchHandlerType* @llvm.eh.handlertype.H.0
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   br label %catch.dispatch.4
 
 lpad.1:                                           ; preds = %invoke.cont
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__CxxFrameHandler3 to i8*)
+  %3 = landingpad { i8*, i32 }
           catch i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)
   %4 = extractvalue { i8*, i32 } %3, 0
   %5 = extractvalue { i8*, i32 } %3, 1
   %6 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%eh.CatchHandlerType* @llvm.eh.handlertype.H.0 to i8*)) #3
   %matches = icmp eq i32 %5, %6
   br i1 %matches, label %catch, label %catch.dispatch.4
 
 catch.dispatch.4:                                 ; preds = %lpad.1, %lpad

llvm/trunk/test/CodeGen/X86/win32-eh.ll

 ; RUN: llc -mtriple=i686-pc-windows-msvc < %s | FileCheck %s
 
 declare void @may_throw_or_crash()
 declare i32 @_except_handler3(...)
 declare i32 @_except_handler4(...)
 declare i32 @__CxxFrameHandler3(...)
 declare void @llvm.eh.begincatch(i8*, i8*)
 declare void @llvm.eh.endcatch()
 declare i32 @llvm.eh.typeid.for(i8*)
 
 define internal i32 @catchall_filt() {
   ret i32 1
 }
 
-define void @use_except_handler3() {
+define void @use_except_handler3() personality i32 (...)* @_except_handler3 {
 entry:
   invoke void @may_throw_or_crash()
       to label %cont unwind label %catchall
 cont:
   ret void
 catchall:
-  %0 = landingpad { i8*, i32 } personality i32 (...)* @_except_handler3
+  %0 = landingpad { i8*, i32 }
       catch i8* bitcast (i32 ()* @catchall_filt to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @catchall_filt to i8*)) #4
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %cont, label %eh.resume
 eh.resume:
   resume { i8*, i32 } %0
 }

 ; CHECK: retl
 
 ; CHECK: .section .xdata,"dr"
 ; CHECK-LABEL: L__ehtable$use_except_handler3:
 ; CHECK-NEXT:  .long   -1
 ; CHECK-NEXT:  .long   _catchall_filt
 ; CHECK-NEXT:  .long   Ltmp{{[0-9]+}}
 
-define void @use_except_handler4() {
+define void @use_except_handler4() personality i32 (...)* @_except_handler4 {
 entry:
   invoke void @may_throw_or_crash()
       to label %cont unwind label %catchall
 cont:
   ret void
 catchall:
-  %0 = landingpad { i8*, i32 } personality i32 (...)* @_except_handler4
+  %0 = landingpad { i8*, i32 }
       catch i8* bitcast (i32 ()* @catchall_filt to i8*)
   %1 = extractvalue { i8*, i32 } %0, 1
   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 ()* @catchall_filt to i8*)) #4
   %matches = icmp eq i32 %1, %2
   br i1 %matches, label %cont, label %eh.resume
 eh.resume:
   resume { i8*, i32 } %0
 }

 ; CHECK-NEXT:  .long   -2
 ; CHECK-NEXT:  .long   0
 ; CHECK-NEXT:  .long   9999
 ; CHECK-NEXT:  .long   0
 ; CHECK-NEXT:  .long   -2
 ; CHECK-NEXT:  .long   _catchall_filt
 ; CHECK-NEXT:  .long   Ltmp{{[0-9]+}}
 
-define void @use_CxxFrameHandler3() {
+define void @use_CxxFrameHandler3() personality i32 (...)* @__CxxFrameHandler3 {
   invoke void @may_throw_or_crash()
       to label %cont unwind label %catchall
 cont:
   ret void
 catchall:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__CxxFrameHandler3
+  %ehvals = landingpad { i8*, i32 }
       catch i8* null
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   call void @llvm.eh.begincatch(i8* %ehptr, i8* null)
   call void @llvm.eh.endcatch()
   br label %cont
 }
 
 ; CHECK-LABEL: _use_CxxFrameHandler3:

llvm/trunk/test/CodeGen/X86/win64_call_epi.ll

 ; RUN: llc < %s -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=WIN64
 
 declare void @bar()
 declare void @baz()
 declare i32 @personality(...)
 
 ; Check for 'nop' between the last call and the epilogue.
-define void @foo1() {
+define void @foo1() personality i32 (...)* @personality {
 
     invoke void @bar()
         to label %normal
         unwind label %catch
 
 normal:
     ret void
 
 catch:
-    %1 = landingpad { i8*, i32 } personality i32 (...)* @personality cleanup
+    %1 = landingpad { i8*, i32 } cleanup
     resume { i8*, i32 } %1
 }
 ; WIN64-LABEL: foo1:
 ; WIN64: .seh_proc foo1
 ; WIN64: callq bar
 ; WIN64: nop
 ; WIN64: addq ${{[0-9]+}}, %rsp
 ; WIN64: retq

llvm/trunk/test/CodeGen/X86/win64_eh.ll

 
 
 ; Check emission of eh handler and handler data
 declare i32 @_d_eh_personality(i32, i32, i64, i8*, i8*)
 declare void @_d_eh_resume_unwind(i8*)
 
 declare i32 @bar()
 
-define i32 @foo4() #0 {
+define i32 @foo4() #0 personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality {
 entry:
   %step = alloca i32, align 4
   store i32 0, i32* %step
   %tmp = load i32, i32* %step
 
   %tmp1 = invoke i32 @bar()
           to label %finally unwind label %landingpad
 
 finally:
   store i32 1, i32* %step
   br label %endtryfinally
 
 landingpad:
-  %landing_pad = landingpad { i8*, i32 } personality i32 (i32, i32, i64, i8*, i8*)* @_d_eh_personality
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %tmp3 = extractvalue { i8*, i32 } %landing_pad, 0
   store i32 2, i32* %step
   call void @_d_eh_resume_unwind(i8* %tmp3)
   unreachable
 
 endtryfinally:
   %tmp10 = load i32, i32* %step

llvm/trunk/test/CodeGen/X86/win_eh_prepare.ll

 ; RUN: opt -S -winehprepare -dwarfehprepare -mtriple x86_64-pc-windows-msvc < %s | FileCheck %s
 
 ; FIXME: Add and test outlining here.
 
 declare void @maybe_throw()
 
 @_ZTIi = external constant i8*
 @g = external global i32
 
 declare i32 @__C_specific_handler(...)
 declare i32 @__gxx_personality_seh0(...)
 declare i32 @llvm.eh.typeid.for(i8*) readnone nounwind
 
-define i32 @use_seh() {
+define i32 @use_seh() personality i32 (...)* @__C_specific_handler {
 entry:
   invoke void @maybe_throw()
       to label %cont unwind label %lpad
 
 cont:
   ret i32 0
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %ehvals = landingpad { i8*, i32 }
       cleanup
       catch i8* bitcast (i32 (i8*, i8*)* @filt_g to i8*)
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_g_sel = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filt_g to i8*))
   %matches = icmp eq i32 %ehsel, %filt_g_sel
   br i1 %matches, label %ret1, label %eh.resume
 
 ret1:

 ; CHECK: landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: catch
 ; CHECK-NEXT: call i8* (...) @llvm.eh.actions({{.*}})
 
 
 ; A MinGW64-ish EH style. It could happen if a binary uses both MSVC CRT and
 ; mingw CRT and is linked with LTO.
-define i32 @use_gcc() {
+define i32 @use_gcc() personality i32 (...)* @__gxx_personality_seh0 {
 entry:
   invoke void @maybe_throw()
       to label %cont unwind label %lpad
 
 cont:
   ret i32 0
 
 lpad:
-  %ehvals = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_seh0
+  %ehvals = landingpad { i8*, i32 }
       cleanup
       catch i8* bitcast (i8** @_ZTIi to i8*)
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   %filt_g_sel = call i32 @llvm.eh.typeid.for(i8* bitcast (i32 (i8*, i8*)* @filt_g to i8*))
   %matches = icmp eq i32 %ehsel, %filt_g_sel
   br i1 %matches, label %ret1, label %eh.resume
 
 ret1:

llvm/trunk/test/CodeGen/XCore/exception.ll

 ; CHECK-LABEL: fn_catch:
 ; CHECK-NEXT: [[START:.L[a-zA-Z0-9_]+]]
 ; CHECK: .cfi_startproc
 ; CHECK: .cfi_personality 0, __gxx_personality_v0
 ; CHECK: .cfi_lsda 0, [[LSDA:.L[a-zA-Z0-9_]+]]
 ; CHECK: entsp 4
 ; CHECK: .cfi_def_cfa_offset 16
 ; CHECK: .cfi_offset 15, 0
-define void @fn_catch() {
+define void @fn_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 
 ; N.B. we alloc no variables, hence force compiler to spill
 ; CHECK: stw r4, sp[3]
 ; CHECK: .cfi_offset 4, -4
 ; CHECK: stw r5, sp[2]
 ; CHECK: .cfi_offset 5, -8
 ; CHECK: stw r6, sp[1]

 ; CHECK: {{.L[a-zA-Z0-9_]+}}
 ; CHECK: [[LANDING:.L[a-zA-Z0-9_]+]]
 ; CHECK: mov r5, r1
 ; CHECK: mov r4, r0
 ; CHECK: bl __cxa_begin_catch
 ; CHECK: ldw r6, r0[0]
 ; CHECK: bl __cxa_end_catch
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast (i8** @_ZTIi to i8*)
           catch i8* bitcast (i8** @_ZTId to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   %3 = call i8* @__cxa_begin_catch(i8* %1) nounwind
   %4 = bitcast i8* %3 to i32*
   %5 = load i32, i32* %4

llvm/trunk/test/DebugInfo/AArch64/eh_frame_personality.ll

 ; RUN: llc -verify-machineinstrs -mtriple=aarch64-none-linux-gnu %s -filetype=obj -o %t
 ; RUN: llvm-objdump -s %t | FileCheck %s
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @bar()
 
-define i64 @foo(i64 %lhs, i64 %rhs) {
+define i64 @foo(i64 %lhs, i64 %rhs) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @bar() to label %end unwind label %clean
 end:
  ret i64 0
 
 clean:
-  %tst = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) cleanup
+  %tst = landingpad { i8*, i32 } cleanup
   ret i64 42
 }
 
 ; CHECK: Contents of section .eh_frame:
 ; CHECK: 0000 1c000000 00000000 017a504c 5200017c  .........zPLR..|
 ; CHECK: 0010 1e0b0000 00000000 00000000 1b0c1f00  ................
 
 ; Don't really care about the rest:

llvm/trunk/test/DebugInfo/AArch64/frameindices.ll

entry:
   %call.i = tail call noalias i8* @_Znwm(i64 %2) #5, !dbg !68
   store i8* %call.i, i8** bitcast (i32** @b to i8**), align 8, !dbg !69, !tbaa !55
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %0, i64 24, i32 8, i1 false), !dbg !70
   call void @_Z2f91A(%struct.A* %agg.tmp.i), !dbg !71
   call void @llvm.lifetime.end(i64 24, i8* %1), !dbg !72
   ret void, !dbg !73
 }
 
-define void @_Z3f16v() #0 {
+define void @_Z3f16v() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %agg.tmp.i.i = alloca %struct.A, align 8
   %d = alloca %struct.B, align 1
   %agg.tmp.sroa.2 = alloca [15 x i8], align 1
   %agg.tmp.sroa.4 = alloca [7 x i8], align 1
   tail call void @llvm.dbg.declare(metadata [15 x i8]* %agg.tmp.sroa.2, metadata !74, metadata !76), !dbg !77
   tail call void @llvm.dbg.declare(metadata [7 x i8]* %agg.tmp.sroa.4, metadata !74, metadata !78), !dbg !77
   tail call void @llvm.dbg.declare(metadata %struct.A* undef, metadata !38, metadata !79), !dbg !80

 
 invoke.cont:                                      ; preds = %call.i.i.noexc
   call void @llvm.lifetime.end(i64 24, i8* %1), !dbg !93
   call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82
   %call1 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94
   ret void, !dbg !94
 
 lpad:                                             ; preds = %call.i.i.noexc, %entry
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup, !dbg !94
   call void @llvm.dbg.value(metadata %struct.B* %d, i64 0, metadata !39, metadata !79), !dbg !82
   %call2 = call %struct.B* @_ZN1BD1Ev(%struct.B* %d) #3, !dbg !94
   resume { i8*, i32 } %3, !dbg !94
 }
 
 declare %struct.B* @_ZN1BC1El(%struct.B*, i64)
 

llvm/trunk/test/DebugInfo/SystemZ/eh_frame_personality.ll

 ; RUN: llc < %s -verify-machineinstrs -mtriple=s390x-linux-gnu | FileCheck -check-prefix=CHECK-FUNC %s
 ; RUN: llc < %s -verify-machineinstrs -mtriple=s390x-linux-gnu | FileCheck -check-prefix=CHECK-ET %s
 ; RUN: llc < %s -verify-machineinstrs -mtriple=s390x-linux-gnu -relocation-model=pic | FileCheck -check-prefix=CHECK-REF %s
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @bar()
 
-define i64 @foo(i64 %lhs, i64 %rhs) {
+define i64 @foo(i64 %lhs, i64 %rhs) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @bar() to label %end unwind label %clean
 end:
  ret i64 0
 
 clean:
-  %tst = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) cleanup
+  %tst = landingpad { i8*, i32 } cleanup
   ret i64 42
 }
 
 ; CHECK-FUNC: foo:
 ; CHECK-FUNC: .cfi_startproc
 ; CHECK-FUNC: .cfi_personality 0, __gxx_personality_v0
 ; CHECK-FUNC: .cfi_lsda 0, .Lexception0
 ; CHECK-FUNC: stmg  %r14, %r15, 112(%r15)

llvm/trunk/test/DebugInfo/X86/arange-and-stub.ll

 
 @_ZTId = external constant i8*
 @zed = global [1 x void ()*] [void ()* @bar]
 
 define void @foo() {
   ret void
 }
 
-define void @bar() {
+define void @bar() personality i8* bitcast (void ()* @foo to i8*) {
   invoke void @foo()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %0
   ret void
 
 lpad:                                             ; preds = %0
-  %tmp1 = landingpad { i8*, i32 } personality i8* bitcast (void ()* @foo to i8*)
+  %tmp1 = landingpad { i8*, i32 }
           filter [1 x i8*] [i8* bitcast (i8** @_ZTId to i8*)]
   ret void
 }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!17, !18}
 
 !0 = !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.7.0 (trunk 234308) (llvm/trunk 234310)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !10, imports: !2)

llvm/trunk/test/DebugInfo/X86/sret.ll

entry:
   %this.addr = alloca %class.A*, align 8
   store %class.A* %this, %class.A** %this.addr, align 8
   call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !101, metadata !DIExpression()), !dbg !102
   %this1 = load %class.A*, %class.A** %this.addr
   ret void, !dbg !103
 }
 
 ; Function Attrs: uwtable
-define i32 @main(i32 %argc, i8** %argv) #2 {
+define i32 @main(i32 %argc, i8** %argv) #2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %retval = alloca i32, align 4
   %argc.addr = alloca i32, align 4
   %argv.addr = alloca i8**, align 8
   %b = alloca %class.B, align 1
   %return_val = alloca i32, align 4
   %temp.lvalue = alloca %class.A, align 8
   %exn.slot = alloca i8*
invoke.cont:                                      ; preds = %entry
   %0 = load i32, i32* %return_val, align 4, !dbg !115
   store i32 %0, i32* %retval, !dbg !115
   store i32 1, i32* %cleanup.dest.slot
   call void @_ZN1AD2Ev(%class.A* %a), !dbg !116
   %1 = load i32, i32* %retval, !dbg !116
   ret i32 %1, !dbg !116
 
 lpad:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup, !dbg !116
   %3 = extractvalue { i8*, i32 } %2, 0, !dbg !116
   store i8* %3, i8** %exn.slot, !dbg !116
   %4 = extractvalue { i8*, i32 } %2, 1, !dbg !116
   store i32 %4, i32* %ehselector.slot, !dbg !116
   invoke void @_ZN1AD2Ev(%class.A* %temp.lvalue)
           to label %invoke.cont1 unwind label %terminate.lpad, !dbg !116
 
 invoke.cont1:                                     ; preds = %lpad
   br label %eh.resume, !dbg !117
 
 eh.resume:                                        ; preds = %invoke.cont1
   %exn = load i8*, i8** %exn.slot, !dbg !119
   %sel = load i32, i32* %ehselector.slot, !dbg !119
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn, 0, !dbg !119
   %lpad.val2 = insertvalue { i8*, i32 } %lpad.val, i32 %sel, 1, !dbg !119
   resume { i8*, i32 } %lpad.val2, !dbg !119
 
 terminate.lpad:                                   ; preds = %lpad
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           catch i8* null, !dbg !121
   %6 = extractvalue { i8*, i32 } %5, 0, !dbg !121
   call void @__clang_call_terminate(i8* %6) #5, !dbg !121
   unreachable, !dbg !121
 }
 
 ; Function Attrs: nounwind uwtable
 define linkonce_odr void @_ZN1BC2Ev(%class.B* %this) unnamed_addr #0 align 2 {
define linkonce_odr hidden void @__clang_call_terminate(i8*) #3 {
   unreachable
 }
 
 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @_ZSt9terminatev()
 
 ; Function Attrs: uwtable
-define linkonce_odr void @_ZN1AD0Ev(%class.A* %this) unnamed_addr #2 align 2 {
+define linkonce_odr void @_ZN1AD0Ev(%class.A* %this) unnamed_addr #2 align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %this.addr = alloca %class.A*, align 8
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store %class.A* %this, %class.A** %this.addr, align 8
   call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !126, metadata !DIExpression()), !dbg !127
   %this1 = load %class.A*, %class.A** %this.addr
   invoke void @_ZN1AD2Ev(%class.A* %this1)
           to label %invoke.cont unwind label %lpad, !dbg !128
 
 invoke.cont:                                      ; preds = %entry
   %0 = bitcast %class.A* %this1 to i8*, !dbg !129
   call void @_ZdlPv(i8* %0) #7, !dbg !129
   ret void, !dbg !129
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup, !dbg !131
   %2 = extractvalue { i8*, i32 } %1, 0, !dbg !131
   store i8* %2, i8** %exn.slot, !dbg !131
   %3 = extractvalue { i8*, i32 } %1, 1, !dbg !131
   store i32 %3, i32* %ehselector.slot, !dbg !131
   %4 = bitcast %class.A* %this1 to i8*, !dbg !131
   call void @_ZdlPv(i8* %4) #7, !dbg !131
   br label %eh.resume, !dbg !131

llvm/trunk/test/DebugInfo/inline-debug-info-multiret.ll

 }
 
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 declare i32 @_Z8test_exti(i32)
 
-define i32 @_Z5test2v()  {
+define i32 @_Z5test2v() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   %0 = load i32, i32* @global_var, align 4, !dbg !21
   %call = invoke i32 @_Z4testi(i32 %0)
           to label %invoke.cont unwind label %lpad, !dbg !21
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont, !dbg !23
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*), !dbg !21
   %2 = extractvalue { i8*, i32 } %1, 0, !dbg !21
   store i8* %2, i8** %exn.slot, !dbg !21
   %3 = extractvalue { i8*, i32 } %1, 1, !dbg !21
   store i32 %3, i32* %ehselector.slot, !dbg !21
   br label %catch.dispatch, !dbg !21
 
 catch.dispatch:                                   ; preds = %lpad

llvm/trunk/test/DebugInfo/inline-debug-info.ll

return:                                           ; preds = %if.end, %if.then
   ret i32 %3, !dbg !20
 }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 declare i32 @_Z8test_exti(i32)
 
-define i32 @_Z5test2v()  {
+define i32 @_Z5test2v() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %e = alloca i32, align 4
   %0 = load i32, i32* @global_var, align 4, !dbg !21
   %call = invoke i32 @_Z4testi(i32 %0)
           to label %invoke.cont unwind label %lpad, !dbg !21
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont, !dbg !23
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*), !dbg !21
   %2 = extractvalue { i8*, i32 } %1, 0, !dbg !21
   store i8* %2, i8** %exn.slot, !dbg !21
   %3 = extractvalue { i8*, i32 } %1, 1, !dbg !21
   store i32 %3, i32* %ehselector.slot, !dbg !21
   br label %catch.dispatch, !dbg !21
 
 catch.dispatch:                                   ; preds = %lpad

llvm/trunk/test/ExecutionEngine/MCJIT/Inputs/multi-module-eh-b.ll

 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException_B() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @FB() {
+define i32 @FB() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException_B()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/MCJIT/eh-lg-pic.ll

 ; RUN: %lli -relocation-model=pic -code-model=large %s
 ; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/MCJIT/eh-sm-pic.ll

 ; RUN: %lli -relocation-model=pic -code-model=small %s
 ; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, darwin, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/MCJIT/eh.ll

 ; RUN: %lli %s
 ; XFAIL: arm, cygwin, win32, mingw, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/MCJIT/multi-module-eh-a.ll

 declare i32 @FB()
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   %r = call i32 @FB( )
   ret i32 %r
 }

llvm/trunk/test/ExecutionEngine/OrcMCJIT/Inputs/multi-module-eh-b.ll

 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException_B() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @FB() {
+define i32 @FB() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException_B()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/OrcMCJIT/eh-lg-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -relocation-model=pic -code-model=large %s
 ; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/OrcMCJIT/eh-sm-pic.ll

 ; RUN: %lli -jit-kind=orc-mcjit -relocation-model=pic -code-model=small %s
 ; XFAIL: cygwin, win32, mingw, mips-, mipsel-, i686, i386, darwin, aarch64, arm, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/OrcMCJIT/eh.ll

 ; RUN: %lli -jit-kind=orc-mcjit %s
 ; XFAIL: arm, cygwin, win32, mingw, asan, msan
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_end_catch()
 declare i8* @__cxa_begin_catch(i8*)
 
 @_ZTIi = external constant i8*
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   ret i32 0
 }

llvm/trunk/test/ExecutionEngine/OrcMCJIT/multi-module-eh-a.ll

 declare i32 @FB()
 
 define void @throwException() {
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @throwException()
           to label %try.cont unwind label %lpad
 
 lpad:
-  %p = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %p = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %e = extractvalue { i8*, i32 } %p, 0
   call i8* @__cxa_begin_catch(i8* %e)
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:
   %r = call i32 @FB( )
   ret i32 %r
 }

llvm/trunk/test/Feature/callingconventions.ll

define void @foo2() {
         ret void
 }
 
 define coldcc void @bar2() {
         call fastcc void @foo( )
         ret void
 }
 
-define cc42 void @bar3() {
+define cc42 void @bar3() personality i32 (...)* @__gxx_personality_v0 {
   invoke fastcc void @foo( )
     to label %Ok unwind label %U
 
 Ok:
   ret void
 
 U:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   resume { i8*, i32 } %exn
 }
 
-define void @bar4() {
+define void @bar4() personality i32 (...)* @__gxx_personality_v0 {
   call cc42 void @bar( )
   invoke cc42 void @bar3( )
     to label %Ok unwind label %U
 
 Ok:
   ret void
 
 U:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   resume { i8*, i32 } %exn
 }
 
 declare ghccc void @ghc_callee()
 
 define void @ghc_caller() {
   call ghccc void @ghc_callee()
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Feature/calltest.ll

 ; RUN: llvm-as < %s | llvm-dis > %t1.ll
 ; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
 ; RUN: diff %t1.ll %t2.ll
 
 %FunTy = type i32 (i32)
 
 define void @invoke(%FunTy* %x) {
   %foo = call i32 %x( i32 123 )           ; <i32> [#uses=0]
   %foo2 = tail call i32 %x( i32 123 )             ; <i32> [#uses=0]
   ret void
 }
 
-define i32 @main(i32 %argc) {
+define i32 @main(i32 %argc) personality i32 (...)* @__gxx_personality_v0 {
   %retval = call i32 @test( i32 %argc )           ; <i32> [#uses=2]
   %two = add i32 %retval, %retval         ; <i32> [#uses=1]
   %retval2 = invoke i32 @test( i32 %argc )
      to label %Next unwind label %Error              ; <i32> [#uses=1]
 
 Next:
   %two2 = add i32 %two, %retval2          ; <i32> [#uses=1]
   call void @invoke( %FunTy* @test )
   ret i32 %two2
 
 Error:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   ret i32 -1
 }
 
 define i32 @test(i32 %i0) {
         ret i32 %i0
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Feature/exception.ll

 ; RUN: llvm-as < %s | llvm-dis > %t1.ll
 ; RUN: llvm-as %t1.ll -o - | llvm-dis > %t2.ll
 ; RUN: diff %t1.ll %t2.ll
 
 @_ZTIc = external constant i8*
 @_ZTId = external constant i8*
 @_ZTIPKc = external constant i8*
 
-define void @_Z3barv() uwtable optsize ssp {
+define void @_Z3barv() uwtable optsize ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z3quxv() optsize
           to label %try.cont unwind label %lpad
 
 try.cont:                                         ; preds = %entry, %invoke.cont4
   ret void
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
             catch i8** @_ZTIc
             filter [2 x i8**] [i8** @_ZTIPKc, i8** @_ZTId]
   resume { i8*, i32 } %exn
 }
 
 declare void @_Z3quxv() optsize
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Feature/seh-nounwind.ll

 ; RUN: opt -S -O2 < %s | FileCheck %s
 
 ; Feature test that verifies that all optimizations leave asynch personality
 ; invokes of nounwind functions alone.
 ; The @div function in this test can fault, even though it can't
 ; throw a synchronous exception.
 
 define i32 @div(i32 %n, i32 %d) nounwind noinline {
 entry:
   %div = sdiv i32 %n, %d
   ret i32 %div
 }
 
-define i32 @main() nounwind {
+define i32 @main() nounwind personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %call = invoke i32 @div(i32 10, i32 0)
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   br label %__try.cont
 
 __try.cont:
   %retval.0 = phi i32 [ %call, %entry ], [ 0, %lpad ]
   ret i32 %retval.0
 }
 
 ; CHECK-LABEL: define i32 @main()
 ; CHECK: invoke i32 @div(i32 10, i32 0)
 
 declare i32 @__C_specific_handler(...)

llvm/trunk/test/Instrumentation/AddressSanitizer/instrument-no-return.ll

 ; CHECK:        call void @__asan_handle_no_return
 ; CHECK-NEXT:   call void @MyNoReturnFunc
 ; CHECK-NEXT: unreachable
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)
 
-define i64 @Invoke1(i8** %esc) nounwind uwtable ssp sanitize_address {
+define i64 @Invoke1(i8** %esc) nounwind uwtable ssp sanitize_address personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @MyNoReturnFunc(i32 1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i64 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret i64 1
 }
 ; CHECK: @Invoke1
 ; CHECK:        call void @__asan_handle_no_return
 ; CHECK-NEXT:   invoke void @MyNoReturnFunc
 ; CHECK: ret i64 0
 ; CHECK: ret i64 1

llvm/trunk/test/LTO/X86/linkonce_odr_func.ll

define i32 @useV2() {
   %x = load i32, i32* @v2
   ret i32 %x
 }
 
 declare void @f(void()*)
 
 declare void @p()
 
-define void @bar() {
+define void @bar() personality void()* @p {
 bb0:
   call void @foo1()
   call void @f(void()* @foo2)
   invoke void @foo3() to label %bb1 unwind label %clean
 bb1:
   invoke void @f(void()* @foo4) to label %bb2 unwind label %clean
 bb2:
   ret void
 clean:
-  landingpad {i32, i32} personality void()* @p cleanup
+  landingpad {i32, i32} cleanup
   ret void
 }

llvm/trunk/test/Other/2008-10-15-MissingSpace.ll

 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 ; PR2894
 declare void @g()
-define void @f() {
+define void @f() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK:  invoke void @g()
 ; CHECK:           to label %d unwind label %c
   invoke void @g() to label %d unwind label %c
 d:
   ret void
 c:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Other/2009-03-31-CallGraph.ll

 ; RUN: opt < %s -inline -prune-eh -disable-output
-define void @f2() {
+define void @f2() personality i32 (...)* @__gxx_personality_v0 {
     invoke void @f6()
         to label %ok1 unwind label %lpad1
 
 ok1:
     ret void
 
 lpad1:
-    landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+    landingpad {i8*, i32}
             cleanup
     invoke void @f4()
         to label %ok2 unwind label %lpad2
 
 ok2:
     call void @f8()
     unreachable
 
 lpad2:
-    %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+    %exn = landingpad {i8*, i32}
             cleanup
     unreachable
 }
 
 declare void @f3()
 
 define void @f4() {
     call void @f3()
     ret void
 }
 
 declare void @f6() nounwind
 
 declare void @f8()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/ADCE/2003-09-10-UnwindInstFail.ll

 ; RUN: opt < %s -adce -disable-output
 
-define void @test() {
+define void @test() personality i32 (...)* @__gxx_personality_v0 {
         br i1 false, label %then, label %endif
 
 then:           ; preds = %0
         invoke void null( i8* null )
                         to label %invoke_cont unwind label %invoke_catch
 
 invoke_catch:           ; preds = %then
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         resume { i8*, i32 } %exn
 
 invoke_cont:            ; preds = %then
         ret void
 
 endif:          ; preds = %0
         ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/ADCE/2005-02-17-PHI-Invoke-Crash.ll

 ; RUN: opt < %s -adce -disable-output
 
 declare void @strlen()
 
 declare void @_ZN10QByteArray6resizeEi()
 
 declare void @q_atomic_decrement()
 
-define void @_ZNK10QByteArray13leftJustifiedEicb() {
+define void @_ZNK10QByteArray13leftJustifiedEicb() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         invoke void @strlen( )
                         to label %tmp.3.i.noexc unwind label %invoke_catch.0
 
 tmp.3.i.noexc:          ; preds = %entry
         br i1 false, label %then.0, label %else.0
 
 invoke_catch.0:         ; preds = %entry
-        %exn.0 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.0 = landingpad {i8*, i32}
                  cleanup
         invoke void @q_atomic_decrement( )
                         to label %tmp.1.i.i183.noexc unwind label %terminate
 
 tmp.1.i.i183.noexc:             ; preds = %invoke_catch.0
         ret void
 
 then.0:         ; preds = %tmp.3.i.noexc
         invoke void @_ZN10QByteArray6resizeEi( )
                         to label %invoke_cont.1 unwind label %invoke_catch.1
 
 invoke_catch.1:         ; preds = %then.0
-        %exn.1 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.1 = landingpad {i8*, i32}
                  cleanup
         invoke void @q_atomic_decrement( )
                         to label %tmp.1.i.i162.noexc unwind label %terminate
 
 tmp.1.i.i162.noexc:             ; preds = %invoke_catch.1
         ret void
 
 invoke_cont.1:          ; preds = %then.0
         ret void
 
 else.0:         ; preds = %tmp.3.i.noexc
         ret void
 
 terminate:              ; preds = %invoke_catch.1, %invoke_catch.0
         %dbg.0.1 = phi {  }* [ null, %invoke_catch.1 ], [ null, %invoke_catch.0 ]               ; <{  }*> [#uses=0]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/ADCE/dce_pure_invoke.ll

 ; RUN: opt < %s -adce -S | grep null
 
 declare i32 @strlen(i8*) readnone
 
-define i32 @test() {
+define i32 @test() personality i32 (...)* @__gxx_personality_v0 {
   ; invoke of pure function should not be deleted!
   invoke i32 @strlen( i8* null ) readnone
       to label %Cont unwind label %Other    ; <i32>:1 [#uses=0]
 
 Cont:   ; preds = %0
   ret i32 0
 
 Other:    ; preds = %0
-         %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+         %exn = landingpad {i8*, i32}
                   cleanup
   ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/ArgumentPromotion/crash.ll

 ; RUN: opt -inline -argpromotion < %s
 ; rdar://7879828
 
-define void @foo() {
+define void @foo() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @foo2()
           to label %if.end432 unwind label %for.end520 
 
 if.end432:  
   unreachable
 
 for.end520: 
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            cleanup
   unreachable
 }
 
 define internal  void @foo2() ssp {
   %call7 = call fastcc i8* @foo3(i1 (i8*)* @foo4)
   %call58 = call fastcc i8* @foo3(i1 (i8*)* @foo5)
   unreachable

llvm/trunk/test/Transforms/BDCE/dce-pure.ll

 ; RUN: opt -bdce -S < %s | FileCheck %s
 
 declare i32 @strlen(i8*) readonly nounwind
 
 define void @test1() {
   call i32 @strlen( i8* null )
   ret void
 
 ; CHECK-LABEL: @test1
 ; CHECK-NOT: call
 ; CHECK: ret void
 }
 
-define i32 @test2() {
+define i32 @test2() personality i32 (...)* @__gxx_personality_v0 {
   ; invoke of pure function should not be deleted!
   invoke i32 @strlen( i8* null ) readnone
                   to label %Cont unwind label %Other
 
 Cont:           ; preds = %0
   ret i32 0
 
 Other:          ; preds = %0
-   %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+   %exn = landingpad {i8*, i32}
             cleanup
   ret i32 1
 
 ; CHECK-LABEL: @test2
 ; CHECK: invoke
 ; CHECK: ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)
 

llvm/trunk/test/Transforms/BDCE/order.ll

 ; RUN: opt -bdce -S < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i32 @__gxx_personality_v0(...)
 
-define fastcc void @_ZN11__sanitizerL12TestRegistryEPNS_14ThreadRegistryEb() #0 {
+define fastcc void @_ZN11__sanitizerL12TestRegistryEPNS_14ThreadRegistryEb() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br i1 undef, label %if.else, label %entry.if.end_crit_edge
 
 if.else:
   ret void
 
 invoke.cont70:
   store i32 %call71, i32* undef, align 4
   br label %if.else
 
 ; CHECK-LABEL: @_ZN11__sanitizerL12TestRegistryEPNS_14ThreadRegistryEb
 ; CHECK: store i32 %call71
 
 lpad65.loopexit.split-lp.loopexit.split-lp:
   br label %if.else
 
 lpad65.loopexit.split-lp.loopexit.split-lp.loopexit:
-  %lpad.loopexit1121 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %lpad.loopexit1121 = landingpad { i8*, i32 }
           cleanup
   br label %lpad65.loopexit.split-lp.loopexit.split-lp
 
 entry.if.end_crit_edge:
   %call71 = invoke i32 @_ZN11__sanitizer14ThreadRegistry12CreateThreadEmbjPv()
           to label %invoke.cont70 unwind label %lpad65.loopexit.split-lp.loopexit.split-lp.loopexit
 }
 
 declare i32 @_ZN11__sanitizer14ThreadRegistry12CreateThreadEmbjPv()
 
 attributes #0 = { uwtable }
 

llvm/trunk/test/Transforms/CodeExtractor/2004-03-18-InvokeHandling.ll

 ; RUN: opt < %s -loop-extract -disable-output
 
 declare i32 @_IO_getc()
 
 declare void @__errno_location()
 
-define void @yylex() {
+define void @yylex() personality i32 (...)* @__gcc_personality_v0 {
 entry:
   switch i32 0, label %label.126 [
      i32 0, label %return
      i32 61, label %combine
      i32 33, label %combine
      i32 94, label %combine
      i32 37, label %combine
      i32 47, label %combine

 
 label.126:    ; preds = %entry
   ret void
 
 return:   ; preds = %entry
   ret void
 
 LongJmpBlkPre:    ; preds = %endif.52, %then.40
-        %exn = landingpad { i8*, i32 } personality i32 (...)* @__gcc_personality_v0
+        %exn = landingpad { i8*, i32 }
                  catch i8* null
   ret void
 }
 
 declare i32 @__gcc_personality_v0(...)

llvm/trunk/test/Transforms/CodeExtractor/2004-11-12-InvokeExtract.ll

 ; RUN: opt < %s -extract-blocks -disable-output
-define i32 @foo() {
+define i32 @foo() personality i32 (...)* @__gcc_personality_v0 {
         br label %EB
 
 EB:             ; preds = %0
         %V = invoke i32 @foo( )
                         to label %Cont unwind label %Unw                ; <i32> [#uses=1]
 
 Cont:           ; preds = %EB
         ret i32 %V
 
 Unw:            ; preds = %EB
-        %exn = landingpad { i8*, i32 } personality i32 (...)* @__gcc_personality_v0
+        %exn = landingpad { i8*, i32 }
                  catch i8* null
         resume { i8*, i32 } %exn
 }
 
 declare i32 @__gcc_personality_v0(...)

llvm/trunk/test/Transforms/DeadArgElim/2009-03-17-MRE-Invoke.ll

 ; RUN: opt < %s -deadargelim | llvm-dis
 ; PR3807
 
 define internal { i32, i32 } @foo() {
   ret {i32,i32} {i32 42, i32 4}
 }
 
-define i32 @bar() {
+define i32 @bar() personality i32 (...)* @__gxx_personality_v0 {
   %x = invoke {i32,i32} @foo() to label %T unwind label %T2
 T:
   %y = extractvalue {i32,i32} %x, 1
   ret i32 %y
 T2:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
-define i32 @bar2() {
+define i32 @bar2() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %x = invoke {i32,i32} @foo() to label %T unwind label %T2
 T:
   %PN = phi i32 [0, %entry]
   %y = extractvalue {i32,i32} %x, 1
   ret i32 %y
 T2:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/FunctionAttrs/nocapture.ll

define i1 @c5(i32* %q, i32 %bitno) {
   %lookup = getelementptr [2 x i1], [2 x i1]* @lookup_table, i32 0, i32 %bit
   %val = load i1, i1* %lookup
   ret i1 %val
 }
 
 declare void @throw_if_bit_set(i8*, i8) readonly
 
 ; CHECK: define i1 @c6(i8* readonly %q, i8 %bit)
-define i1 @c6(i8* %q, i8 %bit) {
+define i1 @c6(i8* %q, i8 %bit) personality i32 (...)* @__gxx_personality_v0 {
   invoke void @throw_if_bit_set(i8* %q, i8 %bit)
     to label %ret0 unwind label %ret1
 ret0:
   ret i1 0
 ret1:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   ret i1 1
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 define i1* @lookup_bit(i32* %q, i32 %bitno) readnone nounwind {
   %tmp = ptrtoint i32* %q to i32

llvm/trunk/test/Transforms/GVN/2010-05-08-OneBit.ll

 ; RUN: opt < %s -gvn
 ; PR7052
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
-define i32 @main(i32 %argc, i8** nocapture %argv) {
+define i32 @main(i32 %argc, i8** nocapture %argv) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %0 = getelementptr inbounds i8, i8* undef, i64 5    ; <i8*> [#uses=1]
   %1 = bitcast i8* %0 to i32*                     ; <i32*> [#uses=1]
   store i32 undef, i32* %1, align 1
   br i1 undef, label %k121.i.i, label %l117.i.i
 
 l117.i.i:                                         ; preds = %entry
   invoke fastcc void @foo()

 
 .noexc10:                                         ; preds = %l147.i.i
   unreachable
 
 k151.i.i:                                         ; preds = %k133.i.i
   ret i32 0
 
 landing_pad:                                      ; preds = %l147.i.i, %l129.i.i, %l117.i.i
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   switch i32 undef, label %fin [
     i32 1, label %catch1
     i32 2, label %catch
   ]
 
 fin:                                              ; preds = %landing_pad
   unreachable

llvm/trunk/test/Transforms/GVN/2011-09-07-TypeIdFor.ll

 declare i32 @llvm.eh.typeid.for(i8*) nounwind readonly
 
 declare i8* @__cxa_begin_catch(i8*) nounwind
 
 declare void @__cxa_end_catch()
 
 declare i32 @__gxx_personality_v0(i32, i64, i8*, i8*)
 
-define void @_Z3foov() uwtable {
+define void @_Z3foov() uwtable personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z4barv()
           to label %return unwind label %lpad
 
 lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %0 = landingpad { i8*, i32 }
           catch %struct.__fundamental_type_info_pseudo* @_ZTIi
           catch %struct.__fundamental_type_info_pseudo* @_ZTIb
           catch %struct.__fundamental_type_info_pseudo* @_ZTIi
           catch %struct.__fundamental_type_info_pseudo* @_ZTIb
   %exc_ptr2.i = extractvalue { i8*, i32 } %0, 0
   %filter3.i = extractvalue { i8*, i32 } %0, 1
   %typeid.i = tail call i32 @llvm.eh.typeid.for(i8* bitcast (%struct.__fundamental_type_info_pseudo* @_ZTIi to i8*))
 ; CHECK: call i32 @llvm.eh.typeid.for

llvm/trunk/test/Transforms/GVN/cond_br2.ll

 ; RUN: opt -basicaa -gvn -S < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 %"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] }
 %"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" }
 %"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" }
 %"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" }
 %"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" }
 %"union.llvm::SmallVectorBase::U" = type { x86_fp80 }
 
 ; Function Attrs: ssp uwtable
-define void @_Z4testv() #0 {
+define void @_Z4testv() #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK: @_Z4testv()
 ; CHECK: invoke.cont:
 ; CHECK: br i1 true, label %new.notnull.i11, label %if.end.i14
 ; CHECK: Retry.i10:
 
 entry:
   %sv = alloca %"class.llvm::SmallVector", align 16
   %0 = bitcast %"class.llvm::SmallVector"* %sv to i8*
if.then.i.i.i20:                                  ; preds = %invoke.cont3
   call void @free(i8* %11) #1
   br label %_ZN4llvm11SmallVectorIiLj8EED1Ev.exit21
 
 _ZN4llvm11SmallVectorIiLj8EED1Ev.exit21:          ; preds = %invoke.cont3, %if.then.i.i.i20
   call void @llvm.lifetime.end(i64 64, i8* %0) #1
   ret void
 
 lpad:                                             ; preds = %if.end.i14, %if.end.i, %invoke.cont2
-  %12 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %12 = landingpad { i8*, i32 }
           cleanup
   %13 = load i8*, i8** %BeginX.i.i.i.i.i.i, align 16, !tbaa !4
   %cmp.i.i.i.i = icmp eq i8* %13, %1
   br i1 %cmp.i.i.i.i, label %eh.resume, label %if.then.i.i.i
 
 if.then.i.i.i:                                    ; preds = %lpad
   call void @free(i8* %13) #1
   br label %eh.resume

llvm/trunk/test/Transforms/GlobalOpt/cleanup-pointer-root-users.ll

; CHECK: alloca i8
   call void @foo2(i8* %txt)
   %call2 = call i8* @strdup(i8* %txt)
   store i8* %call2, i8** @glbl
   ret void
 }
 declare i8* @strdup(i8*)
 declare void @foo2(i8*)
 
-define void @test3() uwtable {
+define void @test3() uwtable personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @test3(
 ; CHECK-NOT: bb1:
 ; CHECK-NOT: bb2:
 ; CHECK: invoke
   %ptr = invoke i8* @_Znwm(i64 1)
           to label %bb1 unwind label %bb2
 bb1:
   store i8* %ptr, i8** @glbl
   unreachable
 bb2:
-  %tmp1 = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %tmp1 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } %tmp1
 }
 declare i32 @__gxx_personality_v0(i32, i64, i8*, i8*)
 declare i8* @_Znwm(i64)

llvm/trunk/test/Transforms/GlobalOpt/invoke.ll

 ; RUN: opt -S -globalopt < %s | FileCheck %s
 ; rdar://11022897
 
 ; Globalopt should be able to evaluate an invoke.
 ; CHECK: @tmp = global i32 1
 
 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @_GLOBAL__I_a }]
 @tmp = global i32 0
 
 define i32 @one() {
   ret i32 1
 }
 
-define void @_GLOBAL__I_a() {
+define void @_GLOBAL__I_a() personality i8* undef {
 bb:
   %tmp1 = invoke i32 @one()
           to label %bb2 unwind label %bb4
 
 bb2:                                              ; preds = %bb
   store i32 %tmp1, i32* @tmp
   ret void
 
 bb4:                                              ; preds = %bb
-  %tmp5 = landingpad { i8*, i32 } personality i8* undef
+  %tmp5 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   unreachable
 }

llvm/trunk/test/Transforms/IPConstantProp/return-argument.ll

 ;; value
 define internal { i32, i32 } @foo(i32 %A, i32 %B) {
         %X = add i32 %A, %B
         %Y = insertvalue { i32, i32 } undef, i32 %A, 0
         %Z = insertvalue { i32, i32 } %Y, i32 %X, 1
         ret { i32, i32 } %Z
 }
 
-define void @caller(i1 %C) {
+define void @caller(i1 %C) personality i32 (...)* @__gxx_personality_v0 {
         %Q = alloca i32
         ;; Call incdec to see if %W is properly replaced by %Q
         %W = call i32* @incdec(i1 %C, i32* %Q )             ; <i32> [#uses=1]
         ;; Call @foo twice, to prevent the arguments from propagating into the
         ;; function (so we can check the returned argument is properly
         ;; propagated per-caller).
         %S1 = call { i32, i32 } @foo(i32 1, i32 2)
         %X1 = extractvalue { i32, i32 } %S1, 0
         %S2 = invoke { i32, i32 } @foo(i32 3, i32 4) to label %OK unwind label %LPAD
 
 OK:
         %X2 = extractvalue { i32, i32 } %S2, 0
         ;; Do some stuff with the returned values which we can grep for
         %Z  = add i32 %X1, %X2
         store i32 %Z, i32* %W
         br label %RET
 
 LPAD:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         br label %RET
 
 RET:
         ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/IPConstantProp/return-constant.ll

 }
 
 define i1 @caller(i1 %C) {
         %X = call i32 @foo( i1 %C )             ; <i32> [#uses=1]
         %Y = icmp ne i32 %X, 0          ; <i1> [#uses=1]
         ret i1 %Y
 }
 
-define i1 @invokecaller(i1 %C) {
+define i1 @invokecaller(i1 %C) personality i32 (...)* @__gxx_personality_v0 {
         %X = invoke i32 @foo( i1 %C ) to label %OK unwind label %FAIL             ; <i32> [#uses=1]
 OK:
         %Y = icmp ne i32 %X, 0          ; <i1> [#uses=1]
         ret i1 %Y 
 FAIL:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i1 false
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/IndVarSimplify/2004-04-05-InvokeCastCrash.ll

 declare void @_ZNK4llvm8Function15getFunctionTypeEv()
 
 declare void @_ZNK4llvm19MachineInstrBuilder7addMRegEiNS_14MachineOperand7UseTypeE()
 
 declare void @_ZNK4llvm19MachineInstrBuilder7addSImmEi()
 
 declare i32 @__gxx_personality_v0(...)
 
-define void @_ZN4llvm11_GLOBAL__N_22InsertPrologEpilogCode20runOnMachineFunctionERNS_15MachineFunctionE(%"struct.llvm::MachineFunction"* %F) {
+define void @_ZN4llvm11_GLOBAL__N_22InsertPrologEpilogCode20runOnMachineFunctionERNS_15MachineFunctionE(%"struct.llvm::MachineFunction"* %F) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %tmp.8.i = invoke %"struct.llvm::TargetFrameInfo"* null( %"struct.llvm::TargetMachine"* null )
       to label %invoke_cont.0.i unwind label %invoke_catch.0.i    ; <%"struct.llvm::TargetFrameInfo"*> [#uses=0]
 
 invoke_catch.0.i:    ; preds = %invoke_cont.49.i, %invoke_cont.48.i, %invoke_cont.47.i, %invoke_cont.i53.i, %no_exit.i, %invoke_cont.44.i, %invoke_cont.43.i, %invoke_cont.42.i, %invoke_cont.41.i, %invoke_cont.40.i, %invoke_cont.39.i, %invoke_cont.38.i, %invoke_cont.37.i, %then.2.i, %invoke_cont.35.i, %invoke_cont.34.i, %then.1.i, %endif.0.i, %invoke_cont.9.i, %invoke_cont.8.i, %invoke_cont.7.i, %invoke_cont.i.i, %then.0.i, %invoke_cont.4.i, %invoke_cont.3.i, %invoke_cont.2.i, %invoke_cont.1.i, %endif.0.i.i, %tmp.7.i.noexc.i, %invoke_cont.0.i, %entry
-        %exn0.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn0.i = landingpad {i8*, i32}
                  cleanup
   ret void
 
 invoke_cont.0.i:    ; preds = %entry
   %tmp.7.i1.i = invoke %"struct.llvm::TargetFrameInfo"* null( %"struct.llvm::TargetMachine"* null )
       to label %tmp.7.i.noexc.i unwind label %invoke_catch.0.i    ; <%"struct.llvm::TargetFrameInfo"*> [#uses=2]
 
 tmp.7.i.noexc.i:    ; preds = %invoke_cont.0.i
then.0.i:   ; preds = %invoke_cont.5.i
   invoke void @_Znwj( )
       to label %tmp.0.i.noexc.i unwind label %invoke_catch.0.i
 
 tmp.0.i.noexc.i:    ; preds = %then.0.i
   invoke void @_ZN4llvm12MachineInstrC1Esjbb( )
       to label %invoke_cont.i.i unwind label %cond_true.i.i
 
 cond_true.i.i:    ; preds = %tmp.0.i.noexc.i
-        %exn.i.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i.i = landingpad {i8*, i32}
                  cleanup
   ret void
 
 invoke_cont.i.i:    ; preds = %tmp.0.i.noexc.i
   invoke void @_ZNK4llvm19MachineInstrBuilder7addMRegEiNS_14MachineOperand7UseTypeE( )
       to label %invoke_cont.7.i unwind label %invoke_catch.0.i
 
 invoke_cont.7.i:    ; preds = %invoke_cont.i.i
no_exit.i:    ; preds = %invoke_cont.50.i, %invoke_cont.45.i
   invoke void @_Znwj( )
       to label %tmp.0.i.noexc55.i unwind label %invoke_catch.0.i
 
 tmp.0.i.noexc55.i:    ; preds = %no_exit.i
   invoke void @_ZN4llvm12MachineInstrC1Esjbb( )
       to label %invoke_cont.i53.i unwind label %cond_true.i52.i
 
 cond_true.i52.i:    ; preds = %tmp.0.i.noexc55.i
-        %exn.i52.i = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn.i52.i = landingpad {i8*, i32}
                  cleanup
   ret void
 
 invoke_cont.i53.i:    ; preds = %tmp.0.i.noexc55.i
   invoke void @_ZNK4llvm19MachineInstrBuilder7addMRegEiNS_14MachineOperand7UseTypeE( )
       to label %invoke_cont.47.i unwind label %invoke_catch.0.i
 
 invoke_cont.47.i:   ; preds = %invoke_cont.i53.i

llvm/trunk/test/Transforms/IndVarSimplify/2005-02-11-InvokeCrash.ll

 ; RUN: opt < %s -indvars -disable-output
 
-define void @_ZN5ArrayISt7complexIdEEC2ERK10dim_vector() {
+define void @_ZN5ArrayISt7complexIdEEC2ERK10dim_vector() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         %tmp.7 = invoke i32 @_ZN5ArrayISt7complexIdEE8get_sizeERK10dim_vector( )
                         to label %invoke_cont.0 unwind label %cond_true.1               ; <i32> [#uses=2]
 
 invoke_cont.0:          ; preds = %entry
         %tmp.4.i = bitcast i32 %tmp.7 to i32            ; <i32> [#uses=0]
         %tmp.14.0.i5 = add i32 %tmp.7, -1               ; <i32> [#uses=1]
         br label %no_exit.i
 
 no_exit.i:              ; preds = %no_exit.i, %invoke_cont.0
         %tmp.14.0.i.0 = phi i32 [ %tmp.14.0.i, %no_exit.i ], [ %tmp.14.0.i5, %invoke_cont.0 ]           ; <i32> [#uses=1]
         %tmp.14.0.i = add i32 %tmp.14.0.i.0, -1         ; <i32> [#uses=1]
         br label %no_exit.i
 
 cond_true.1:            ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         resume { i8*, i32 } %exn
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare i32 @_ZN5ArrayISt7complexIdEE8get_sizeERK10dim_vector()
 

llvm/trunk/test/Transforms/IndVarSimplify/2005-02-17-TruncateExprCrash.ll

 ; RUN: opt < %s -indvars -disable-output
 
 declare void @q_atomic_increment()
 
 declare void @_Z9qt_assertPKcS0_i()
 
-define void @_ZN13QMetaResourceC1EPKh() {
+define void @_ZN13QMetaResourceC1EPKh() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @_Z9qt_assertPKcS0_i( )
       to label %endif.1 unwind label %then.i.i551
 
 then.i.i551:    ; preds = %entry
-        %exn551 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn551 = landingpad {i8*, i32}
                  cleanup
   ret void
 
 endif.1:    ; preds = %entry
   br i1 false, label %then.2, label %then.i.i
 
 then.2:   ; preds = %endif.1
   invoke void @q_atomic_increment( )
       to label %loopentry.0 unwind label %invoke_catch.6
 
 invoke_catch.6:   ; preds = %then.2
-        %exn6 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn6 = landingpad {i8*, i32}
                  cleanup
   ret void
 
 loopentry.0:    ; preds = %then.2
   br i1 false, label %shortcirc_next.i, label %endif.3
 
 endif.3:    ; preds = %loopentry.0
   ret void

llvm/trunk/test/Transforms/IndVarSimplify/crash.ll

 ; PR10770
 
 declare void @__go_panic() noreturn
 
 declare void @__go_undefer()
 
 declare i32 @__gccgo_personality_v0(i32, i64, i8*, i8*)
 
-define void @main.main() uwtable {
+define void @main.main() uwtable personality i32 (i32, i64, i8*, i8*)* @__gccgo_personality_v0 {
 entry:
   invoke void @__go_panic() noreturn
           to label %0 unwind label %"5.i"
 
 ; <label>:0                                       ; preds = %entry
   unreachable
 
 "3.i":                                            ; preds = %"7.i", %"5.i"
   invoke void @__go_undefer()
           to label %main.f.exit unwind label %"7.i"
 
 "5.i":                                            ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gccgo_personality_v0
+  %1 = landingpad { i8*, i32 }
           catch i8* null
   br label %"3.i"
 
 "7.i":                                            ; preds = %"3.i"
-  %2 = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gccgo_personality_v0
+  %2 = landingpad { i8*, i32 }
           catch i8* null
   br label %"3.i"
 
 main.f.exit:                                      ; preds = %"3.i"
   unreachable
 }
 
 

llvm/trunk/test/Transforms/IndVarSimplify/interesting-invoke-use.ll

 ; RUN: opt < %s -indvars
 
 ; An invoke has a result value which is used in an "Interesting"
 ; expression inside the loop. IndVars should be able to rewrite
 ; the expression in the correct place.
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
 target triple = "i386-pc-linux-gnu"
   %struct.string___XUB = type { i32, i32 }
   %struct.string___XUP = type { [0 x i8]*, %struct.string___XUB* }
 @.str7 = external constant [24 x i8]            ; <[24 x i8]*> [#uses=1]
 @C.17.316 = external constant %struct.string___XUB              ; <%struct.string___XUB*> [#uses=1]
 
-define void @_ada_c35503g() {
+define void @_ada_c35503g() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br label %bb
 
 bb:             ; preds = %bb, %entry
   br i1 false, label %bb65.loopexit, label %bb
 
 bb65.loopexit:          ; preds = %bb
   br label %bb123

 invcont138:             ; preds = %invcont129
   unreachable
 
 bb178:          ; preds = %invcont127
   %3 = add i32 %i.0, 1          ; <i32> [#uses=1]
   br label %bb123
 
 lpad266:                ; preds = %invcont129, %bb128, %bb123
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @system__img_int__image_integer(%struct.string___XUP* noalias sret, i32)
 
 declare void @system__string_ops__str_concat(%struct.string___XUP* noalias sret, [0 x i8]*, %struct.string___XUB*, [0 x i8]*, %struct.string___XUB*)
 
 declare i32 @report__ident_int(i32)

llvm/trunk/test/Transforms/Inline/2003-09-14-InlineValue.ll

 ; RUN: opt < %s -inline -disable-output
 
 declare i32 @External()
 
 define internal i32 @Callee() {
         %I = call i32 @External( )              ; <i32> [#uses=2]
         %J = add i32 %I, %I             ; <i32> [#uses=1]
         ret i32 %J
 }
 
-define i32 @Caller() {
+define i32 @Caller() personality i32 (...)* @__gxx_personality_v0 {
         %V = invoke i32 @Callee( )
                         to label %Ok unwind label %Bad          ; <i32> [#uses=1]
 
 Ok:             ; preds = %0
         ret i32 %V
 
 Bad:            ; preds = %0
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 0
 }
 
 declare i32 @__gxx_personality_v0(...)
 

llvm/trunk/test/Transforms/Inline/2003-09-22-PHINodeInlineFail.ll

 ; RUN: opt < %s -inline -disable-output
 
-define i32 @main() {
+define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         invoke void @__main( )
                         to label %LongJmpBlkPost unwind label %LongJmpBlkPre
 
 LongJmpBlkPost:
         ret i32 0
 
 LongJmpBlkPre:
         %i.3 = phi i32 [ 0, %entry ]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 0
 }
 
 define void @__main() {
         ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Inline/2003-09-22-PHINodesInExceptionDest.ll

 ; RUN: opt < %s -inline -disable-output
 
-define i32 @main() {
+define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         invoke void @__main( )
                         to label %Call2Invoke unwind label %LongJmpBlkPre
 
 Call2Invoke:            ; preds = %entry
         br label %exit
 
 LongJmpBlkPre:          ; preds = %Call2Invoke, %entry
         %i.3 = phi i32 [ 0, %entry ]
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         br label %exit
 
 exit:
         ret i32 0
 }
 
 define void @__main() {

llvm/trunk/test/Transforms/Inline/2003-09-22-PHINodesInNormalInvokeDest.ll

 ; RUN: opt < %s -inline -disable-output
 
-define i32 @main() {
+define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         invoke void @__main( )
                         to label %else unwind label %RethrowExcept
 
 else:           ; preds = %LJDecisionBB, %entry
         %i.2 = phi i32 [ 36, %entry ], [ %i.2, %LJDecisionBB ]          ; <i32> [#uses=1]
         br label %LJDecisionBB
 
 LJDecisionBB:           ; preds = %else
         br label %else
 
 RethrowExcept:          ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 0
 }
 
 define void @__main() {
         ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Inline/2006-11-09-InlineCGUpdate-2.ll

entry:
   ret void
 }
 
 define void @_ZNSt9bad_allocD1Ev() {
 entry:
   unreachable
 }
 
-define fastcc void @_ZSt19__throw_logic_errorPKc() {
+define fastcc void @_ZSt19__throw_logic_errorPKc() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke fastcc void @_ZNSt11logic_errorC1ERKSs( )
       to label %try_exit.0 unwind label %try_catch.0
 
 try_catch.0:    ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   resume { i8*, i32 } %exn
 
 try_exit.0:   ; preds = %entry
   unreachable
 }
 
 define fastcc void @_ZNSt11logic_errorC1ERKSs() {
 entry:
   call fastcc void @_ZNSsC1ERKSs( )
   ret void
 }
 
 define void @_ZNSt12domain_errorD1Ev() {
 entry:
   unreachable
 }
 
 define fastcc void @_ZSt20__throw_length_errorPKc() {
 entry:
   call fastcc void @_ZNSt12length_errorC1ERKSs( )
   unreachable
 }
 
-define fastcc void @_ZNSt12length_errorC1ERKSs() {
+define fastcc void @_ZNSt12length_errorC1ERKSs() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke fastcc void @_ZNSsC1ERKSs( )
       to label %_ZNSt11logic_errorC2ERKSs.exit unwind label %invoke_catch.i
 
 invoke_catch.i:   ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   resume { i8*, i32 } %exn
 
 _ZNSt11logic_errorC2ERKSs.exit:   ; preds = %entry
   ret void
 }
 
 define fastcc void @_ZNSs4_Rep9_S_createEjRKSaIcE() {
then.1.i:   ; preds = %entry
   call fastcc void @_ZSt19__throw_logic_errorPKc( )
   br label %endif.1.i
 
 endif.1.i:    ; preds = %then.1.i, %entry
   call fastcc void @_ZNSs4_Rep9_S_createEjRKSaIcE( )
   unreachable
 }
 
-define fastcc void @_ZNSsC1ERKSs() {
+define fastcc void @_ZNSsC1ERKSs() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   call fastcc void @_ZNSs4_Rep7_M_grabERKSaIcES2_( )
   invoke fastcc void @_ZNSaIcEC1ERKS_( )
       to label %invoke_cont.1 unwind label %invoke_catch.1
 
 invoke_catch.1:   ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   call fastcc void @_ZNSaIcED1Ev( )
   resume { i8*, i32 } %exn
 
 invoke_cont.1:    ; preds = %entry
   call fastcc void @_ZNSaIcEC2ERKS_( )
   ret void
 }

llvm/trunk/test/Transforms/Inline/2006-11-09-InlineCGUpdate.ll

then.1.i:   ; preds = %entry
   call fastcc void @_ZSt19__throw_logic_errorPKc( )
   ret void
 
 endif.1.i:    ; preds = %entry
   call fastcc void @_ZNSs4_Rep9_S_createEjRKSaIcE( )
   unreachable
 }
 
-define fastcc void @_ZNSsC1ERKSs() {
+define fastcc void @_ZNSsC1ERKSs() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   call fastcc void @_ZNSs4_Rep7_M_grabERKSaIcES2_( )
   invoke fastcc void @_ZNSaIcEC1ERKS_( )
       to label %invoke_cont.1 unwind label %invoke_catch.1
 
 invoke_catch.1:   ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   call fastcc void @_ZNSaIcED1Ev( )
   resume { i8*, i32 } %exn
 
 invoke_cont.1:    ; preds = %entry
   call fastcc void @_ZNSaIcEC2ERKS_( )
   ret void
 }
entry:
   ret void
 }
 
 define fastcc void @_ZNSt11logic_errorD2Ev() {
 entry:
   unreachable
 }
 
-define fastcc void @_ZNSt12length_errorC1ERKSs() {
+define fastcc void @_ZNSt12length_errorC1ERKSs() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke fastcc void @_ZNSsC1ERKSs( )
       to label %_ZNSt11logic_errorC2ERKSs.exit unwind label %invoke_catch.i
 
 invoke_catch.i:   ; preds = %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
   resume { i8*, i32 } %exn
 
 _ZNSt11logic_errorC2ERKSs.exit:   ; preds = %entry
   ret void
 }
 
 define void @_ZNK10__cxxabiv120__si_class_type_info20__do_find_public_srcEiPKvPKNS_17__class_type_infoES2_() {

llvm/trunk/test/Transforms/Inline/2007-04-15-InlineEH.ll

 ; RUN: opt < %s -inline -S | not grep "invoke void asm"
 ; PR1335
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64"
 target triple = "i686-pc-linux-gnu"
   %struct.gnat__strings__string_access = type { i8*, %struct.string___XUB* }
   %struct.string___XUB = type { i32, i32 }
 
 define void @bc__support__high_resolution_time__clock() {
 entry:
   call void asm "rdtsc\0A\09movl %eax, $0\0A\09movl %edx, $1", "=*imr,=*imr,~{dirflag},~{fpsr},~{flags},~{dx},~{ax}"( i32* null, i32* null ) nounwind
   unreachable
 }
 
-define fastcc void @bc__support__high_resolution_time__initialize_clock_rate() {
+define fastcc void @bc__support__high_resolution_time__initialize_clock_rate() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @gnat__os_lib__getenv( %struct.gnat__strings__string_access* null )
       to label %invcont unwind label %cleanup144
 
 invcont:    ; preds = %entry
   invoke void @ada__calendar__delays__delay_for( )
       to label %invcont64 unwind label %cleanup144
 
 invcont64:    ; preds = %invcont
   invoke void @ada__calendar__clock( )
       to label %invcont65 unwind label %cleanup144
 
 invcont65:    ; preds = %invcont64
   invoke void @bc__support__high_resolution_time__clock( )
       to label %invcont67 unwind label %cleanup144
 
 invcont67:    ; preds = %invcont65
   ret void
 
 cleanup144:   ; preds = %invcont65, %invcont64, %invcont, %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   resume { i8*, i32 } %exn
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @gnat__os_lib__getenv(%struct.gnat__strings__string_access*)
 

llvm/trunk/test/Transforms/Inline/callgraph-update.ll

bb5:
   unreachable
 }
 
 define internal fastcc void @parse() {
   call fastcc void @read()
   ret void
 }
 
-define void @main() {
+define void @main() personality i32 (...)* @__gxx_personality_v0 {
   invoke fastcc void @parse()
       to label %invcont unwind label %lpad
 
 invcont:
   unreachable
 
 lpad:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   unreachable
 }
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Inline/crash.ll

 declare fastcc void @list_Rplacd1284() nounwind ssp
 
 
 
 
 ;============================
 ; PR5208
 
-define void @AAA() {
+define void @AAA() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %A = alloca i8, i32 undef, align 1
   invoke fastcc void @XXX()
           to label %invcont98 unwind label %lpad156 
 
 invcont98:                          
   unreachable
 
 lpad156:                            
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare fastcc void @YYY()
 
-define internal fastcc void @XXX() {
+define internal fastcc void @XXX() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %B = alloca i8, i32 undef, align 1
   invoke fastcc void @YYY()
           to label %bb260 unwind label %lpad
 
 bb260:                              
   ret void
 
 lpad:                               
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   resume { i8*, i32 } %exn
 }
 
 
 
 ;; This exposed a crash handling devirtualized calls.
 define void @f1(void ()* %f) ssp {
 entry:
   call void %f()
   ret void
 }
 
-define void @f4(i32 %size) ssp {
+define void @f4(i32 %size) ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @f1(void ()* @f3)
           to label %invcont3 unwind label %lpad18
 
 invcont3:                                         ; preds = %bb1
   ret void
 
 lpad18:                                           ; preds = %invcont3, %bb1
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   unreachable
 }
 
 define void @f3() ssp {
 entry:
   unreachable
 }
 
 declare void @f5() ssp
 
 
 

llvm/trunk/test/Transforms/Inline/debug-invoke.ll

 declare i32 @__gxx_personality_v0(...)
 
 attributes #0 = { alwaysinline }
 define void @inl() #0 {
   call void @test(), !dbg !3
   ret void
 }
 
-define void @caller() {
+define void @caller() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   invoke void @inl()
     to label %cont unwind label %lpad, !dbg !4
 
 cont:
   ret void
 
 lpad:
-  landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  landingpad { i8*, i32 }
     cleanup
   ret void
 }
 
 !llvm.module.flags = !{!1}
 !1 = !{i32 2, !"Debug Info Version", i32 3}
 !2 = !DISubprogram()
 !3 = !DILocation(line: 1, scope: !2)
 !4 = !DILocation(line: 2, scope: !2)

llvm/trunk/test/Transforms/Inline/inline-invoke-tail.ll

 ; RUN: opt < %s -inline -S | not grep "tail call void @llvm.memcpy.i32"
 ; PR3550
 
 define internal void @foo(i32* %p, i32* %q) {
   %pp = bitcast i32* %p to i8*
   %qq = bitcast i32* %q to i8*
   tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %pp, i8* %qq, i32 4, i32 1, i1 false)
   ret void
 }
 
 declare void @llvm.memcpy.i32(i8* nocapture, i8* nocapture, i32, i32) nounwind
 
-define i32 @main() {
+define i32 @main() personality i32 (...)* @__gxx_personality_v0 {
   %a = alloca i32   ; <i32*> [#uses=3]
   %b = alloca i32   ; <i32*> [#uses=2]
   store i32 1, i32* %a, align 4
   store i32 0, i32* %b, align 4
   invoke void @foo(i32* %a, i32* %b)
       to label %invcont unwind label %lpad
 
 invcont:
   %retval = load i32, i32* %a, align 4
   ret i32 %retval
 
 lpad:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
             catch i8* null
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind

llvm/trunk/test/Transforms/Inline/inline-invoke-with-asm-call.ll

 ; RUN: opt < %s -inline -S | FileCheck %s
 target triple = "x86_64-apple-darwin"
 
 ; In inliner, we assume that inline asm does not throw. This testing case makes
 ; sure that the inliner does not convert "call asm" to "invoke asm".
 ; rdar://15317907
 ; CHECK-LABEL: @caller
 ; Make sure we are generating "call asm" instead of "invoke asm".
 ; CHECK: call void asm
 ; CHECK-LABEL: @callee_with_asm
-define void @caller() {
+define void @caller() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
   br i1 undef, label %1, label %4
 
 ; <label>:1
   invoke void @callee_with_asm()
           to label %4 unwind label %2
 
 ; <label>:2
-  %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %3 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 
 ; <label>:4
   ret void
 }
 
 define void @callee_with_asm() {
   call void asm sideeffect "mov\09r7, r7\09\09@ marker for objc_retainAutoreleaseReturnValue", ""()
   ret void
 }
 
 declare i32 @__objc_personality_v0(...)

llvm/trunk/test/Transforms/Inline/inline_invoke.ll

 declare i32 @__gxx_personality_v0(...)
 
 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @__cxa_end_catch()
 
 declare void @_ZSt9terminatev()
 
-define internal void @test0_in() alwaysinline uwtable ssp {
+define internal void @test0_in() alwaysinline uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %a = alloca %struct.A, align 1
   %b = alloca %struct.A, align 1
   call void @_ZN1AC1Ev(%struct.A* %a)
   invoke void @_ZN1AC1Ev(%struct.A* %b)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   invoke void @_ZN1AD1Ev(%struct.A* %b)
           to label %invoke.cont1 unwind label %lpad
 
 invoke.cont1:
   call void @_ZN1AD1Ev(%struct.A* %a)
   ret void
 
 lpad:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   invoke void @_ZN1AD1Ev(%struct.A* %a)
           to label %invoke.cont2 unwind label %terminate.lpad
 
 invoke.cont2:
   resume { i8*, i32 } %exn
 
 terminate.lpad:
-  %exn1 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn1 = landingpad {i8*, i32}
             catch i8* null
   call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 }
 
-define void @test0_out() uwtable ssp {
+define void @test0_out() uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @test0_in()
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             catch i8* bitcast (i8** @_ZTIi to i8*)
   %eh.exc = extractvalue { i8*, i32 } %exn, 0
   %eh.selector = extractvalue { i8*, i32 } %exn, 1
   %0 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) nounwind
   %1 = icmp eq i32 %eh.selector, %0
   br i1 %1, label %catch, label %eh.resume
 
 catch:
   %ignored = call i8* @__cxa_begin_catch(i8* %eh.exc) nounwind
   call void @__cxa_end_catch() nounwind
   br label %ret
 
 eh.resume:
   resume { i8*, i32 } %exn
 }
 
 ; CHECK:    define void @test0_out()
 ; CHECK:      [[A:%.*]] = alloca %struct.A,
 ; CHECK:      [[B:%.*]] = alloca %struct.A,
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[A]])
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[B]])
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[B]])
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[A]])
-; CHECK:      landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK:      landingpad { i8*, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(%struct.A* [[A]])
 ; CHECK-NEXT:   to label %[[LBL:[^\s]+]] unwind
 ; CHECK: [[LBL]]:
 ; CHECK-NEXT: br label %[[LPAD:[^\s]+]]
 ; CHECK:      ret void
-; CHECK:      landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK:      landingpad { i8*, i32 }
 ; CHECK-NEXT:    catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: br label %[[LPAD]]
 ; CHECK: [[LPAD]]:
 ; CHECK-NEXT: phi { i8*, i32 } [
 ; CHECK-NEXT: extractvalue { i8*, i32 }
 ; CHECK-NEXT: extractvalue { i8*, i32 }
 ; CHECK-NEXT: call i32 @llvm.eh.typeid.for(
 
 
 ;; Test 1 - Correctly handle phis in outer landing pads.
 
-define void @test1_out() uwtable ssp {
+define void @test1_out() uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @test0_in()
           to label %cont unwind label %lpad
 
 cont:
   invoke void @test0_in()
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad:
   %x = phi i32 [ 0, %entry ], [ 1, %cont ]
   %y = phi i32 [ 1, %entry ], [ 4, %cont ]
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             catch i8* bitcast (i8** @_ZTIi to i8*)
   %eh.exc = extractvalue { i8*, i32 } %exn, 0
   %eh.selector = extractvalue { i8*, i32 } %exn, 1
   %0 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) nounwind
   %1 = icmp eq i32 %eh.selector, %0
   br i1 %1, label %catch, label %eh.resume
 
 catch:

 ; CHECK-NEXT:   unwind label %[[LPAD1:[^\s]+]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[B1]])
 ; CHECK-NEXT:   unwind label %[[LPAD1]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[A1]])
 ; CHECK-NEXT:   unwind label %[[LPAD]]
 
 ; Inner landing pad from first inlining.
 ; CHECK:    [[LPAD1]]:
-; CHECK-NEXT: [[LPADVAL1:%.*]] = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK-NEXT: [[LPADVAL1:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(%struct.A* [[A1]])
 ; CHECK-NEXT:   to label %[[RESUME1:[^\s]+]] unwind
 ; CHECK: [[RESUME1]]:
 ; CHECK-NEXT: br label %[[LPAD_JOIN1:[^\s]+]]
 
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[A2]])
 ; CHECK-NEXT:   unwind label %[[LPAD]]
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[B2]])
 ; CHECK-NEXT:   unwind label %[[LPAD2:[^\s]+]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[B2]])
 ; CHECK-NEXT:   unwind label %[[LPAD2]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[A2]])
 ; CHECK-NEXT:   unwind label %[[LPAD]]
 
 ; Inner landing pad from second inlining.
 ; CHECK:    [[LPAD2]]:
-; CHECK-NEXT: [[LPADVAL2:%.*]] = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK-NEXT: [[LPADVAL2:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:   cleanup
 ; CHECK-NEXT:   catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(%struct.A* [[A2]])
 ; CHECK-NEXT:   to label %[[RESUME2:[^\s]+]] unwind
 ; CHECK: [[RESUME2]]:
 ; CHECK-NEXT: br label %[[LPAD_JOIN2:[^\s]+]]
 
 ; CHECK:      ret void
 
 ; CHECK:    [[LPAD]]:
 ; CHECK-NEXT: [[X:%.*]] = phi i32 [ 0, %entry ], [ 0, {{%.*}} ], [ 1, %cont ], [ 1, {{%.*}} ]
 ; CHECK-NEXT: [[Y:%.*]] = phi i32 [ 1, %entry ], [ 1, {{%.*}} ], [ 4, %cont ], [ 4, {{%.*}} ]
-; CHECK-NEXT: [[LPADVAL:%.*]] = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK-NEXT: [[LPADVAL:%.*]] = landingpad { i8*, i32 }
 ; CHECK-NEXT:   catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: br label %[[LPAD_JOIN2]]
 
 ; CHECK: [[LPAD_JOIN2]]:
 ; CHECK-NEXT: [[XJ2:%.*]] = phi i32 [ [[X]], %[[LPAD]] ], [ 1, %[[RESUME2]] ]
 ; CHECK-NEXT: [[YJ2:%.*]] = phi i32 [ [[Y]], %[[LPAD]] ], [ 4, %[[RESUME2]] ]
 ; CHECK-NEXT: [[EXNJ2:%.*]] = phi { i8*, i32 } [ [[LPADVAL]], %[[LPAD]] ], [ [[LPADVAL2]], %[[RESUME2]] ]
 ; CHECK-NEXT: br label %[[LPAD_JOIN1]]

 
 ; CHECK:      call void @use(i32 [[XJ1]])
 ; CHECK:      call void @use(i32 [[YJ1]])
 
 ; CHECK:      resume { i8*, i32 }
 
 
 ;; Test 2 - Don't make invalid IR for inlines into landing pads without eh.exception calls
-define void @test2_out() uwtable ssp {
+define void @test2_out() uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @test0_in()
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   call void @_ZSt9terminatev()
   unreachable
 }
 
 ; CHECK: define void @test2_out()
 ; CHECK:      [[A:%.*]] = alloca %struct.A,
 ; CHECK:      [[B:%.*]] = alloca %struct.A,
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[A]])
 ; CHECK-NEXT:   unwind label %[[LPAD:[^\s]+]]
 ; CHECK:      invoke void @_ZN1AC1Ev(%struct.A* [[B]])
 ; CHECK-NEXT:   unwind label %[[LPAD2:[^\s]+]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[B]])
 ; CHECK-NEXT:   unwind label %[[LPAD2]]
 ; CHECK:      invoke void @_ZN1AD1Ev(%struct.A* [[A]])
 ; CHECK-NEXT:   unwind label %[[LPAD]]
 
 
 ;; Test 3 - Deal correctly with split unwind edges.
-define void @test3_out() uwtable ssp {
+define void @test3_out() uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @test0_in()
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             catch i8* bitcast (i8** @_ZTIi to i8*)
   br label %lpad.cont
 
 lpad.cont:
   call void @_ZSt9terminatev()
   unreachable
 }
 
 ; CHECK: define void @test3_out()
-; CHECK:      landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK:      landingpad { i8*, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(
 ; CHECK-NEXT:   to label %[[L:[^\s]+]] unwind
 ; CHECK:    [[L]]:
 ; CHECK-NEXT: br label %[[JOIN:[^\s]+]]
 ; CHECK:    [[JOIN]]:
 ; CHECK-NEXT: phi { i8*, i32 }
 ; CHECK-NEXT: br label %lpad.cont
 ; CHECK:    lpad.cont:
 ; CHECK-NEXT: call void @_ZSt9terminatev()
 
 
 ;; Test 4 - Split unwind edges with a dominance problem
-define void @test4_out() uwtable ssp {
+define void @test4_out() uwtable ssp personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @test0_in()
           to label %cont unwind label %lpad.crit
 
 cont:
   invoke void @opaque()
           to label %ret unwind label %lpad
 
 ret:
   ret void
 
 lpad.crit:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             catch i8* bitcast (i8** @_ZTIi to i8*)
   call void @opaque() nounwind
   br label %terminate
 
 lpad:
-  %exn2 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn2 = landingpad {i8*, i32}
             catch i8* bitcast (i8** @_ZTIi to i8*)
   br label %terminate
 
 terminate:
   %phi = phi i32 [ 0, %lpad.crit ], [ 1, %lpad ]
   call void @use(i32 %phi)
   call void @_ZSt9terminatev()
   unreachable
 }
 
 ; CHECK: define void @test4_out()
-; CHECK:      landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK:      landingpad { i8*, i32 }
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: invoke void @_ZN1AD1Ev(
 ; CHECK-NEXT:   to label %[[L:[^\s]+]] unwind
 ; CHECK:    [[L]]:
 ; CHECK-NEXT: br label %[[JOIN:[^\s]+]]
 ; CHECK:      invoke void @opaque()
 ; CHECK-NEXT:                  unwind label %lpad
 ; CHECK:    lpad.crit:
-; CHECK-NEXT: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK-NEXT: landingpad { i8*, i32 }
 ; CHECK-NEXT:   catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: br label %[[JOIN]]
 ; CHECK:    [[JOIN]]:
 ; CHECK-NEXT: phi { i8*, i32 }
 ; CHECK-NEXT: call void @opaque() [[NUW:#[0-9]+]]
 ; CHECK-NEXT: br label %[[FIX:[^\s]+]]
 ; CHECK:    lpad:
-; CHECK-NEXT: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK-NEXT: landingpad { i8*, i32 }
 ; CHECK-NEXT:   catch i8* bitcast (i8** @_ZTIi to i8*)
 ; CHECK-NEXT: br label %[[FIX]]
 ; CHECK:    [[FIX]]:
 ; CHECK-NEXT: [[T1:%.*]] = phi i32 [ 0, %[[JOIN]] ], [ 1, %lpad ]
 ; CHECK-NEXT: call void @use(i32 [[T1]])
 ; CHECK-NEXT: call void @_ZSt9terminatev()
 
 ; CHECK: attributes [[NUW]] = { nounwind }
 ; CHECK: attributes #1 = { nounwind readnone }
 ; CHECK: attributes #2 = { ssp uwtable }
 ; CHECK: attributes #3 = { noreturn nounwind }

llvm/trunk/test/Transforms/Inline/inline_returns_twice.ll

 entry:
 ; CHECK-LABEL: define i32 @outer2(
 ; CHECK: call i32 @a()
   %call = call i32 @inner2() returns_twice
   %add = add nsw i32 1, %call
   ret i32 %add
 }
 
-define i32 @inner3() {
+define i32 @inner3() personality i8* null {
 entry:
   %invoke = invoke i32 @a() returns_twice
       to label %cont unwind label %lpad
 
 cont:
   %add = add nsw i32 1, %invoke
   ret i32 %add
 
 lpad:
-  %lp = landingpad i32 personality i8* null cleanup
+  %lp = landingpad i32 cleanup
   resume i32 %lp
 }
 
 define i32 @outer3() {
 entry:
 ; CHECK-LABEL: define i32 @outer3(
 ; CHECK: call i32 @inner3()
   %call = call i32 @inner3()
   %add = add nsw i32 1, %call
   ret i32 %add
 }
 
-define i32 @inner4() returns_twice {
+define i32 @inner4() returns_twice personality i8* null {
 entry:
   %invoke = invoke i32 @a() returns_twice
       to label %cont unwind label %lpad
 
 cont:
   %add = add nsw i32 1, %invoke
   ret i32 %add
 
 lpad:
-  %lp = landingpad i32 personality i8* null cleanup
+  %lp = landingpad i32 cleanup
   resume i32 %lp
 }
 
 define i32 @outer4() {
 entry:
 ; CHECK-LABEL: define i32 @outer4(
 ; CHECK: invoke i32 @a()
   %call = call i32 @inner4() returns_twice
   %add = add nsw i32 1, %call
   ret i32 %add
 }

llvm/trunk/test/Transforms/Inline/invoke-cleanup.ll

 ; RUN: opt %s -inline -S | FileCheck %s
 
 declare void @external_func()
 
 @exception_type1 = external global i8
 @exception_type2 = external global i8
 
 
-define internal void @inner() {
+define internal void @inner() personality i8* null {
   invoke void @external_func()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_type1
   resume i32 %lp
 }
 
 ; Test that the "cleanup" clause is kept when inlining @inner() into
 ; this call site (PR17872), otherwise C++ destructors will not be
 ; called when they should be.
 
-define void @outer() {
+define void @outer() personality i8* null {
   invoke void @inner()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       cleanup
       catch i8* @exception_type2
   resume i32 %lp
 }
 ; CHECK: define void @outer
 ; CHECK: landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: catch i8* @exception_type1
 ; CHECK-NEXT: catch i8* @exception_type2

llvm/trunk/test/Transforms/Inline/invoke-combine-clauses.ll

 ; RUN: opt %s -inline -S | FileCheck %s
 
 declare void @external_func()
 declare void @abort()
 
 @exception_inner = external global i8
 @exception_outer = external global i8
 @condition = external global i1
 
 
 ; Check for a bug in which multiple "resume" instructions in the
 ; inlined function caused "catch i8* @exception_outer" to appear
 ; multiple times in the resulting landingpad.
 
-define internal void @inner_multiple_resume() {
+define internal void @inner_multiple_resume() personality i8* null {
   invoke void @external_func()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_inner
   %cond = load i1, i1* @condition
   br i1 %cond, label %resume1, label %resume2
 resume1:
   resume i32 1
 resume2:
   resume i32 2
 }
 
-define void @outer_multiple_resume() {
+define void @outer_multiple_resume() personality i8* null {
   invoke void @inner_multiple_resume()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_outer
   resume i32 %lp
 }
 ; CHECK: define void @outer_multiple_resume()
 ; CHECK: %lp.i = landingpad
 ; CHECK-NEXT: catch i8* @exception_inner
 ; CHECK-NEXT: catch i8* @exception_outer
 ; Check that there isn't another "catch" clause:
 ; CHECK-NEXT: load
 
 
 ; Check for a bug in which having a "resume" and a "call" in the
 ; inlined function caused "catch i8* @exception_outer" to appear
 ; multiple times in the resulting landingpad.
 
-define internal void @inner_resume_and_call() {
+define internal void @inner_resume_and_call() personality i8* null {
   call void @external_func()
   invoke void @external_func()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_inner
   resume i32 %lp
 }
 
-define void @outer_resume_and_call() {
+define void @outer_resume_and_call() personality i8* null {
   invoke void @inner_resume_and_call()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_outer
   resume i32 %lp
 }
 ; CHECK: define void @outer_resume_and_call()
 ; CHECK: %lp.i = landingpad
 ; CHECK-NEXT: catch i8* @exception_inner
 ; CHECK-NEXT: catch i8* @exception_outer
 ; Check that there isn't another "catch" clause:
 ; CHECK-NEXT: br
 
 
 ; Check what happens if the inlined function contains an "invoke" but
 ; no "resume".  In this case, the inlined landingpad does not need to
 ; include the "catch i8* @exception_outer" clause from the outer
 ; function (since the outer function's landingpad will not be
 ; reachable), but it's OK to include this clause.
 
-define internal void @inner_no_resume_or_call() {
+define internal void @inner_no_resume_or_call() personality i8* null {
   invoke void @external_func()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_inner
   ; A landingpad might have no "resume" if a C++ destructor aborts.
   call void @abort() noreturn nounwind
   unreachable
 }
 
-define void @outer_no_resume_or_call() {
+define void @outer_no_resume_or_call() personality i8* null {
   invoke void @inner_no_resume_or_call()
       to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %lp = landingpad i32 personality i8* null
+  %lp = landingpad i32
       catch i8* @exception_outer
   resume i32 %lp
 }
 ; CHECK: define void @outer_no_resume_or_call()
 ; CHECK: %lp.i = landingpad
 ; CHECK-NEXT: catch i8* @exception_inner
 ; CHECK-NEXT: catch i8* @exception_outer
 ; Check that there isn't another "catch" clause:
 ; CHECK-NEXT: call void @abort()

llvm/trunk/test/Transforms/Inline/invoke-cost.ll

 ; RUN: opt -inline < %s -S -o - -inline-threshold=100 | FileCheck %s
 
 target datalayout = "p:32:32"
 
 @glbl = external global i32
 
 declare void @f()
 declare i32 @__gxx_personality_v0(...)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare void @_ZSt9terminatev()
 
-define void @inner1() {
+define void @inner1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   invoke void @f() to label %cont1 unwind label %terminate.lpad
 
 cont1:
   invoke void @f() to label %cont2 unwind label %terminate.lpad
 
 cont2:
   invoke void @f() to label %cont3 unwind label %terminate.lpad
 
 cont3:
   invoke void @f() to label %cont4 unwind label %terminate.lpad
 
 cont4:
   ret void
 
 terminate.lpad:
-  landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  landingpad {i8*, i32}
             catch i8* null
   call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 }
 
 define void @outer1() {
 ; CHECK-LABEL: @outer1(
 ;
 ; This call should not get inlined because inner1 actually calls a function
 ; many times, but it only does so through invoke as opposed to call.
 ;
 ; CHECK: call void @inner1
   call void @inner1()
   ret void
 }

llvm/trunk/test/Transforms/Inline/invoke_test-1.ll

 ; Test that we can inline a simple function, turning the calls in it into invoke
 ; instructions
 
 ; RUN: opt < %s -inline -S | \
 ; RUN:   not grep "call[^e]"
 
 declare void @might_throw()
 
 define internal void @callee() {
         call void @might_throw( )
         ret void
 }
 
 ; caller returns true if might_throw throws an exception...
-define i32 @caller() {
+define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
         invoke void @callee( )
                         to label %cont unwind label %exc
 
 cont:           ; preds = %0
         ret i32 0
 
 exc:            ; preds = %0
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Inline/invoke_test-2.ll

 ; Test that if an invoked function is inlined, and if that function cannot
 ; throw, that the dead handler is now unreachable.
 
 ; RUN: opt < %s -inline -simplifycfg -S | \
 ; RUN:   not grep UnreachableExceptionHandler
 
 declare void @might_throw()
 
-define internal i32 @callee() {
+define internal i32 @callee() personality i32 (...)* @__gxx_personality_v0 {
         invoke void @might_throw( )
                         to label %cont unwind label %exc
 
 cont:           ; preds = %0
         ret i32 0
 
 exc:            ; preds = %0
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 1
 }
 
 ; caller returns true if might_throw throws an exception... callee cannot throw.
-define i32 @caller() {
+define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
         %X = invoke i32 @callee( )
                         to label %cont unwind label %UnreachableExceptionHandler                ; <i32> [#uses=1]
 
 cont:           ; preds = %0
         ret i32 %X
 
 UnreachableExceptionHandler:            ; preds = %0
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 -1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Inline/invoke_test-3.ll

 ; Test that any rethrown exceptions in an inlined function are automatically
 ; turned into branches to the invoke destination.
 
 ; RUN: opt < %s -inline -S | not grep unwind$
 
 declare void @might_throw()
 
-define internal i32 @callee() {
+define internal i32 @callee() personality i32 (...)* @__gxx_personality_v0 {
         invoke void @might_throw( )
                         to label %cont unwind label %exc
 
 cont:           ; preds = %0
         ret i32 0
 
 exc:            ; preds = %0a
        ; This just rethrows the exception!
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         resume { i8*, i32 } %exn
 }
 
 ; caller returns true if might_throw throws an exception... which gets
 ; propagated by callee.
-define i32 @caller() {
+define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
         %X = invoke i32 @callee( )
                         to label %cont unwind label %Handler            ; <i32> [#uses=1]
 
 cont:           ; preds = %0
         ret i32 %X
 
 Handler:                ; preds = %0
 ; This consumes an exception thrown by might_throw
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll

 ; RUN: opt < %s -instcombine -disable-output
 
 declare i32* @bar()
 
-define float* @foo() {
+define float* @foo() personality i32 (...)* @__gxx_personality_v0 {
         %tmp.11 = invoke float* bitcast (i32* ()* @bar to float* ()*)( )
                         to label %invoke_cont unwind label %X           ; <float*> [#uses=1]
 
 invoke_cont:            ; preds = %0
         ret float* %tmp.11
 
 X:              ; preds = %0
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret float* null
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll

 ; Test for a problem afflicting several C++ programs in the testsuite.  The 
 ; instcombine pass is trying to get rid of the cast in the invoke instruction, 
 ; inserting a cast of the return value after the PHI instruction, but which is
 ; used by the PHI instruction.  This is bad: because of the semantics of the
 ; invoke instruction, we really cannot perform this transformation at all at
 ; least without splitting the critical edge.
 ;
 ; RUN: opt < %s -instcombine -disable-output
 
 declare i8* @test()
 
-define i32 @foo() {
+define i32 @foo() personality i32 (...)* @__gxx_personality_v0 {
 entry:
         br i1 true, label %cont, label %call
 
 call:           ; preds = %entry
         %P = invoke i32* bitcast (i8* ()* @test to i32* ()*)( )
                         to label %cont unwind label %N          ; <i32*> [#uses=1]
 
 cont:           ; preds = %call, %entry
         %P2 = phi i32* [ %P, %call ], [ null, %entry ]          ; <i32*> [#uses=1]
         %V = load i32, i32* %P2              ; <i32> [#uses=1]
         ret i32 %V
 
 N:              ; preds = %call
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
         ret i32 0
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/InstCombine/2008-05-09-SinkOfInvoke.ll

 ; RUN: opt < %s -instcombine -disable-output
 ; PR2303
   %"struct.std::ctype<char>" = type { %"struct.std::locale::facet", i32*, i8, i32*, i32*, i16*, i8, [256 x i8], [256 x i8], i8 }
   %"struct.std::locale::facet" = type { i32 (...)**, i32 }
 
 declare i32* @_ZNSt6locale5facet15_S_get_c_localeEv()
 
 declare i32** @__ctype_toupper_loc() readnone 
 
 declare i32** @__ctype_tolower_loc() readnone 
 
-define void @_ZNSt5ctypeIcEC2EPiPKtbm(%"struct.std::ctype<char>"* %this, i32* %unnamed_arg, i16* %__table, i8 zeroext  %__del, i64 %__refs) {
+define void @_ZNSt5ctypeIcEC2EPiPKtbm(%"struct.std::ctype<char>"* %this, i32* %unnamed_arg, i16* %__table, i8 zeroext  %__del, i64 %__refs) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %tmp8 = invoke i32* @_ZNSt6locale5facet15_S_get_c_localeEv( )
       to label %invcont unwind label %lpad    ; <i32*> [#uses=0]
 
 invcont:    ; preds = %entry
   %tmp32 = invoke i32** @__ctype_toupper_loc( ) readnone 
       to label %invcont31 unwind label %lpad    ; <i32**> [#uses=0]
 
 invcont31:    ; preds = %invcont
   %tmp38 = invoke i32** @__ctype_tolower_loc( ) readnone 
       to label %invcont37 unwind label %lpad    ; <i32**> [#uses=1]
 
 invcont37:    ; preds = %invcont31
   %tmp39 = load i32*, i32** %tmp38, align 8    ; <i32*> [#uses=1]
   %tmp41 = getelementptr %"struct.std::ctype<char>", %"struct.std::ctype<char>"* %this, i32 0, i32 4    ; <i32**> [#uses=1]
   store i32* %tmp39, i32** %tmp41, align 8
   ret void
 
 lpad:   ; preds = %invcont31, %invcont, %entry
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/InstCombine/AddOverFlow.ll

; CHECK-NEXT: ret
   ret i16 %3
 }
 
 declare i16 @bounded(i16 %input);
 declare i32 @__gxx_personality_v0(...);
 !0 = !{i16 0, i16 32768} ; [0, 32767]
 !1 = !{i16 0, i16 32769} ; [0, 32768]
 
-define i16 @add_bounded_values(i16 %a, i16 %b) {
+define i16 @add_bounded_values(i16 %a, i16 %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @add_bounded_values(
 entry:
   %c = call i16 @bounded(i16 %a), !range !0
   %d = invoke i16 @bounded(i16 %b) to label %cont unwind label %lpad, !range !0
 cont:
 ; %c and %d are in [0, 32767]. Therefore, %c + %d doesn't unsigned overflow.
   %e = add i16 %c, %d
 ; CHECK: add nuw i16 %c, %d
   ret i16 %e
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret i16 42
 }
 
-define i16 @add_bounded_values_2(i16 %a, i16 %b) {
+define i16 @add_bounded_values_2(i16 %a, i16 %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @add_bounded_values_2(
 entry:
   %c = call i16 @bounded(i16 %a), !range !1
   %d = invoke i16 @bounded(i16 %b) to label %cont unwind label %lpad, !range !1
 cont:
 ; Similar to add_bounded_values, but %c and %d are in [0, 32768]. Therefore,
 ; %c + %d may unsigned overflow and we cannot add NUW.
   %e = add i16 %c, %d
 ; CHECK: add i16 %c, %d
   ret i16 %e
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret i16 42
 }
 
 ; CHECK-LABEL: @ripple_nsw1
 ; CHECK: add nsw i16 %a, %b
 define i16 @ripple_nsw1(i16 %x, i16 %y) {
 ; %a has at most one bit set

llvm/trunk/test/Transforms/InstCombine/LandingPadClauses.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 @T1 = external constant i32
 @T2 = external constant i32
 @T3 = external constant i32
 
 declare i32 @generic_personality(i32, i64, i8*, i8*)
 declare i32 @__gxx_personality_v0(i32, i64, i8*, i8*)
 declare i32 @__objc_personality_v0(i32, i64, i8*, i8*)
 declare i32 @__C_specific_handler(...)
 
 declare void @bar()
 
-define void @foo_generic() {
+define void @foo_generic() personality i32 (i32, i64, i8*, i8*)* @generic_personality {
 ; CHECK-LABEL: @foo_generic(
   invoke void @bar()
     to label %cont.a unwind label %lpad.a
 cont.a:
   invoke void @bar()
     to label %cont.b unwind label %lpad.b
 cont.b:
   invoke void @bar()
invoke void @bar()
     to label %cont.h unwind label %lpad.h
 cont.h:
   invoke void @bar()
     to label %cont.i unwind label %lpad.i
 cont.i:
   ret void
 
 lpad.a:
-  %a = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %a = landingpad { i8*, i32 }
           catch i32* @T1
           catch i32* @T2
           catch i32* @T1
           catch i32* @T2
   unreachable
 ; CHECK: %a = landingpad
 ; CHECK-NEXT: @T1
 ; CHECK-NEXT: @T2
 ; CHECK-NEXT: unreachable
 
 lpad.b:
-  %b = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %b = landingpad { i8*, i32 }
           filter [0 x i32*] zeroinitializer
           catch i32* @T1
   unreachable
 ; CHECK: %b = landingpad
 ; CHECK-NEXT: filter
 ; CHECK-NEXT: unreachable
 
 lpad.c:
-  %c = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %c = landingpad { i8*, i32 }
           catch i32* @T1
           filter [1 x i32*] [i32* @T1]
           catch i32* @T2
   unreachable
 ; CHECK: %c = landingpad
 ; CHECK-NEXT: @T1
 ; CHECK-NEXT: filter [0 x i32*]
 ; CHECK-NEXT: unreachable
 
 lpad.d:
-  %d = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %d = landingpad { i8*, i32 }
           filter [3 x i32*] zeroinitializer
   unreachable
 ; CHECK: %d = landingpad
 ; CHECK-NEXT: filter [1 x i32*] zeroinitializer
 ; CHECK-NEXT: unreachable
 
 lpad.e:
-  %e = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %e = landingpad { i8*, i32 }
           catch i32* @T1
           filter [3 x i32*] [i32* @T1, i32* @T2, i32* @T2]
   unreachable
 ; CHECK: %e = landingpad
 ; CHECK-NEXT: @T1
 ; CHECK-NEXT: filter [1 x i32*] [i32* @T2]
 ; CHECK-NEXT: unreachable
 
 lpad.f:
-  %f = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %f = landingpad { i8*, i32 }
           filter [2 x i32*] [i32* @T2, i32* @T1]
           filter [1 x i32*] [i32* @T1]
   unreachable
 ; CHECK: %f = landingpad
 ; CHECK-NEXT: filter [1 x i32*] [i32* @T1]
 ; CHECK-NEXT: unreachable
 
 lpad.g:
-  %g = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %g = landingpad { i8*, i32 }
           filter [1 x i32*] [i32* @T1]
           catch i32* @T3
           filter [2 x i32*] [i32* @T2, i32* @T1]
   unreachable
 ; CHECK: %g = landingpad
 ; CHECK-NEXT: filter [1 x i32*] [i32* @T1]
 ; CHECK-NEXT: catch i32* @T3
 ; CHECK-NEXT: unreachable
 
 lpad.h:
-  %h = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %h = landingpad { i8*, i32 }
           filter [2 x i32*] [i32* @T1, i32* null]
           filter [1 x i32*] zeroinitializer
   unreachable
 ; CHECK: %h = landingpad
 ; CHECK-NEXT: filter [1 x i32*] zeroinitializer
 ; CHECK-NEXT: unreachable
 
 lpad.i:
-  %i = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @generic_personality
+  %i = landingpad { i8*, i32 }
           cleanup
           filter [0 x i32*] zeroinitializer
   unreachable
 ; CHECK: %i = landingpad
 ; CHECK-NEXT: filter
 ; CHECK-NEXT: unreachable
 }
 
-define void @foo_cxx() {
+define void @foo_cxx() personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @foo_cxx(
   invoke void @bar()
     to label %cont.a unwind label %lpad.a
 cont.a:
   invoke void @bar()
     to label %cont.b unwind label %lpad.b
 cont.b:
   invoke void @bar()
     to label %cont.c unwind label %lpad.c
 cont.c:
   invoke void @bar()
     to label %cont.d unwind label %lpad.d
 cont.d:
   ret void
 
 lpad.a:
-  %a = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %a = landingpad { i8*, i32 }
           catch i32* null
           catch i32* @T1
   unreachable
 ; CHECK: %a = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 
 lpad.b:
-  %b = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %b = landingpad { i8*, i32 }
           filter [1 x i32*] zeroinitializer
   unreachable
 ; CHECK: %b = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.c:
-  %c = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %c = landingpad { i8*, i32 }
           filter [2 x i32*] [i32* @T1, i32* null]
   unreachable
 ; CHECK: %c = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.d:
-  %d = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %d = landingpad { i8*, i32 }
           cleanup
           catch i32* null
   unreachable
 ; CHECK: %d = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 }
 
-define void @foo_objc() {
+define void @foo_objc() personality i32 (i32, i64, i8*, i8*)* @__objc_personality_v0 {
 ; CHECK-LABEL: @foo_objc(
   invoke void @bar()
     to label %cont.a unwind label %lpad.a
 cont.a:
   invoke void @bar()
     to label %cont.b unwind label %lpad.b
 cont.b:
   invoke void @bar()
     to label %cont.c unwind label %lpad.c
 cont.c:
   invoke void @bar()
     to label %cont.d unwind label %lpad.d
 cont.d:
   ret void
 
 lpad.a:
-  %a = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__objc_personality_v0
+  %a = landingpad { i8*, i32 }
           catch i32* null
           catch i32* @T1
   unreachable
 ; CHECK: %a = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 
 lpad.b:
-  %b = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__objc_personality_v0
+  %b = landingpad { i8*, i32 }
           filter [1 x i32*] zeroinitializer
   unreachable
 ; CHECK: %b = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.c:
-  %c = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__objc_personality_v0
+  %c = landingpad { i8*, i32 }
           filter [2 x i32*] [i32* @T1, i32* null]
   unreachable
 ; CHECK: %c = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.d:
-  %d = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__objc_personality_v0
+  %d = landingpad { i8*, i32 }
           cleanup
           catch i32* null
   unreachable
 ; CHECK: %d = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 }
 
-define void @foo_seh() {
+define void @foo_seh() personality i32 (...)* @__C_specific_handler {
 ; CHECK-LABEL: @foo_seh(
   invoke void @bar()
     to label %cont.a unwind label %lpad.a
 cont.a:
   invoke void @bar()
     to label %cont.b unwind label %lpad.b
 cont.b:
   invoke void @bar()
     to label %cont.c unwind label %lpad.c
 cont.c:
   invoke void @bar()
     to label %cont.d unwind label %lpad.d
 cont.d:
   ret void
 
 lpad.a:
-  %a = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %a = landingpad { i8*, i32 }
           catch i32* null
           catch i32* @T1
   unreachable
 ; CHECK: %a = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 
 lpad.b:
-  %b = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %b = landingpad { i8*, i32 }
           filter [1 x i32*] zeroinitializer
   unreachable
 ; CHECK: %b = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.c:
-  %c = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %c = landingpad { i8*, i32 }
           filter [2 x i32*] [i32* @T1, i32* null]
   unreachable
 ; CHECK: %c = landingpad
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: unreachable
 
 lpad.d:
-  %d = landingpad { i8*, i32 } personality i32 (...)* @__C_specific_handler
+  %d = landingpad { i8*, i32 }
           cleanup
           catch i32* null
   unreachable
 ; CHECK: %d = landingpad
 ; CHECK-NEXT: null
 ; CHECK-NEXT: unreachable
 }

llvm/trunk/test/Transforms/InstCombine/call.ll

; CHECK: ret void
   call void bitcast (void ()* @test7a to void (i32)*)( i32 5 )
   ret void
 }
 
 
 ; rdar://7590304
 declare void @test8a()
 
-define i8* @test8() {
+define i8* @test8() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT: invoke void @test8a()
 ; Don't turn this into "unreachable": the callee and caller don't agree in
 ; calling conv, but the implementation of test8a may actually end up using the
 ; right calling conv.
   invoke void @test8a()
           to label %invoke.cont unwind label %try.handler
 
 invoke.cont:                                      ; preds = %entry
   unreachable
 
 try.handler:                                      ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
             cleanup
   ret i8* null
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 
 ; Don't turn this into a direct call, because test9x is just a prototype and

llvm/trunk/test/Transforms/InstCombine/cast.ll

define void @test11(i32* %P) {
         %c = bitcast i32* %P to i16*            ; <i16*> [#uses=1]
         call void (i32, ...) @varargs( i32 5, i16* %c )
         ret void
 ; CHECK: call void (i32, ...) @varargs(i32 5, i32* %P)
 ; CHECK: ret void
 }
 
 declare i32 @__gxx_personality_v0(...)
-define void @test_invoke_vararg_cast(i32* %a, i32* %b) {
+define void @test_invoke_vararg_cast(i32* %a, i32* %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %0 = bitcast i32* %b to i8*
   %1 = bitcast i32* %a to i64*
   invoke void (i32, ...) @varargs(i32 1, i8* %0, i64* %1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   ret void
 
 lpad:                                             ; preds = %entry
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           cleanup
   ret void
 ; CHECK-LABEL: test_invoke_vararg_cast
 ; CHECK-LABEL: entry:
 ; CHECK: invoke void (i32, ...) @varargs(i32 1, i32* %b, i32* %a)
 }
 
 define i8* @test13(i64 %A) {

llvm/trunk/test/Transforms/InstCombine/crash.ll

l10:
   ret i64 %v11
 }
 
 ; PR5471
 define i32 @test5a() {
        ret i32 0
 }
 
-define void @test5() {
+define void @test5() personality i32 (...)* @__gxx_personality_v0 {
   store i1 true, i1* undef
   %r = invoke i32 @test5a() to label %exit unwind label %unwind
 unwind:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
           cleanup
   br label %exit
 exit:
   ret void
 }
 
 
 ; PR5673
 
 @test6g = external global i32*  
 
 define arm_aapcs_vfpcc i32 @test6(i32 %argc, i8** %argv) nounwind {
 entry:
   store i32* getelementptr (i32, i32* bitcast (i32 (i32, i8**)* @test6 to i32*), i32 -2048), i32** @test6g, align 4
   unreachable
 }
 
 
 ; PR5827
 
 %class.RuleBasedBreakIterator = type { i64 ()* }
 %class.UStack = type { i8** }
 
-define i32 @_ZN22RuleBasedBreakIterator15checkDictionaryEi(%class.RuleBasedBreakIterator* %this, i32 %x) align 2 {
+define i32 @_ZN22RuleBasedBreakIterator15checkDictionaryEi(%class.RuleBasedBreakIterator* %this, i32 %x) align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %breaks = alloca %class.UStack, align 4         ; <%class.UStack*> [#uses=3]
   call void @_ZN6UStackC1Ei(%class.UStack* %breaks, i32 0)
   %tobool = icmp ne i32 %x, 0                     ; <i1> [#uses=1]
   br i1 %tobool, label %cond.end, label %cond.false
 
 terminate.handler:                                ; preds = %ehcleanup
-  %exc = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %exc = landingpad { i8*, i32 }
            cleanup
   call void @_ZSt9terminatev() noreturn nounwind
   unreachable
 
 ehcleanup:                                        ; preds = %cond.false
-  %exc1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %exc1 = landingpad { i8*, i32 }
            catch i8* null
   invoke void @_ZN6UStackD1Ev(%class.UStack* %breaks)
           to label %cont unwind label %terminate.handler
 
 cont:                                             ; preds = %ehcleanup
   resume { i8*, i32 } %exc1
 
 cond.false:                                       ; preds = %entry

 
 declare void @_ZSt9terminatev()
 
 declare void @_Unwind_Resume_or_Rethrow(i8*)
 
 
 
 ; rdar://7590304
-define i8* @test10(i8* %self, i8* %tmp3) {
+define i8* @test10(i8* %self, i8* %tmp3) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   store i1 true, i1* undef
   store i1 true, i1* undef
   invoke void @test10a()
           to label %invoke.cont unwind label %try.handler ; <i8*> [#uses=0]
 
 invoke.cont:                                      ; preds = %entry
   unreachable
 
 try.handler:                                      ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            catch i8* null
   ret i8* %self
 }
 
 define void @test10a() {
   ret void
 }
 

 return:                                           ; No predecessors!
   ret void
 }
 
 ; PR11275
 declare void @test18b() noreturn
 declare void @test18foo(double**)
 declare void @test18a() noreturn
-define fastcc void @test18x(i8* %t0, i1 %b) uwtable align 2 {
+define fastcc void @test18x(i8* %t0, i1 %b) uwtable align 2 personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br i1 %b, label %e1, label %e2
 e1:
   %t2 = bitcast i8* %t0 to double**
   invoke void @test18b() noreturn
           to label %u unwind label %lpad
 e2:
   %t4 = bitcast i8* %t0 to double**
   invoke void @test18a() noreturn
           to label %u unwind label %lpad
 lpad:
   %t5 = phi double** [ %t2, %e1 ], [ %t4, %e2 ]
-  %lpad.nonloopexit262 = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  %lpad.nonloopexit262 = landingpad { i8*, i32 }
           cleanup
   call void @test18foo(double** %t5)
   unreachable
 u:
   unreachable
 }

llvm/trunk/test/Transforms/InstCombine/gepphigep.ll

 ; CHECK-LABEL: @test2(
 ; CHECK: getelementptr inbounds %struct2, %struct2* %tmp1, i64 %tmp9, i32 0
 ; CHECK: getelementptr inbounds %struct2, %struct2* %tmp1, i64 %tmp19, i32 0
 ; CHECK: getelementptr inbounds %struct2, %struct2* %tmp1, i64 %tmp9, i32 1
 }
 
 ; Check that instcombine doesn't insert GEPs before landingpad.
 
-define i32 @test3(%struct3* %dm, i1 %tmp4, i64 %tmp9, i64 %tmp19, i64 %tmp20, i64 %tmp21) {
+define i32 @test3(%struct3* %dm, i1 %tmp4, i64 %tmp9, i64 %tmp19, i64 %tmp20, i64 %tmp21) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 bb:
   %tmp = getelementptr inbounds %struct3, %struct3* %dm, i64 0
   br i1 %tmp4, label %bb1, label %bb2
 
 bb1:
   %tmp1 = getelementptr inbounds %struct3, %struct3* %tmp, i64 %tmp19, i32 1
   %tmp11 = getelementptr inbounds %struct4, %struct4* %tmp1, i64 0, i32 0, i32 0
   store i32 0, i32* %tmp11, align 4
   br label %bb3
 
 bb2:
   %tmp2 = getelementptr inbounds %struct3, %struct3* %tmp, i64 %tmp20, i32 1
   %tmp12 = getelementptr inbounds %struct4, %struct4* %tmp2, i64 0, i32 0, i32 1
   store i32 0, i32* %tmp12, align 4
   br label %bb3
 
 bb3:
   %phi = phi %struct4* [ %tmp1, %bb1 ], [ %tmp2, %bb2 ]
   %tmp22 = invoke i32 @foo1(i32 11) to label %bb4 unwind label %bb5
 
 bb4:
   ret i32 0
 
 bb5:
-  %tmp27 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) catch i8* bitcast (i8** @_ZTIi to i8*)
+  %tmp27 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*)
   %tmp34 = getelementptr inbounds %struct4, %struct4* %phi, i64 %tmp21, i32 1
   %tmp35 = getelementptr inbounds %struct2, %struct2* %tmp34, i64 0, i32 1
   %tmp25 = load i32, i32* %tmp35, align 4
   ret i32 %tmp25
 
 ; CHECK-LABEL: @test3(
 ; CHECK: bb5:
-; CHECK-NEXT: {{.*}}landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+; CHECK-NEXT: {{.*}}landingpad { i8*, i32 }
 }
 
 @_ZTIi = external constant i8*
 declare i32 @__gxx_personality_v0(...)
 declare i32 @foo1(i32)
 
 
 ; Check that instcombine doesn't fold GEPs into themselves through a loop

llvm/trunk/test/Transforms/InstCombine/invoke.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
 declare i64 @llvm.objectsize.i64(i8*, i1) nounwind readonly
 declare i8* @_Znwm(i64)
 
 
 ; CHECK-LABEL: @f1(
-define i64 @f1() nounwind uwtable ssp {
+define i64 @f1() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: nvoke noalias i8* undef()
   %call = invoke noalias i8* undef()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 0
   %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
   ret i64 %0
 
 lpad:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f2(
-define i64 @f2() nounwind uwtable ssp {
+define i64 @f2() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: nvoke noalias i8* null()
   %call = invoke noalias i8* null()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 0
   %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
   ret i64 %0
 
 lpad:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f3(
-define void @f3() nounwind uwtable ssp {
+define void @f3() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK: invoke void @llvm.donothing()
   %call = invoke noalias i8* @_Znwm(i64 13)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret void
 
 lpad:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }

llvm/trunk/test/Transforms/InstCombine/malloc-free-delete.ll

 }
 
 declare i8* @_ZnwmRKSt9nothrow_t(i64, i8*) nobuiltin
 declare void @_ZdlPvRKSt9nothrow_t(i8*, i8*) nobuiltin
 declare i32 @__gxx_personality_v0(...)
 declare void @_ZN1AC2Ev(i8* %this)
 
 ; CHECK-LABEL: @test7(
-define void @test7() {
+define void @test7() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %nt = alloca i8
   ; CHECK-NOT: call {{.*}}@_ZnwmRKSt9nothrow_t(
   %call.i = tail call i8* @_ZnwmRKSt9nothrow_t(i64 1, i8* %nt) builtin nounwind
   invoke void @_ZN1AC2Ev(i8* undef)
           to label %.noexc.i unwind label %lpad.i
 
 .noexc.i:                                         ; preds = %entry
   unreachable
 
 lpad.i:                                           ; preds = %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) cleanup
+  %0 = landingpad { i8*, i32 } cleanup
   ; CHECK-NOT: call {{.*}}@_ZdlPvRKSt9nothrow_t(
   call void @_ZdlPvRKSt9nothrow_t(i8* %call.i, i8* %nt) builtin nounwind
   resume { i8*, i32 } %0
 }
 
 declare i8* @_Znwm(i64) nobuiltin
 declare i8* @_Znwj(i32) nobuiltin
 declare i8* @_Znam(i64) nobuiltin

llvm/trunk/test/Transforms/InstCombine/objsize-64.ll

define i64 @f1(i8 **%esc) {
   store i8* %call, i8** %esc
   %size = call i64 @llvm.objectsize.i64(i8* %call, i1 false)
 ; CHECK: ret i64 4
   ret i64 %size
 }
 
 
 ; CHECK-LABEL: @f2(
-define i64 @f2(i8** %esc) nounwind uwtable ssp {
+define i64 @f2(i8** %esc) nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: invoke noalias i8* @_Znwm(i64 13)
   %call = invoke noalias i8* @_Znwm(i64 13)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK: ret i64 13
   store i8* %call, i8** %esc
   %0 = tail call i64 @llvm.objectsize.i64(i8* %call, i1 false)
   ret i64 %0
 
 lpad:
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %2 = extractvalue { i8*, i32 } %1, 0
   tail call void @__cxa_call_unexpected(i8* %2) noreturn nounwind
   unreachable
 }

llvm/trunk/test/Transforms/InstSimplify/2011-09-05-InsertExtractValue.ll

 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare void @bar()
 
-define void @test1() {
+define void @test1() personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 entry:
   invoke void @bar() to label %cont unwind label %lpad
 cont:
   ret void
 lpad:
-  %ex = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 cleanup
+  %ex = landingpad { i8*, i32 } cleanup
   %exc_ptr = extractvalue { i8*, i32 } %ex, 0
   %filter = extractvalue { i8*, i32 } %ex, 1
   %exc_ptr2 = insertvalue { i8*, i32 } undef, i8* %exc_ptr, 0
   %filter2 = insertvalue { i8*, i32 } %exc_ptr2, i32 %filter, 1
   resume { i8*, i32 } %filter2
 ; CHECK-LABEL: @test1(
 ; CHECK-NOT: extractvalue
 ; CHECK-NOT: insertvalue

llvm/trunk/test/Transforms/JumpThreading/landing-pad.ll

 
 declare void @_ZN24CompositeEditCommandImplC2Ev() #1
 
 define void @_ZN1D7doApplyEv(%class.D* nocapture %this) unnamed_addr nounwind readnone uwtable align 2 {
 entry:
   ret void
 }
 
-define void @_Z3fn1v() uwtable {
+define void @_Z3fn1v() uwtable personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %call = call noalias i8* @_Znwm() #8
   invoke void @_ZN24CompositeEditCommandImplC2Ev()
           to label %_ZN1DC1Ev.exit unwind label %lpad
 
 _ZN1DC1Ev.exit:                                   ; preds = %entry
   %0 = bitcast i8* %call to i32 (...)***
   store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1D, i64 0, i64 2) to i32 (...)**), i32 (...)*** %0, align 8

 _ZN15EditCommandImpl5applyEv.exit:                ; preds = %_ZN1DC1Ev.exit
   invoke void @_ZN1D16deleteKeyPressedEv()
           to label %invoke.cont7 unwind label %lpad1
 
 invoke.cont7:                                     ; preds = %_ZN15EditCommandImpl5applyEv.exit
   ret void
 
 lpad:                                             ; preds = %entry
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           cleanup
   call void @_ZdlPv() #9
   unreachable
 
 lpad1:                                            ; preds = %_ZN1DC1Ev.exit, %_ZN15EditCommandImpl5applyEv.exit
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           cleanup
   %6 = load i32, i32* %1, align 4
   %tobool.i.i.i = icmp eq i32 %6, 0
   br i1 %tobool.i.i.i, label %_ZN1BI1DED1Ev.exit, label %if.then.i.i.i
 
 if.then.i.i.i:                                    ; preds = %lpad1
   br i1 undef, label %_ZN1BI1DED1Ev.exit, label %delete.notnull.i.i.i
 
 delete.notnull.i.i.i:                             ; preds = %if.then.i.i.i
   call void @_ZdlPv() #9
   unreachable
 
 _ZN1BI1DED1Ev.exit:                               ; preds = %lpad1, %if.then.i.i.i
   resume { i8*, i32 } undef
 
 terminate.lpad:                                   ; No predecessors!
-  %7 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %7 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 define void @_ZN1BI1DEC1EPS0_(%class.B* nocapture %this, %class.D* %p1) unnamed_addr uwtable align 2 {
 entry:
   %m_ptr.i = getelementptr inbounds %class.B, %class.B* %this, i64 0, i32 0
   store %class.D* %p1, %class.D** %m_ptr.i, align 8

llvm/trunk/test/Transforms/LCSSA/invoke-dest.ll

 ; RUN: opt < %s -lcssa
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
 
 @.str12 = external constant [3 x i8], align 1    ; <[3 x i8]*> [#uses=1]
 @.str17175 = external constant [4 x i8], align 1    ; <[4 x i8]*> [#uses=1]
 @.str21179 = external constant [12 x i8], align 1    ; <[12 x i8]*> [#uses=1]
 @.str25183 = external constant [10 x i8], align 1    ; <[10 x i8]*> [#uses=1]
 @.str32190 = external constant [92 x i8], align 1    ; <[92 x i8]*> [#uses=1]
 @.str41 = external constant [25 x i8], align 1    ; <[25 x i8]*> [#uses=1]
 
-define void @_ZN8EtherBus10initializeEv() {
+define void @_ZN8EtherBus10initializeEv() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   br i1 undef, label %_ZN7cObjectnwEj.exit, label %bb.i
 
 bb.i:   ; preds = %entry
   br label %_ZN7cObjectnwEj.exit
 
 _ZN7cObjectnwEj.exit:   ; preds = %bb.i, %entry
   invoke void @_ZN7cObjectC2EPKc(i8* undef, i8* getelementptr ([12 x i8], [12 x i8]* @.str21179, i32 0, i32 0))

 invcont105:   ; preds = %invcont104
   br label %bb106
 
 bb106:    ; preds = %invcont105, %bb61
   %tmp4 = invoke i8* @_Znaj(i32 124)
       to label %.noexc unwind label %lpad119    ; <i8*> [#uses=1]
 
 lpad:   ; preds = %_ZN7cObjectnwEj.exit
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  cleanup
   br label %Unwind
 
 lpad119:    ; preds = %bb106, %invcont104, %invcont103, %bb102, %bb49, %bb34, %bb12, %invcont10, %invcont9, %bb8
-        %exn119 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn119 = landingpad {i8*, i32}
                  cleanup
   unreachable
 
 lpad123:    ; preds = %.noexc
-        %exn123 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn123 = landingpad {i8*, i32}
                  cleanup
   %tmp5 = icmp eq i8* %tmp4, null    ; <i1> [#uses=1]
   br i1 %tmp5, label %Unwind, label %bb.i2
 
 bb.i2:    ; preds = %lpad123
   br label %Unwind
 
 Unwind:   ; preds = %bb.i2, %lpad123, %lpad

llvm/trunk/test/Transforms/LoopRotate/multiple-exits.ll

 
 declare i32 @foo(i32)
 
 declare i32 @bar(i32)
 
 @_ZTIi = external constant i8*
 
 ; Verify dominators.
-define void @test3(i32 %x) {
+define void @test3(i32 %x) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %cmp2 = icmp eq i32 0, %x
   br i1 %cmp2, label %try.cont.loopexit, label %for.body.lr.ph
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body
 
 for.body:                                         ; preds = %for.body.lr.ph, %for.inc
   %i.03 = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
   invoke void @_Z3fooi(i32 %i.03)
           to label %for.inc unwind label %lpad
 
 for.inc:                                          ; preds = %for.body
   %inc = add i32 %i.03, 1
   %cmp = icmp eq i32 %inc, %x
   br i1 %cmp, label %for.cond.try.cont.loopexit_crit_edge, label %for.body
 
 lpad:                                             ; preds = %for.body
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   %3 = tail call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) nounwind
   %matches = icmp eq i32 %2, %3
   br i1 %matches, label %catch, label %eh.resume
 
 catch:                                            ; preds = %lpad
invoke void @_Z3fooi(i32 %i.0.i1)
           to label %for.inc.i unwind label %lpad.i
 
 for.inc.i:                                        ; preds = %for.body.i
   %inc.i = add i32 %i.0.i1, 1
   %cmp.i = icmp eq i32 %inc.i, 0
   br i1 %cmp.i, label %for.cond.i.invoke.cont2.loopexit_crit_edge, label %for.body.i
 
 lpad.i:                                           ; preds = %for.body.i
-  %5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %5 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
   %6 = extractvalue { i8*, i32 } %5, 0
   %7 = extractvalue { i8*, i32 } %5, 1
   %matches.i = icmp eq i32 %7, %3
   br i1 %matches.i, label %catch.i, label %lpad1.body
 
 catch.i:                                          ; preds = %lpad.i
   %8 = tail call i8* @__cxa_begin_catch(i8* %6) nounwind
   invoke void @test3(i32 0)
           to label %invoke.cont2.i unwind label %lpad1.i
 
 invoke.cont2.i:                                   ; preds = %catch.i
   tail call void @__cxa_end_catch() nounwind
   br label %invoke.cont2
 
 lpad1.i:                                          ; preds = %catch.i
-  %9 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %9 = landingpad { i8*, i32 }
           cleanup
   %10 = extractvalue { i8*, i32 } %9, 0
   %11 = extractvalue { i8*, i32 } %9, 1
   tail call void @__cxa_end_catch() nounwind
   br label %lpad1.body
 
 for.cond.i.invoke.cont2.loopexit_crit_edge:       ; preds = %for.inc.i
   br label %invoke.cont2.loopexit

llvm/trunk/test/Transforms/LoopSimplify/2007-10-28-InvokeCrash.ll

 ; RUN: opt < %s -loop-simplify -disable-output
 ; PR1752
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-s0:0:64-f80:32:32"
 target triple = "i686-pc-mingw32"
 
-define void @func() {
+define void @func() personality i32 (...)* @__gxx_personality_v0 {
 bb_init:
   br label %bb_main
 
 bb_main:
         br label %invcont17.normaldest
 
 invcont17.normaldest917:    ; No predecessors!
   %tmp23 = invoke i32 @foo()
       to label %invcont17.normaldest unwind label %invcont17.normaldest.normaldest
 
 invcont17.normaldest:   ; preds = %invcont17.normaldest917, %bb_main
   br label %bb_main
 
 invcont17.normaldest.normaldest:    ; No predecessors!
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
         store i32 %tmp23, i32* undef
   br label %bb_main
 }
 
 declare i32 @foo()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/LoopSimplify/2011-12-14-LandingpadHeader.ll

 ; RUN: opt < %s -loop-simplify -S | FileCheck %s
 ; PR11575
 
 @catchtypeinfo = external unnamed_addr constant { i8*, i8*, i8* }
 
-define void @main() uwtable ssp {
+define void @main() uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @f1()
           to label %try.cont19 unwind label %catch
 
 ; CHECK: catch.preheader:
 ; CHECK-NEXT: landingpad
 ; CHECK: br label %catch
 
 ; CHECK: catch.preheader.split-lp:
 ; CHECK-NEXT: landingpad
 ; CHECK: br label %catch
 
 catch:                                            ; preds = %if.else, %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8*, i8* }* @catchtypeinfo to i8*)
   invoke void @f3()
           to label %if.else unwind label %eh.resume
 
 if.else:                                          ; preds = %catch
   invoke void @f2()
           to label %try.cont19 unwind label %catch
 
 try.cont19:                                       ; preds = %if.else, %entry
   ret void
 
 eh.resume:                                        ; preds = %catch
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
           catch i8* bitcast ({ i8*, i8*, i8* }* @catchtypeinfo to i8*)
   resume { i8*, i32 } undef
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 declare void @f1()
 
 declare void @f2()
 
 declare void @f3()

llvm/trunk/test/Transforms/LoopSimplify/dbg-loc.ll

 }
 
 ; CHECK-LABEL: @with_landingpad
 ; CHECK: catch.preheader:
 ; CHECK:   br label %catch, !dbg [[LPAD_PREHEADER_LOC:![0-9]+]]
 ; CHECK: catch.preheader.split-lp:
 ; CHECK:   br label %catch, !dbg [[LPAD_PREHEADER_LOC]]
 
-define void @with_landingpad() uwtable ssp {
+define void @with_landingpad() uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @f1() to label %try.cont19 unwind label %catch, !dbg !13
 
 catch:                                            ; preds = %if.else, %entry
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* bitcast ({ i8*, i8*, i8* }* @catchtypeinfo to i8*), !dbg !13
   invoke void @f3() to label %if.else unwind label %eh.resume, !dbg !13
 
 if.else:                                          ; preds = %catch
   invoke void @f2() to label %try.cont19 unwind label %catch, !dbg !13
 
 try.cont19:                                       ; preds = %if.else, %entry
   ret void, !dbg !13
 
 eh.resume:                                        ; preds = %catch
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup catch i8* bitcast ({ i8*, i8*, i8* }* @catchtypeinfo to i8*), !dbg !13
   resume { i8*, i32 } undef, !dbg !13
 }
 
 ; CHECK-DAG: [[PREHEADER_LOC]] = !DILocation(line: 73, column: 27, scope: !{{[0-9]+}})
 ; CHECK-DAG: [[LOOPEXIT_LOC]] = !DILocation(line: 75, column: 9, scope: !{{[0-9]+}})
 ; CHECK-DAG: [[LPAD_PREHEADER_LOC]] = !DILocation(line: 85, column: 1, scope: !{{[0-9]+}})
 

llvm/trunk/test/Transforms/LoopStrengthReduce/dominate-assert.ll

 ; RUN: opt -loop-reduce < %s
 ; we used to crash on this one
 
 declare i8* @_Znwm()
 declare i32 @__gxx_personality_v0(...)
 declare void @g()
-define void @f() {
+define void @f() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 bb0:
   br label %bb1
 bb1:
   %v0 = phi i64 [ 0, %bb0 ], [ %v1, %bb1 ]
   %v1 = add nsw i64 %v0, 1
   br i1 undef, label %bb2, label %bb1
 bb2:
   %v2 = icmp eq i64 %v0, 0
   br i1 %v2, label %bb6, label %bb3
 bb3:
   %v3 = invoke noalias i8* @_Znwm()
           to label %bb5 unwind label %bb4
 bb4:
-  %v4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %v4 = landingpad { i8*, i32 }
           cleanup
   br label %bb9
 bb5:
   %v5 = bitcast i8* %v3 to i32**
   %add.ptr.i = getelementptr inbounds i32*, i32** %v5, i64 %v0
   br label %bb6
 bb6:
   %v6 = phi i32** [ null, %bb2 ], [ %add.ptr.i, %bb5 ]
   invoke void @g()
           to label %bb7 unwind label %bb8
 bb7:
   unreachable
 bb8:
-  %v7 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %v7 = landingpad { i8*, i32 }
           cleanup
   br label %bb9
 bb9:
   resume { i8*, i32 } zeroinitializer
 }
 
 
-define void @h() {
+define void @h() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 bb1:
   invoke void @g() optsize
           to label %bb2 unwind label %bb5
 bb2:
   %arrayctor.cur = phi i8* [ undef, %bb1 ], [ %arrayctor.next, %bb3 ]
   invoke void @g() optsize
           to label %bb3 unwind label %bb6
 bb3:
   %arrayctor.next = getelementptr inbounds i8, i8* %arrayctor.cur, i64 1
   br label %bb2
 bb4:
   ret void
 bb5:
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp = landingpad { i8*, i32 }
           cleanup
   invoke void @g() optsize
           to label %bb4 unwind label %bb7
 bb6:
-  %tmp1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %tmp1 = landingpad { i8*, i32 }
           cleanup
   %arraydestroy.isempty = icmp eq i8* undef, %arrayctor.cur
   ret void
 bb7:
-  %lpad.nonloopexit = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %lpad.nonloopexit = landingpad { i8*, i32 }
           catch i8* null
   ret void
 }
 
 ; PR17425
 define void @i() {
 entry:
   br label %while.cond

llvm/trunk/test/Transforms/LoopUnswitch/2011-09-26-EHCrash.ll

 ; RUN: opt < %s -scalarrepl-ssa -loop-unswitch -disable-output
 ; PR11016
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-macosx10.7.2"
 
 %class.MyContainer.1.3.19.29 = type { [6 x %class.MyMemVarClass.0.2.18.28*] }
 %class.MyMemVarClass.0.2.18.28 = type { i32 }
 
-define void @_ZN11MyContainer1fEi(%class.MyContainer.1.3.19.29* %this, i32 %doit) uwtable ssp align 2 {
+define void @_ZN11MyContainer1fEi(%class.MyContainer.1.3.19.29* %this, i32 %doit) uwtable ssp align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
   %inc1 = phi i32 [ %inc, %for.inc ], [ 0, %entry ]
   %conv = sext i32 %inc1 to i64
   %cmp = icmp ult i64 %conv, 6
   br i1 %cmp, label %for.body, label %for.end
invoke void @_ZN13MyMemVarClassD1Ev(%class.MyMemVarClass.0.2.18.28* %tmp4)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %delete.notnull
   %0 = bitcast %class.MyMemVarClass.0.2.18.28* %tmp4 to i8*
   call void @_ZdlPv(i8* %0) nounwind
   br label %for.inc
 
 lpad:                                             ; preds = %delete.notnull
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   %2 = extractvalue { i8*, i32 } %1, 0
   %3 = extractvalue { i8*, i32 } %1, 1
   %4 = bitcast %class.MyMemVarClass.0.2.18.28* %tmp4 to i8*
   call void @_ZdlPv(i8* %4) nounwind
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %2, 0
   %lpad.val7 = insertvalue { i8*, i32 } %lpad.val, i32 %3, 1
   resume { i8*, i32 } %lpad.val7

llvm/trunk/test/Transforms/LoopUnswitch/2012-04-30-LoopUnswitch-LPad-Crash.ll

 ; RUN: opt < %s -basicaa -instcombine -inline -functionattrs -licm -loop-unswitch -gvn -verify
 ; PR12573
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.7.0"
 
 %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 }
 %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* }
 %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* }
 %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 }
 
-define void @_Z23get_reconstruction_pathv() uwtable ssp {
+define void @_Z23get_reconstruction_pathv() uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %c = alloca %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379, align 8
   br label %for.cond
 
 for.cond:                                         ; preds = %for.end, %entry
   invoke void @_ZN1DptEv(%class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* %c)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %for.cond
   invoke void @_ZN1C3endEv()
           to label %for.cond3 unwind label %lpad
 
 for.cond3:                                        ; preds = %invoke.cont6, %invoke.cont
   invoke void @_ZN1DptEv(%class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* %c)
           to label %invoke.cont4 unwind label %lpad
 
 invoke.cont4:                                     ; preds = %for.cond3
   invoke void @_ZN1C3endEv()
           to label %invoke.cont6 unwind label %lpad
 
 invoke.cont6:                                     ; preds = %invoke.cont4
   br i1 undef, label %for.cond3, label %for.end
 
 lpad:                                             ; preds = %for.end, %invoke.cont4, %for.cond3, %invoke.cont, %for.cond
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 
 for.end:                                          ; preds = %invoke.cont6
   invoke void @_ZN1C13_M_insert_auxER1D()
           to label %for.cond unwind label %lpad
 }
 

llvm/trunk/test/Transforms/LowerInvoke/2003-12-10-Crash.ll

 ; This testcase was reduced from Shootout-C++/reversefile.cpp by bugpoint
 
 ; RUN: opt < %s -lowerinvoke -disable-output
 
 declare void @baz()
 
 declare void @bar()
 
-define void @foo() {
+define void @foo() personality i32 (...)* @__gxx_personality_v0 {
 then:
   invoke void @baz( )
       to label %invoke_cont.0 unwind label %try_catch
 invoke_cont.0:    ; preds = %then
   invoke void @bar( )
       to label %try_exit unwind label %try_catch
 try_catch:    ; preds = %invoke_cont.0, %then
   %__tmp.0 = phi i32* [ null, %invoke_cont.0 ], [ null, %then ]    ; <i32*> [#uses=0]
-  %res = landingpad { i8* } personality i32 (...)* @__gxx_personality_v0
+  %res = landingpad { i8* }
           cleanup
   ret void
 try_exit:   ; preds = %invoke_cont.0
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/LowerInvoke/lowerinvoke.ll

 ; RUN: opt < %s -lowerinvoke -S | FileCheck %s
 
 declare i32 @external_func(i64 %arg)
 
-define i32 @invoke_test(i64 %arg) {
+define i32 @invoke_test(i64 %arg) personality i8* null {
 entry:
   %result = invoke fastcc i32 @external_func(i64 inreg %arg)
       to label %cont unwind label %lpad
 cont:
   ret i32 %result
 lpad:
   %phi = phi i32 [ 99, %entry ]
-  %lp = landingpad { i8*, i32 } personality i8* null cleanup
+  %lp = landingpad { i8*, i32 } cleanup
   ret i32 %phi
 }
 
 ; The "invoke" should be converted to a "call".
 ; CHECK-LABEL: define i32 @invoke_test
 ; CHECK: %result = call fastcc i32 @external_func(i64 inreg %arg)
 ; CHECK-NEXT: br label %cont
 
 ; Note that this pass does not remove dead landingpad blocks.
 ; CHECK: lpad:
 ; CHECK-NOT: phi
 ; CHECK: landingpad

llvm/trunk/test/Transforms/Mem2Reg/crash.ll

 ; RUN: opt < %s -mem2reg -S
 ; PR5023
 
 declare i32 @test1f()
 
-define i32 @test1() {
+define i32 @test1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %whichFlag = alloca i32
   %A = invoke i32 @test1f()
           to label %invcont2 unwind label %lpad86
 
 invcont2:
   store i32 %A, i32* %whichFlag
   br label %bb15
 
 bb15:
   %B = load i32, i32* %whichFlag
   ret i32 %B
 
 lpad86:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            cleanup
   br label %bb15
   
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 

llvm/trunk/test/Transforms/MergeFunc/2011-02-08-RemoveEqual.ll

 %"struct.kc::impl_fileline_FileLine" = type { %"struct.kc::impl_fileline" }
 %"struct.kc::impl_outmostpatterns" = type { %"struct.kc::impl_Ccode_option", %"struct.kc::impl_elem_patternrepresentation"*, %"struct.kc::impl_outmostpatterns"* }
 %"struct.kc::impl_withcaseinfo_Withcaseinfo" = type { %"struct.kc::impl_Ccode_option", %"struct.kc::impl_outmostpatterns"*, %"struct.kc::impl_outmostpatterns"*, %"struct.kc::impl_Ctext"* }
 
 @_ZTVN2kc13impl_filelineE = external constant [13 x i32 (...)*], align 32
 @.str = external constant [1 x i8], align 1
 @_ZTVN2kc22impl_fileline_FileLineE = external constant [13 x i32 (...)*], align 32
 
-define void @_ZN2kc22impl_fileline_FileLineC2EPNS_20impl_casestring__StrEi(%"struct.kc::impl_fileline_FileLine"* %this, %"struct.kc::impl_casestring__Str"* %_file, i32 %_line) align 2 {
+define void @_ZN2kc22impl_fileline_FileLineC2EPNS_20impl_casestring__StrEi(%"struct.kc::impl_fileline_FileLine"* %this, %"struct.kc::impl_casestring__Str"* %_file, i32 %_line) align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %this_addr = alloca %"struct.kc::impl_fileline_FileLine"*, align 4
   %_file_addr = alloca %"struct.kc::impl_casestring__Str"*, align 4
   %_line_addr = alloca i32, align 4
   %save_filt.150 = alloca i32
   %save_eptr.149 = alloca i8*
   %iftmp.99 = alloca %"struct.kc::impl_casestring__Str"*
   %eh_exception = alloca i8*
bb2:                                              ; preds = %bb1, %invcont
   %14 = load %"struct.kc::impl_fileline_FileLine"*, %"struct.kc::impl_fileline_FileLine"** %this_addr, align 4
   %15 = getelementptr inbounds %"struct.kc::impl_fileline_FileLine", %"struct.kc::impl_fileline_FileLine"* %14, i32 0, i32 0
   %16 = getelementptr inbounds %"struct.kc::impl_fileline", %"struct.kc::impl_fileline"* %15, i32 0, i32 2
   %17 = load i32, i32* %_line_addr, align 4
   store i32 %17, i32* %16, align 4
   ret void
 
 lpad:                                             ; preds = %bb
-  %eh_ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %eh_ptr = landingpad { i8*, i32 }
               cleanup
   %exn = extractvalue { i8*, i32 } %eh_ptr, 0
   store i8* %exn, i8** %eh_exception
   %eh_ptr4 = load i8*, i8** %eh_exception
   %eh_select5 = extractvalue { i8*, i32 } %eh_ptr, 1
   store i32 %eh_select5, i32* %eh_selector
   %eh_select = load i32, i32* %eh_selector
   store i32 %eh_select, i32* %save_filt.150, align 4
bb1:                                              ; preds = %entry
   %5 = bitcast %"struct.kc::impl_fileline"* %4 to i8*
   call void @_ZdlPv() nounwind
   br label %return
 
 return:                                           ; preds = %bb1, %entry
   ret void
 }
 
-define void @_ZN2kc22impl_fileline_FileLineC1EPNS_20impl_casestring__StrEi(%"struct.kc::impl_fileline_FileLine"* %this, %"struct.kc::impl_casestring__Str"* %_file, i32 %_line) align 2 {
+define void @_ZN2kc22impl_fileline_FileLineC1EPNS_20impl_casestring__StrEi(%"struct.kc::impl_fileline_FileLine"* %this, %"struct.kc::impl_casestring__Str"* %_file, i32 %_line) align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %this_addr = alloca %"struct.kc::impl_fileline_FileLine"*, align 4
   %_file_addr = alloca %"struct.kc::impl_casestring__Str"*, align 4
   %_line_addr = alloca i32, align 4
   %save_filt.148 = alloca i32
   %save_eptr.147 = alloca i8*
   %iftmp.99 = alloca %"struct.kc::impl_casestring__Str"*
   %eh_exception = alloca i8*
bb2:                                              ; preds = %bb1, %invcont
   %14 = load %"struct.kc::impl_fileline_FileLine"*, %"struct.kc::impl_fileline_FileLine"** %this_addr, align 4
   %15 = getelementptr inbounds %"struct.kc::impl_fileline_FileLine", %"struct.kc::impl_fileline_FileLine"* %14, i32 0, i32 0
   %16 = getelementptr inbounds %"struct.kc::impl_fileline", %"struct.kc::impl_fileline"* %15, i32 0, i32 2
   %17 = load i32, i32* %_line_addr, align 4
   store i32 %17, i32* %16, align 4
   ret void
 
 lpad:                                             ; preds = %bb
-  %eh_ptr = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %eh_ptr = landingpad { i8*, i32 }
               cleanup
   %exn = extractvalue { i8*, i32 } %eh_ptr, 0
   store i8* %exn, i8** %eh_exception
   %eh_ptr4 = load i8*, i8** %eh_exception
   %eh_select5 = extractvalue { i8*, i32 } %eh_ptr, 1
   store i32 %eh_select5, i32* %eh_selector
   %eh_select = load i32, i32* %eh_selector
   store i32 %eh_select, i32* %save_filt.148, align 4

llvm/trunk/test/Transforms/MergeFunc/call-and-invoke-with-ranges.ll

 ; CHECK-NEXT: bitcast i8 0 to i8
 ; CHECK-NEXT: %out = call i8 @dummy(), !range !1
 ; CHECK-NEXT: ret i8 %out
   bitcast i8 0 to i8
   %out = call i8 @dummy(), !range !1
   ret i8 %out
 }
 
-define i8 @invoke_with_range() {
+define i8 @invoke_with_range() personality i8* undef {
   %out = invoke i8 @dummy() to label %next unwind label %lpad, !range !0
 
 next:
   ret i8 %out
 
 lpad:
-  %pad = landingpad { i8*, i32 } personality i8* undef cleanup
+  %pad = landingpad { i8*, i32 } cleanup
   resume { i8*, i32 } zeroinitializer
 }
 
-define i8 @invoke_no_range() {
+define i8 @invoke_no_range() personality i8* undef {
 ; CHECK-LABEL: @invoke_no_range()
 ; CHECK-NEXT: invoke i8 @dummy
   %out = invoke i8 @dummy() to label %next unwind label %lpad
 
 next:
   ret i8 %out
 
 lpad:
-  %pad = landingpad { i8*, i32 } personality i8* undef cleanup
+  %pad = landingpad { i8*, i32 } cleanup
   resume { i8*, i32 } zeroinitializer
 }
 
-define i8 @invoke_different_range() {
+define i8 @invoke_different_range() personality i8* undef {
 ; CHECK-LABEL: @invoke_different_range()
 ; CHECK-NEXT: invoke i8 @dummy
   %out = invoke i8 @dummy() to label %next unwind label %lpad, !range !1
 
 next:
   ret i8 %out
 
 lpad:
-  %pad = landingpad { i8*, i32 } personality i8* undef cleanup
+  %pad = landingpad { i8*, i32 } cleanup
   resume { i8*, i32 } zeroinitializer
 }
 
 define i8 @call_with_same_range() {
 ; CHECK-LABEL: @call_with_same_range
 ; CHECK: tail call i8 @call_with_range
   bitcast i8 0 to i8
   %out = call i8 @dummy(), !range !0
   ret i8 %out
 }
 
-define i8 @invoke_with_same_range() {
+define i8 @invoke_with_same_range() personality i8* undef {
 ; CHECK-LABEL: @invoke_with_same_range()
 ; CHECK: tail call i8 @invoke_with_range()
   %out = invoke i8 @dummy() to label %next unwind label %lpad, !range !0
 
 next:
   ret i8 %out
 
 lpad:
-  %pad = landingpad { i8*, i32 } personality i8* undef cleanup
+  %pad = landingpad { i8*, i32 } cleanup
   resume { i8*, i32 } zeroinitializer
 }
 
 declare i8 @dummy();
 declare i32 @__gxx_personality_v0(...)
 
 !0 = !{i8 0, i8 2}
 !1 = !{i8 5, i8 7}

llvm/trunk/test/Transforms/ObjCARC/basic.ll

 }
 
 ; Bitcast insertion
 
 ; CHECK-LABEL: define void @test20(
 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) [[NUW]]
 ; CHECK-NEXT: invoke
 ; CHECK: }
-define void @test20(double* %self) {
+define void @test20(double* %self) personality i32 (...)* @__gxx_personality_v0 {
 if.then12:
   %tmp = bitcast double* %self to i8*
   %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
   invoke void @invokee()
           to label %invoke.cont23 unwind label %lpad20
 
 invoke.cont23:                                    ; preds = %if.then12
   invoke void @invokee()
           to label %if.end unwind label %lpad20
 
 lpad20:                                           ; preds = %invoke.cont23, %if.then12
   %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            cleanup
   unreachable
 
 if.end:                                           ; preds = %invoke.cont23
   ret void
 }
 
 ; Delete a redundant retain,autorelease when forwaring a call result

llvm/trunk/test/Transforms/ObjCARC/contract-testcases.ll

bb7:                                              ; preds = %bb6, %bb6, %bb5
   %tmp8 = phi %0* [ %tmp, %bb ], [ %tmp, %bb ]
   unreachable
 }
 
 ; When looking for the defining instruction for an objc_retainAutoreleasedReturnValue
 ; call, handle the case where it's an invoke in a different basic block.
 ; rdar://11714057
 
-; CHECK: define void @_Z6doTestP8NSString() {
+; CHECK: define void @_Z6doTestP8NSString() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 ; CHECK: invoke.cont:                                      ; preds = %entry
 ; CHECK-NEXT: call void asm sideeffect "mov\09r7, r7\09\09@ marker for objc_retainAutoreleaseReturnValue", ""()
 ; CHECK-NEXT: %tmp = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %call) [[NUW:#[0-9]+]]
 ; CHECK: }
-define void @_Z6doTestP8NSString() {
+define void @_Z6doTestP8NSString() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %call = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* ()*)()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %tmp = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %call) nounwind
   unreachable
 
 lpad:                                             ; preds = %entry
-  %tmp1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1 = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 }
 
 !clang.arc.retainAutoreleasedReturnValueMarker = !{!0}
 
 !0 = !{!"mov\09r7, r7\09\09@ marker for objc_retainAutoreleaseReturnValue"}
 
 ; CHECK: attributes #0 = { optsize }
 ; CHECK: attributes [[NUW]] = { nounwind }

llvm/trunk/test/Transforms/ObjCARC/ensure-that-exception-unwind-path-is-visited.ll

 @"OBJC_CLASS_$_NSException" = external global %struct._class_t
 @"\01L_OBJC_CLASSLIST_REFERENCES_$_1" = internal global %struct._class_t* @"OBJC_CLASS_$_NSException", section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
 @.str2 = private unnamed_addr constant [4 x i8] c"Foo\00", align 1
 @_unnamed_cfstring_3 = private constant %struct.NSConstantString { i32* getelementptr inbounds ([0 x i32], [0 x i32]* @__CFConstantStringClassReference, i32 0, i32 0), i32 1992, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str2, i32 0, i32 0), i64 3 }, section "__DATA,__cfstring"
 @"\01L_OBJC_METH_VAR_NAME_4" = internal global [14 x i8] c"raise:format:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
 @"\01L_OBJC_SELECTOR_REFERENCES_5" = internal global i8* getelementptr inbounds ([14 x i8], [14 x i8]* @"\01L_OBJC_METH_VAR_NAME_4", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
 @llvm.used = appending global [6 x i8*] [i8* bitcast (%struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_" to i8*), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i32 0, i32 0), i8* bitcast (i8** @"\01L_OBJC_SELECTOR_REFERENCES_" to i8*), i8* bitcast (%struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_1" to i8*), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @"\01L_OBJC_METH_VAR_NAME_4", i32 0, i32 0), i8* bitcast (i8** @"\01L_OBJC_SELECTOR_REFERENCES_5" to i8*)], section "llvm.metadata"
 
-define i32 @main() uwtable ssp {
+define i32 @main() uwtable ssp personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %tmp = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_", align 8, !dbg !37
   %tmp1 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8, !dbg !37, !invariant.load !38
   %tmp2 = bitcast %struct._class_t* %tmp to i8*, !dbg !37
 ; CHECK: call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp2, i8* %tmp1)
   %call = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* %tmp2, i8* %tmp1), !dbg !37, !clang.arc.no_objc_arc_exceptions !38
   call void @llvm.dbg.value(metadata i8* %call, i64 0, metadata !25, metadata !DIExpression()), !dbg !37
 ; CHECK: call i8* @objc_retain(i8* %call) [[NUW:#[0-9]+]]
   %tmp3 = call i8* @objc_retain(i8* %call) nounwind, !dbg !39
   call void @llvm.dbg.value(metadata i8* %call, i64 0, metadata !25, metadata !DIExpression()), !dbg !39
   invoke fastcc void @ThrowFunc(i8* %call)
           to label %eh.cont unwind label %lpad, !dbg !40, !clang.arc.no_objc_arc_exceptions !38
 
 eh.cont:                                          ; preds = %entry
 ; CHECK: call void @objc_release(i8* %call)
   call void @objc_release(i8* %call) nounwind, !dbg !42, !clang.imprecise_release !38
   br label %if.end, !dbg !43
 
 lpad:                                             ; preds = %entry
-  %tmp4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %tmp4 = landingpad { i8*, i32 }
           catch i8* null, !dbg !40
   %tmp5 = extractvalue { i8*, i32 } %tmp4, 0, !dbg !40
   %exn.adjusted = call i8* @objc_begin_catch(i8* %tmp5) nounwind, !dbg !44
   call void @llvm.dbg.value(metadata i8 0, i64 0, metadata !21, metadata !DIExpression()), !dbg !46
   call void @objc_end_catch(), !dbg !49, !clang.arc.no_objc_arc_exceptions !38
 ; CHECK: call void @objc_release(i8* %call)
   call void @objc_release(i8* %call) nounwind, !dbg !42, !clang.imprecise_release !38
   call void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring_ to i8*), i8* %call), !dbg !50, !clang.arc.no_objc_arc_exceptions !38

llvm/trunk/test/Transforms/ObjCARC/invoke.ll

 ; CHECK-LABEL: define void @test0(
 ; CHECK: invoke.cont:
 ; CHECK:   call void @objc_release(i8* %zipFile) [[NUW:#[0-9]+]], !clang.imprecise_release !0
 ; CHECK:   ret void
 ; CHECK: lpad:
 ; CHECK:   call void @objc_release(i8* %zipFile) [[NUW]], !clang.imprecise_release !0
 ; CHECK:   ret void
 ; CHECK-NEXT: }
-define void @test0(i8* %zipFile) {
+define void @test0(i8* %zipFile) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   call i8* @objc_retain(i8* %zipFile) nounwind
   call void @use_pointer(i8* %zipFile)
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*)*)(i8* %zipFile) 
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   call void @objc_release(i8* %zipFile) nounwind, !clang.imprecise_release !0
   ret void
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            cleanup
   call void @objc_release(i8* %zipFile) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 ; ARCOpt should move the release before the callee calls.
 
 ; CHECK-LABEL: define void @test1(
 ; CHECK: invoke.cont:
 ; CHECK:   call void @objc_release(i8* %zipFile) [[NUW]], !clang.imprecise_release !0
 ; CHECK:   call void @callee()
 ; CHECK:   br label %done
 ; CHECK: lpad:
 ; CHECK:   call void @objc_release(i8* %zipFile) [[NUW]], !clang.imprecise_release !0
 ; CHECK:   call void @callee()
 ; CHECK:   br label %done
 ; CHECK: done:
 ; CHECK-NEXT: ret void
 ; CHECK-NEXT: }
-define void @test1(i8* %zipFile) {
+define void @test1(i8* %zipFile) personality i32 (...)* @__gxx_personality_v0 {
 entry:
   call i8* @objc_retain(i8* %zipFile) nounwind
   call void @use_pointer(i8* %zipFile)
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*)*)(i8* %zipFile)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   call void @callee()
   br label %done
 
 lpad:                                             ; preds = %entry
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
            cleanup
   call void @callee()
   br label %done
 
 done:
   call void @objc_release(i8* %zipFile) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 ; The optimizer should ignore invoke unwind paths consistently.
 ; PR12265
 
-; CHECK: define void @test2() {
+; CHECK: define void @test2() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 ; CHECK: invoke.cont:
 ; CHECK-NEXT: call i8* @objc_retain
 ; CHECK-NOT: @objc_r
 ; CHECK: finally.cont:
 ; CHECK-NEXT: call void @objc_release
 ; CHECK-NOT: @objc
 ; CHECK: finally.rethrow:
 ; CHECK-NOT: @objc
 ; CHECK: }
-define void @test2() {
+define void @test2() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %call = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* ()*)()
           to label %invoke.cont unwind label %finally.rethrow, !clang.arc.no_objc_arc_exceptions !0
 
 invoke.cont:                                      ; preds = %entry
   %tmp1 = tail call i8* @objc_retainAutoreleasedReturnValue(i8* %call) nounwind
   call void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void ()*)(), !clang.arc.no_objc_arc_exceptions !0
   invoke void @use_pointer(i8* %call)
           to label %finally.cont unwind label %finally.rethrow, !clang.arc.no_objc_arc_exceptions !0
 
 finally.cont:                                     ; preds = %invoke.cont
   tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
   ret void
 
 finally.rethrow:                                  ; preds = %invoke.cont, %entry
-  %tmp2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %tmp2 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 ; Don't try to place code on invoke critical edges.
 
 ; CHECK-LABEL: define void @test3(
 ; CHECK: if.end:
 ; CHECK-NEXT: call void @objc_release(i8* %p) [[NUW]]
 ; CHECK-NEXT: ret void
 ; CHECK-NEXT: }
-define void @test3(i8* %p, i1 %b) {
+define void @test3(i8* %p, i1 %b) personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %0 = call i8* @objc_retain(i8* %p)
   call void @callee()
   br i1 %b, label %if.else, label %if.then
 
 if.then:
   invoke void @use_pointer(i8* %p)
           to label %if.end unwind label %lpad, !clang.arc.no_objc_arc_exceptions !0
 
 if.else:
   invoke void @use_pointer(i8* %p)
           to label %if.end unwind label %lpad, !clang.arc.no_objc_arc_exceptions !0
 
 lpad:
-  %r = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %r = landingpad { i8*, i32 }
        cleanup
   ret void
 
 if.end:
   call void @objc_release(i8* %p)
   ret void
 }
 
 ; Like test3, but with ARC-relevant exception handling.
 
 ; CHECK-LABEL: define void @test4(
 ; CHECK: lpad:
-; CHECK-NEXT: %r = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+; CHECK-NEXT: %r = landingpad { i8*, i32 }
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: call void @objc_release(i8* %p) [[NUW]]
 ; CHECK-NEXT: ret void
 ; CHECK: if.end:
 ; CHECK-NEXT: call void @objc_release(i8* %p) [[NUW]]
 ; CHECK-NEXT: ret void
 ; CHECK-NEXT: }
-define void @test4(i8* %p, i1 %b) {
+define void @test4(i8* %p, i1 %b) personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %0 = call i8* @objc_retain(i8* %p)
   call void @callee()
   br i1 %b, label %if.else, label %if.then
 
 if.then:
   invoke void @use_pointer(i8* %p)
           to label %if.end unwind label %lpad
 
 if.else:
   invoke void @use_pointer(i8* %p)
           to label %if.end unwind label %lpad
 
 lpad:
-  %r = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %r = landingpad { i8*, i32 }
        cleanup
   call void @objc_release(i8* %p)
   ret void
 
 if.end:
   call void @objc_release(i8* %p)
   ret void
 }
 
 ; Don't turn the retainAutoreleaseReturnValue into retain, because it's
 ; for an invoke which we can assume codegen will put immediately prior.
 
 ; CHECK-LABEL: define void @test5(
 ; CHECK: call i8* @objc_retainAutoreleasedReturnValue(i8* %z)
 ; CHECK: }
-define void @test5() {
+define void @test5() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %z = invoke i8* @returner()
           to label %if.end unwind label %lpad, !clang.arc.no_objc_arc_exceptions !0
 
 lpad:
-  %r13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %r13 = landingpad { i8*, i32 }
           cleanup
   ret void
 
 if.end:
   call i8* @objc_retainAutoreleasedReturnValue(i8* %z)
   ret void
 }
 
 ; Like test5, but there's intervening code.
 
 ; CHECK-LABEL: define void @test6(
 ; CHECK: call i8* @objc_retain(i8* %z)
 ; CHECK: }
-define void @test6() {
+define void @test6() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   %z = invoke i8* @returner()
           to label %if.end unwind label %lpad, !clang.arc.no_objc_arc_exceptions !0
 
 lpad:
-  %r13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %r13 = landingpad { i8*, i32 }
           cleanup
   ret void
 
 if.end:
   call void @callee()
   call i8* @objc_retainAutoreleasedReturnValue(i8* %z)
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)
 declare i32 @__objc_personality_v0(...)
 
 ; CHECK: attributes [[NUW]] = { nounwind }
 
 !0 = !{}

llvm/trunk/test/Transforms/ObjCARC/path-overflow.ll

 declare i8* @returner()
 declare i8* @objc_msgSend(i8*, i8*, ...) nonlazybind
 declare void @NSLog(i8*, ...)
 declare void @objc_msgSend_stret(i8*, i8*, ...)
 declare i32 @__gxx_personality_sj0(...)
 declare i32 @__objc_personality_v0(...)
 
 
-define hidden void @test1() {
+define hidden void @test1() personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   br i1 undef, label %msgSend.nullinit, label %msgSend.call
 
 msgSend.call:                                     ; preds = %entry
   br label %msgSend.cont
 
 msgSend.nullinit:                                 ; preds = %entry
   br label %msgSend.cont

 bb221:                                            ; preds = %bb219
   unreachable
 
 bb222:                                            ; preds = %bb20, %bb19
   ret void
 }
 
 ; Function Attrs: ssp
-define void @test3() #1 {
+define void @test3() #1 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 entry:
   %call2 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %call5 = invoke signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont4 unwind label %lpad3
 

 
 invoke.cont.i:                                    ; preds = %land.end
   br i1 undef, label %invoke.cont8, label %if.then.i
 
 if.then.i:                                        ; preds = %invoke.cont.i
   br label %invoke.cont8
 
 lpad.i:                                           ; preds = %land.end
-  %tmp13 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp13 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont8:                                     ; preds = %if.then.i, %invoke.cont.i
   %call18 = invoke i8* (i8*, i8*, i8*, ...) bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*, ...)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef)
           to label %invoke.cont17 unwind label %lpad16
 
 invoke.cont17:                                    ; preds = %invoke.cont8
   %call22 = invoke signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont21 unwind label %lpad20
 
 invoke.cont21:                                    ; preds = %invoke.cont17
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i1980 unwind label %lpad.i1982
 
 invoke.cont.i1980:                                ; preds = %invoke.cont21
   br i1 undef, label %invoke.cont24, label %if.then.i1981
 
 if.then.i1981:                                    ; preds = %invoke.cont.i1980
   br label %invoke.cont24
 
 lpad.i1982:                                       ; preds = %invoke.cont21
-  %tmp28 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp28 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont24:                                    ; preds = %if.then.i1981, %invoke.cont.i1980
   %call37 = invoke signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont36 unwind label %lpad35
 
 invoke.cont36:                                    ; preds = %invoke.cont24

 
 invoke.cont.i1986:                                ; preds = %land.end43
   br i1 undef, label %invoke.cont44, label %if.then.i1987
 
 if.then.i1987:                                    ; preds = %invoke.cont.i1986
   br label %invoke.cont44
 
 lpad.i1988:                                       ; preds = %land.end43
-  %tmp42 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp42 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont44:                                    ; preds = %if.then.i1987, %invoke.cont.i1986
   %call53 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont52 unwind label %lpad51
 
 invoke.cont52:                                    ; preds = %invoke.cont44

 
 invoke.cont.i1998:                                ; preds = %invoke.cont71
   br i1 undef, label %invoke.cont91, label %if.then.i1999
 
 if.then.i1999:                                    ; preds = %invoke.cont.i1998
   br label %invoke.cont91
 
 lpad.i2000:                                       ; preds = %invoke.cont71
-  %tmp74 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp74 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup102
 
 invoke.cont91:                                    ; preds = %if.then.i1999, %invoke.cont.i1998
   %call96 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont95 unwind label %lpad94
 
 invoke.cont95:                                    ; preds = %invoke.cont91
   %call98 = invoke signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* %call96)
           to label %invoke.cont97 unwind label %lpad94
 
 invoke.cont97:                                    ; preds = %invoke.cont95
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2004 unwind label %lpad.i2006
 
 invoke.cont.i2004:                                ; preds = %invoke.cont97
   br i1 undef, label %invoke.cont100, label %if.then.i2005
 
 if.then.i2005:                                    ; preds = %invoke.cont.i2004
   br label %invoke.cont100
 
 lpad.i2006:                                       ; preds = %invoke.cont97
-  %tmp82 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp82 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont100:                                   ; preds = %if.then.i2005, %invoke.cont.i2004
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont110 unwind label %lpad109
 
 invoke.cont110:                                   ; preds = %invoke.cont100
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2010 unwind label %lpad.i2012
 
 invoke.cont.i2010:                                ; preds = %invoke.cont110
   br i1 undef, label %invoke.cont117, label %if.then.i2011
 
 if.then.i2011:                                    ; preds = %invoke.cont.i2010
   br label %invoke.cont117
 
 lpad.i2012:                                       ; preds = %invoke.cont110
-  %tmp98 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp98 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont117:                                   ; preds = %if.then.i2011, %invoke.cont.i2010
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2022 unwind label %lpad156.body
 
 lpad:                                             ; preds = %entry
-  %tmp118 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp118 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup
 
 lpad3:                                            ; preds = %land.rhs, %invoke.cont
-  %tmp119 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp119 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup
 
 ehcleanup:                                        ; preds = %lpad3, %lpad
   unreachable
 
 lpad16:                                           ; preds = %invoke.cont8
-  %tmp121 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp121 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup26
 
 lpad20:                                           ; preds = %invoke.cont17
-  %tmp122 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp122 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup26
 
 ehcleanup26:                                      ; preds = %lpad20, %lpad16
   unreachable
 
 lpad35:                                           ; preds = %land.rhs39, %invoke.cont24
-  %tmp124 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp124 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad51:                                           ; preds = %invoke.cont44
-  %tmp125 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp125 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad61:                                           ; preds = %land.rhs58
-  %tmp127 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp127 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad66.body.thread:                               ; preds = %invoke.cont62
-  %tmp128 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp128 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad66.body:                                      ; preds = %land.end70
-  %tmp129 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp129 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad94:                                           ; preds = %invoke.cont95, %invoke.cont91
-  %tmp133 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp133 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup102
 
 ehcleanup102:                                     ; preds = %lpad94, %lpad.i2000
   unreachable
 
 lpad109:                                          ; preds = %invoke.cont100
-  %tmp134 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp134 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont.i2022:                                ; preds = %invoke.cont117
   br i1 undef, label %invoke.cont157, label %if.then.i2023
 
 if.then.i2023:                                    ; preds = %invoke.cont.i2022
   br label %invoke.cont157

 
 invoke.cont.i2034:                                ; preds = %invoke.cont185
   br i1 undef, label %invoke.cont190, label %if.then.i2035
 
 if.then.i2035:                                    ; preds = %invoke.cont.i2034
   br label %invoke.cont190
 
 lpad.i2036:                                       ; preds = %invoke.cont185
-  %tmp168 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp168 = landingpad { i8*, i32 }
           cleanup
   br label %lpad183.body
 
 invoke.cont190:                                   ; preds = %if.then.i2035, %invoke.cont.i2034
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont197 unwind label %lpad196
 
 invoke.cont197:                                   ; preds = %invoke.cont190

 
 invoke.cont.i2040:                                ; preds = %invoke.cont204
   br i1 undef, label %invoke.cont207, label %if.then.i2041
 
 if.then.i2041:                                    ; preds = %invoke.cont.i2040
   br label %invoke.cont207
 
 lpad.i2042:                                       ; preds = %invoke.cont204
-  %tmp181 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp181 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont207:                                   ; preds = %if.then.i2041, %invoke.cont.i2040
   %call209 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont208 unwind label %lpad203
 
 invoke.cont208:                                   ; preds = %invoke.cont207

 
 invoke.cont.i2052:                                ; preds = %invoke.cont228
   br i1 undef, label %invoke.cont231, label %if.then.i2053
 
 if.then.i2053:                                    ; preds = %invoke.cont.i2052
   br label %invoke.cont231
 
 lpad.i2054:                                       ; preds = %invoke.cont228
-  %tmp198 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp198 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont231:                                   ; preds = %if.then.i2053, %invoke.cont.i2052
   %call233 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont232 unwind label %lpad227
 
 invoke.cont232:                                   ; preds = %invoke.cont231

 
 invoke.cont.i2064:                                ; preds = %invoke.cont278
   br i1 undef, label %invoke.cont281, label %if.then.i2065
 
 if.then.i2065:                                    ; preds = %invoke.cont.i2064
   br label %invoke.cont281
 
 lpad.i2066:                                       ; preds = %invoke.cont278
-  %tmp253 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp253 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont281:                                   ; preds = %if.then.i2065, %invoke.cont.i2064
   %call291 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont290 unwind label %lpad289
 
 invoke.cont290:                                   ; preds = %invoke.cont281

 
 invoke.cont.i2076:                                ; preds = %invoke.cont370
   br i1 undef, label %invoke.cont373, label %if.then.i2077
 
 if.then.i2077:                                    ; preds = %invoke.cont.i2076
   br label %invoke.cont373
 
 lpad.i2078:                                       ; preds = %invoke.cont370
-  %tmp340 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp340 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont373:                                   ; preds = %if.then.i2077, %invoke.cont.i2076
   %call377 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32, i8*)*)(i8* undef, i8* undef, i32 42, i8* undef)
           to label %invoke.cont376 unwind label %lpad363
 
 invoke.cont376:                                   ; preds = %invoke.cont373

 
 invoke.cont.i2082:                                ; preds = %invoke.cont383
   br i1 undef, label %invoke.cont392, label %if.then.i2083
 
 if.then.i2083:                                    ; preds = %invoke.cont.i2082
   br label %invoke.cont392
 
 lpad.i2084:                                       ; preds = %invoke.cont383
-  %tmp360 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp360 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont392:                                   ; preds = %if.then.i2083, %invoke.cont.i2082
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i32)*)(i8* undef, i8* undef, i8* undef, i32 -2)
           to label %invoke.cont395 unwind label %lpad381
 
 invoke.cont395:                                   ; preds = %invoke.cont392

 
 invoke.cont.i2088:                                ; preds = %invoke.cont402
   br i1 undef, label %invoke.cont405, label %if.then.i2089
 
 if.then.i2089:                                    ; preds = %invoke.cont.i2088
   br label %invoke.cont405
 
 lpad.i2090:                                       ; preds = %invoke.cont402
-  %tmp370 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp370 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont405:                                   ; preds = %if.then.i2089, %invoke.cont.i2088
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i32)*)(i8* undef, i8* undef, i8* undef, i32 -1)
           to label %invoke.cont408 unwind label %lpad381
 
 invoke.cont408:                                   ; preds = %invoke.cont405

 
 invoke.cont.i2094:                                ; preds = %invoke.cont412
   br i1 undef, label %invoke.cont418, label %if.then.i2095
 
 if.then.i2095:                                    ; preds = %invoke.cont.i2094
   br label %invoke.cont418
 
 lpad.i2096:                                       ; preds = %invoke.cont412
-  %tmp380 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp380 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont418:                                   ; preds = %if.then.i2095, %invoke.cont.i2094
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i32)*)(i8* undef, i8* undef, i8* undef, i32 0)
           to label %invoke.cont422 unwind label %lpad381
 
 invoke.cont422:                                   ; preds = %invoke.cont418

 
 invoke.cont.i2100:                                ; preds = %invoke.cont429
   br i1 undef, label %invoke.cont432, label %if.then.i2101
 
 if.then.i2101:                                    ; preds = %invoke.cont.i2100
   br label %invoke.cont432
 
 lpad.i2102:                                       ; preds = %invoke.cont429
-  %tmp390 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp390 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont432:                                   ; preds = %if.then.i2101, %invoke.cont.i2100
   %call436 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 0)
           to label %invoke.cont435 unwind label %lpad381
 
 invoke.cont435:                                   ; preds = %invoke.cont432
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2106 unwind label %lpad.i2108
 
 invoke.cont.i2106:                                ; preds = %invoke.cont435
   %call444 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 5)
           to label %invoke.cont443 unwind label %lpad381
 
 lpad.i2108:                                       ; preds = %invoke.cont435
-  %tmp396 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp396 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont443:                                   ; preds = %invoke.cont.i2106
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2112 unwind label %lpad.i2114
 
 invoke.cont.i2112:                                ; preds = %invoke.cont443
   br i1 undef, label %invoke.cont449, label %if.then.i2113
 
 if.then.i2113:                                    ; preds = %invoke.cont.i2112
   br label %invoke.cont449
 
 lpad.i2114:                                       ; preds = %invoke.cont443
-  %tmp402 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp402 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont449:                                   ; preds = %if.then.i2113, %invoke.cont.i2112
   %call453 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 -2)
           to label %invoke.cont452 unwind label %lpad381
 
 invoke.cont452:                                   ; preds = %invoke.cont449
   %call456 = invoke i32 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i32 (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont455 unwind label %lpad454
 
 invoke.cont455:                                   ; preds = %invoke.cont452
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2118 unwind label %lpad.i2120
 
 invoke.cont.i2118:                                ; preds = %invoke.cont455
   br i1 undef, label %invoke.cont458, label %if.then.i2119
 
 if.then.i2119:                                    ; preds = %invoke.cont.i2118
   br label %invoke.cont458
 
 lpad.i2120:                                       ; preds = %invoke.cont455
-  %tmp408 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp408 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont458:                                   ; preds = %if.then.i2119, %invoke.cont.i2118
   %call461 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 -1)
           to label %invoke.cont460 unwind label %lpad381
 
 invoke.cont460:                                   ; preds = %invoke.cont458
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2124 unwind label %lpad.i2126
 
 invoke.cont.i2124:                                ; preds = %invoke.cont460
   br i1 undef, label %invoke.cont466, label %if.then.i2125
 
 if.then.i2125:                                    ; preds = %invoke.cont.i2124
   br label %invoke.cont466
 
 lpad.i2126:                                       ; preds = %invoke.cont460
-  %tmp414 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp414 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup477
 
 invoke.cont466:                                   ; preds = %if.then.i2125, %invoke.cont.i2124
   %call470 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 0)
           to label %invoke.cont469 unwind label %lpad381
 
 invoke.cont469:                                   ; preds = %invoke.cont466
   invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2130 unwind label %lpad.i2132
 
 invoke.cont.i2130:                                ; preds = %invoke.cont469
   br i1 undef, label %invoke.cont475, label %if.then.i2131
 
 if.then.i2131:                                    ; preds = %invoke.cont.i2130
   br label %invoke.cont475
 
 lpad.i2132:                                       ; preds = %invoke.cont469
-  %tmp420 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp420 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup477
 
 invoke.cont475:                                   ; preds = %if.then.i2131, %invoke.cont.i2130
   %call491 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* undef, i8* undef, i32 1)
           to label %invoke.cont490 unwind label %lpad489
 
 invoke.cont490:                                   ; preds = %invoke.cont475

 
 invoke.cont.i2136:                                ; preds = %msgSend.cont
   br i1 undef, label %invoke.cont521, label %if.then.i2137
 
 if.then.i2137:                                    ; preds = %invoke.cont.i2136
   br label %invoke.cont521
 
 lpad.i2138:                                       ; preds = %msgSend.cont
-  %tmp468 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp468 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont521:                                   ; preds = %if.then.i2137, %invoke.cont.i2136
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef)
           to label %invoke.cont528 unwind label %lpad527
 
 invoke.cont528:                                   ; preds = %invoke.cont521

 
 invoke.cont.i2142:                                ; preds = %invoke.cont534
   br i1 undef, label %invoke.cont540, label %if.then.i2143
 
 if.then.i2143:                                    ; preds = %invoke.cont.i2142
   br label %invoke.cont540
 
 lpad.i2144:                                       ; preds = %invoke.cont534
-  %tmp486 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp486 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 invoke.cont540:                                   ; preds = %if.then.i2143, %invoke.cont.i2142
   %call544 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* undef, i32 3)
           to label %invoke.cont543 unwind label %lpad489
 
 invoke.cont543:                                   ; preds = %invoke.cont540
invoke void (i8*, ...) @NSLog(i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i8* %tmp499, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont.i2148 unwind label %lpad.i2150
 
 invoke.cont.i2148:                                ; preds = %invoke.cont554
   call void @objc_release(i8* %tmp499) #3, !clang.imprecise_release !0
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont566 unwind label %lpad565
 
 lpad.i2150:                                       ; preds = %invoke.cont554
-  %tmp500 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp500 = landingpad { i8*, i32 }
           cleanup
   call void @objc_release(i8* %tmp499) #3, !clang.imprecise_release !0
   unreachable
 
 invoke.cont566:                                   ; preds = %invoke.cont.i2148
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i8*, i8*)*)(i8* undef, i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*))
           to label %invoke.cont572 unwind label %lpad571
 
 invoke.cont572:                                   ; preds = %invoke.cont566
   %call582 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* undef, i8* undef)
           to label %invoke.cont581 unwind label %lpad580
 
 invoke.cont581:                                   ; preds = %invoke.cont572
   unreachable
 
 lpad156.body:                                     ; preds = %invoke.cont117
-  %tmp1157 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1157 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad164.body:                                     ; preds = %invoke.cont157
-  %tmp1158 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1158 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad183:                                          ; preds = %invoke.cont184, %invoke.cont165
-  %tmp1159 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1159 = landingpad { i8*, i32 }
           cleanup
   br label %lpad183.body
 
 lpad183.body:                                     ; preds = %lpad183, %lpad.i2036
   unreachable
 
 lpad196:                                          ; preds = %invoke.cont190
-  %tmp1160 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1160 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad200:                                          ; preds = %invoke.cont197
-  %tmp1161 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1161 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad203:                                          ; preds = %invoke.cont207, %invoke.cont201
-  %tmp1162 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1162 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad212.body:                                     ; preds = %invoke.cont208
-  %tmp1163 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1163 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad220:                                          ; preds = %invoke.cont213
-  %tmp1164 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1164 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 lpad227:                                          ; preds = %invoke.cont231, %invoke.cont221
-  %tmp1166 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1166 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup239
 
 lpad236.body:                                     ; preds = %invoke.cont232
-  %tmp1167 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1167 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup239
 
 ehcleanup239:                                     ; preds = %lpad236.body, %lpad227
   unreachable
 
 lpad244:                                          ; preds = %invoke.cont245, %invoke.cont237
-  %tmp1168 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1168 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad249:                                          ; preds = %invoke.cont247
-  %tmp1169 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1169 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad252:                                          ; preds = %invoke.cont250
-  %tmp1170 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1170 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup263
 
 lpad255:                                          ; preds = %invoke.cont253
-  %tmp1171 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1171 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup263
 
 lpad258:                                          ; preds = %invoke.cont256
-  %tmp1172 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1172 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 ehcleanup263:                                     ; preds = %lpad255, %lpad252
   unreachable
 
 lpad265:                                          ; preds = %invoke.cont259
-  %tmp1173 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1173 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad273:                                          ; preds = %invoke.cont266
-  %tmp1175 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1175 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad277:                                          ; preds = %invoke.cont274
-  %tmp1176 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1176 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad289:                                          ; preds = %invoke.cont281
-  %tmp1177 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1177 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad301:                                          ; preds = %invoke.cont290
-  %tmp1180 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1180 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad308:                                          ; preds = %invoke.cont302
-  %tmp1182 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1182 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad311:                                          ; preds = %invoke.cont309
-  %tmp1183 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1183 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad314:                                          ; preds = %invoke.cont312
-  %tmp1184 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1184 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad320:                                          ; preds = %invoke.cont315
-  %tmp1186 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1186 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad340.body.thread:                              ; preds = %land.rhs335
-  %tmp1188 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1188 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad340.body:                                     ; preds = %land.end344
-  %tmp1189 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1189 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad360:                                          ; preds = %invoke.cont345
-  %tmp1191 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1191 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 lpad363:                                          ; preds = %invoke.cont373, %invoke.cont361
-  %tmp1192 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1192 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad369:                                          ; preds = %invoke.cont364
-  %tmp1194 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1194 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad381:                                          ; preds = %invoke.cont466, %invoke.cont458, %invoke.cont449, %invoke.cont.i2106, %invoke.cont432, %invoke.cont422, %invoke.cont418, %invoke.cont408, %invoke.cont405, %invoke.cont395, %invoke.cont392, %invoke.cont382, %invoke.cont376
-  %tmp1196 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1196 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup477
 
 lpad398:                                          ; preds = %invoke.cont396
-  %tmp1199 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1199 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad401:                                          ; preds = %invoke.cont399
-  %tmp1200 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1200 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad411:                                          ; preds = %invoke.cont409
-  %tmp1201 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1201 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad425:                                          ; preds = %invoke.cont423
-  %tmp1203 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1203 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup477
 
 lpad428:                                          ; preds = %invoke.cont426
-  %tmp1204 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1204 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad454:                                          ; preds = %invoke.cont452
-  %tmp1207 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1207 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 ehcleanup477:                                     ; preds = %lpad425, %lpad381, %lpad.i2132, %lpad.i2126
   unreachable
 
 lpad489:                                          ; preds = %invoke.cont546, %invoke.cont540, %invoke.cont528, %invoke.cont509, %invoke.cont499, %invoke.cont475
-  %tmp1211 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1211 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup560
 
 lpad498:                                          ; preds = %invoke.cont490
-  %tmp1214 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1214 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad505:                                          ; preds = %invoke.cont503
-  %tmp1215 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1215 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad508:                                          ; preds = %invoke.cont506
-  %tmp1216 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1216 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad514:                                          ; preds = %msgSend.call
-  %tmp1217 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1217 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad527:                                          ; preds = %invoke.cont521
-  %tmp1219 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1219 = landingpad { i8*, i32 }
           cleanup
   br label %ehcleanup560
 
 lpad533:                                          ; preds = %invoke.cont531
-  %tmp1220 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1220 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad545:                                          ; preds = %invoke.cont543
-  %tmp1222 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1222 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad553:                                          ; preds = %invoke.cont548
-  %tmp1224 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1224 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 ehcleanup560:                                     ; preds = %lpad527, %lpad489
   br label %eh.resume
 
 lpad565:                                          ; preds = %invoke.cont.i2148
-  %tmp1225 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1225 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad571:                                          ; preds = %invoke.cont566
-  %tmp1227 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1227 = landingpad { i8*, i32 }
           cleanup
   unreachable
 
 lpad580:                                          ; preds = %invoke.cont572
-  %tmp1228 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp1228 = landingpad { i8*, i32 }
           cleanup
   br label %eh.resume
 
 eh.resume:                                        ; preds = %lpad580, %ehcleanup560, %lpad360, %lpad220
   resume { i8*, i32 } undef
 }
 
 @"OBJC_EHTYPE_$_NSException" = external global i8
 
-define void @test4() {
+define void @test4() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   br i1 undef, label %if.end13, label %if.then10
 
 if.then10:                                        ; preds = %entry
   br label %if.end13
 
 if.end13:                                         ; preds = %if.then10, %entry
   %0 = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*, i64, i8*, i8)*)(i8* undef, i8* undef, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring to i8*), i64 2, i8* bitcast (%struct.NSConstantString* @_unnamed_cfstring_2 to i8*), i8 signext 0), !clang.arc.no_objc_arc_exceptions !0

 eh.cont:                                          ; preds = %if.end399
   br i1 undef, label %if.then430, label %if.end439.critedge
 
 if.then430:                                       ; preds = %eh.cont
   %1 = call i8* @objc_retain(i8* %0)
   br label %if.end439
 
 lpad:                                             ; preds = %if.end399
-  %2 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %2 = landingpad { i8*, i32 }
           catch i8* @"OBJC_EHTYPE_$_NSException"
   unreachable
 
 if.end439.critedge:                               ; preds = %eh.cont
   %3 = call i8* @objc_retain(i8* %0)
   br label %if.end439
 
 if.end439:                                        ; preds = %if.end439.critedge, %if.then430

llvm/trunk/test/Transforms/ObjCARC/retain-not-declared.ll

 ; rdar://9825114
 
 ; CHECK-LABEL: @test1(
 ; CHECK: @objc_retain(
 ; CHECK: @objc_retainAutoreleasedReturnValue(
 ; CHECK: @objc_release(
 ; CHECK: @objc_release(
 ; CHECK: }
-define void @test1(i8* %call88) nounwind {
+define void @test1(i8* %call88) nounwind personality i32 (...)* @__gxx_personality_v0 {
 entry:
   %tmp1 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call88) nounwind
   %call94 = invoke i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*)*)(i8* %tmp1)
           to label %invoke.cont93 unwind label %lpad91
 
 invoke.cont93:                                    ; preds = %entry
   %tmp2 = call i8* @objc_retainAutoreleasedReturnValue(i8* %call94) nounwind
   call void @objc_release(i8* %tmp1) nounwind
   invoke void bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*)*)(i8* %tmp2)
           to label %invoke.cont102 unwind label %lpad100
 
 invoke.cont102:                                   ; preds = %invoke.cont93
   call void @objc_release(i8* %tmp2) nounwind, !clang.imprecise_release !0
   unreachable
 
 lpad91:                                           ; preds = %entry
-  %exn91 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn91 = landingpad {i8*, i32}
               cleanup
   unreachable
 
 lpad100:                                          ; preds = %invoke.cont93
-  %exn100 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn100 = landingpad {i8*, i32}
               cleanup
   call void @objc_release(i8* %tmp2) nounwind, !clang.imprecise_release !0
   unreachable
 }
 
 declare i32 @__gxx_personality_v0(...)
 
 !0 = !{}
 
 ; CHECK: attributes [[NUW]] = { nounwind }

llvm/trunk/test/Transforms/ObjCARC/split-backedge.ll

 ; RUN: opt -S -objc-arc < %s | FileCheck %s
 
 ; Handle a retain+release pair entirely contained within a split loop backedge.
 ; rdar://11256239
 
 ; CHECK-LABEL: define void @test0(
 ; CHECK: call i8* @objc_retain(i8* %call) [[NUW:#[0-9]+]]
 ; CHECK: call i8* @objc_retain(i8* %call) [[NUW]]
 ; CHECK: call i8* @objc_retain(i8* %cond) [[NUW]]
 ; CHECK: call void @objc_release(i8* %call) [[NUW]]
 ; CHECK: call void @objc_release(i8* %call) [[NUW]]
 ; CHECK: call void @objc_release(i8* %cond) [[NUW]]
-define void @test0() {
+define void @test0() personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*) {
 entry:
   br label %while.body
 
 while.body:                                       ; preds = %while.cond
   %call = invoke i8* @returner()
           to label %invoke.cont unwind label %lpad, !clang.arc.no_objc_arc_exceptions !0
 
 invoke.cont:                                      ; preds = %while.body
   %t0 = call i8* @objc_retain(i8* %call) nounwind
   %t1 = call i8* @objc_retain(i8* %call) nounwind
   %call.i1 = invoke i8* @returner()
           to label %invoke.cont1 unwind label %lpad
 
 invoke.cont1:                                     ; preds = %invoke.cont
   %cond = select i1 undef, i8* null, i8* %call
   %t2 = call i8* @objc_retain(i8* %cond) nounwind
   call void @objc_release(i8* %call) nounwind
   call void @objc_release(i8* %call) nounwind
   call void @use_pointer(i8* %cond)
   call void @objc_release(i8* %cond) nounwind
   br label %while.body
 
 lpad:                                             ; preds = %invoke.cont, %while.body
-  %t4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__objc_personality_v0 to i8*)
+  %t4 = landingpad { i8*, i32 }
           catch i8* null
   ret void
 }
 
 declare i8* @returner()
 declare i32 @__objc_personality_v0(...)
 declare void @objc_release(i8*)
 declare i8* @objc_retain(i8*)
 declare void @use_pointer(i8*)
 
 !0 = !{}
 
 ; CHECK: attributes [[NUW]] = { nounwind }

llvm/trunk/test/Transforms/PhaseOrdering/gdce.ll

entry:
   %this.addr = alloca %class.Base*, align 8
   store %class.Base* %this, %class.Base** %this.addr, align 8
   %this1 = load %class.Base*, %class.Base** %this.addr
   %0 = bitcast %class.Base* %this1 to i8***
   store i8** getelementptr inbounds ([4 x i8*], [4 x i8*]* @_ZTV4Base, i64 0, i64 2), i8*** %0
   ret void
 }
 
-define linkonce_odr void @_ZN4BaseD0Ev(%class.Base* %this) unnamed_addr uwtable ssp align 2 {
+define linkonce_odr void @_ZN4BaseD0Ev(%class.Base* %this) unnamed_addr uwtable ssp align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %this.addr = alloca %class.Base*, align 8
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store %class.Base* %this, %class.Base** %this.addr, align 8
   %this1 = load %class.Base*, %class.Base** %this.addr
   invoke void @_ZN4BaseD1Ev(%class.Base* %this1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   %0 = bitcast %class.Base* %this1 to i8*
   call void @_ZdlPv(i8* %0) nounwind
   ret void
 
 lpad:                                             ; preds = %entry
-  %1 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %1 = landingpad { i8*, i32 }
           cleanup
   %2 = extractvalue { i8*, i32 } %1, 0
   store i8* %2, i8** %exn.slot
   %3 = extractvalue { i8*, i32 } %1, 1
   store i32 %3, i32* %ehselector.slot
   %4 = bitcast %class.Base* %this1 to i8*
   call void @_ZdlPv(i8* %4) nounwind
   br label %eh.resume

llvm/trunk/test/Transforms/PlaceSafepoints/invokes.ll

 ; RUN: opt %s -S -place-safepoints | FileCheck %s
 
 declare i64 addrspace(1)* @"some_call"(i64 addrspace(1)*)
 declare i32 @"personality_function"()
 
-define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke
   ; CHECK: statepoint
   ; CHECK: some_call
   %ret_val = invoke i64 addrspace(1)* @"some_call"(i64 addrspace(1)* %obj)
                to label %normal_return unwind label %exceptional_return
 
 ; CHECK-LABEL: normal_return:
 ; CHECK: gc.result
 ; CHECK: ret i64
 
 normal_return:
   ret i64 addrspace(1)* %ret_val
 
 ; CHECK-LABEL: exceptional_return:
 ; CHECK: landingpad
 ; CHECK: ret i64
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @"personality_function"
+  %landing_pad4 = landingpad {i8*, i32}
           cleanup
   ret i64 addrspace(1)* %obj1
 }
 
-define i64 addrspace(1)* @test_two_invokes(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define i64 addrspace(1)* @test_two_invokes(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke 
   ; CHECK: statepoint
   ; CHECK: some_call
   %ret_val1 = invoke i64 addrspace(1)* @"some_call"(i64 addrspace(1)* %obj)
                to label %second_invoke unwind label %exceptional_return
 
normal_return:
   ; CHECK: gc.result
   ; CHECK: ret i64
   ret i64 addrspace(1)* %ret_val2
 
 ; CHECK: exceptional_return:
 ; CHECK: ret i64
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @"personality_function"
+  %landing_pad4 = landingpad {i8*, i32}
           cleanup
   ret i64 addrspace(1)* %obj1
 }
 
-define i64 addrspace(1)* @test_phi_node(i1 %cond, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define i64 addrspace(1)* @test_phi_node(i1 %cond, i64 addrspace(1)* %obj) gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: @test_phi_node
 ; CHECK-LABEL: entry:
 entry:
   br i1 %cond, label %left, label %right
 
 left:
   %ret_val_left = invoke i64 addrspace(1)* @"some_call"(i64 addrspace(1)* %obj)
                     to label %merge unwind label %exceptional_return

 merge:
   %ret_val = phi i64 addrspace(1)* [%ret_val_left, %left], [%ret_val_right, %right]
   ret i64 addrspace(1)* %ret_val
 
 ; CHECK-LABEL: exceptional_return:
 ; CHECK: ret i64 addrspace(1)*
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @"personality_function"
+  %landing_pad4 = landingpad {i8*, i32}
           cleanup
   ret i64 addrspace(1)* %obj
 }
 
 declare void @do_safepoint()
 define void @gc.safepoint_poll() {
 ; CHECK-LABEL: gc.safepoint_poll
 ; CHECK-LABEL: entry
 ; CHECK-NEXT: do_safepoint
 ; CHECK-NEXT: ret void 
 entry:
   call void @do_safepoint()
   ret void
-}
+}
 

llvm/trunk/test/Transforms/PlaceSafepoints/patchable-statepoints.ll

 ; RUN: opt -place-safepoints -S < %s | FileCheck %s
 
 declare void @f()
 declare i32 @personality_function()
 
-define void @test_id() gc "statepoint-example" {
+define void @test_id() gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: @test_id(
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 100, i32 0, void ()* @f
   invoke void @f()  "statepoint-id"="100" to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ret void
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @personality_function cleanup
+  %landing_pad4 = landingpad {i8*, i32} cleanup
   ret void
 }
 
-define void @test_num_patch_bytes() gc "statepoint-example" {
+define void @test_num_patch_bytes() gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: @test_num_patch_bytes(
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 99, void ()* null,
   invoke void @f()  "statepoint-num-patch-bytes"="99" to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ret void
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @personality_function cleanup
+  %landing_pad4 = landingpad {i8*, i32} cleanup
   ret void
 }
 
 declare void @do_safepoint()
 define void @gc.safepoint_poll() {
 entry:
   call void @do_safepoint()
   ret void
 }
 
 ; CHECK-NOT: statepoint-id
 ; CHECK-NOT: statepoint-num-patch_bytes

llvm/trunk/test/Transforms/PlaceSafepoints/statepoint-calling-conventions.ll

 ; RUN: opt -place-safepoints -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate carry over
 ; the right calling conventions.
 
-define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke coldcc i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0)
 entry:
   %ret_val = invoke coldcc i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
                to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ret i64 addrspace(1)* %ret_val
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @personality
+  %landing_pad4 = landingpad {i8*, i32}
           cleanup
   ret i64 addrspace(1)* %obj1
 }
 
 define i64 addrspace(1)* @test_call_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
 ; CHECK-LABEL: @test_call_format(
 ; CHECK-LABEL: entry:
 ; CHECK: call coldcc i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0)

llvm/trunk/test/Transforms/PlaceSafepoints/statepoint-format.ll

 ; RUN: opt -place-safepoints -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate have the
 ; set of arguments we expect it to have.
 
-define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
+define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0)
 entry:
   %ret_val = invoke i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
                to label %normal_return unwind label %exceptional_return
 
 normal_return:
   ret i64 addrspace(1)* %ret_val
 
 exceptional_return:
-  %landing_pad4 = landingpad {i8*, i32} personality i32 ()* @personality
+  %landing_pad4 = landingpad {i8*, i32}
           cleanup
   ret i64 addrspace(1)* %obj1
 }
 
 define i64 addrspace(1)* @test_call_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" {
 ; CHECK-LABEL: @test_call_format(
 ; CHECK-LABEL: entry:
 ; CHECK: call i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0)

llvm/trunk/test/Transforms/PruneEH/recursivetest.ll

 ; RUN: opt < %s -prune-eh -S | not grep invoke
 
-define internal i32 @foo() {
+define internal i32 @foo() personality i32 (...)* @__gxx_personality_v0 {
   invoke i32 @foo( )
       to label %Normal unwind label %Except   ; <i32>:1 [#uses=0]
 Normal:   ; preds = %0
   ret i32 12
 Except:   ; preds = %0
-        landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+        landingpad { i8*, i32 }
                 catch i8* null
   ret i32 123
 }
 
-define i32 @caller() {
+define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
   invoke i32 @foo( )
       to label %Normal unwind label %Except   ; <i32>:1 [#uses=0]
 Normal:   ; preds = %0
   ret i32 0
 Except:   ; preds = %0
-        landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+        landingpad { i8*, i32 }
                 catch i8* null
   ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/PruneEH/seh-nounwind.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
 
 ; Don't remove invokes of nounwind functions if the personality handles async
 ; exceptions. The @div function in this test can fault, even though it can't
 ; throw a synchronous exception.
 
 define i32 @div(i32 %n, i32 %d) nounwind {
 entry:
   %div = sdiv i32 %n, %d
   ret i32 %div
 }
 
-define i32 @main() nounwind {
+define i32 @main() nounwind personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %call = invoke i32 @div(i32 10, i32 0)
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   br label %__try.cont
 
 __try.cont:
   %retval.0 = phi i32 [ %call, %entry ], [ 0, %lpad ]
   ret i32 %retval.0
 }
 
 ; CHECK-LABEL: define i32 @main()
 ; CHECK: invoke i32 @div(i32 10, i32 0)
 
 declare i32 @__C_specific_handler(...)

llvm/trunk/test/Transforms/PruneEH/simpletest.ll

 ; RUN: opt < %s -prune-eh -S | not grep invoke
 
 declare void @nounwind() nounwind
 
 define internal void @foo() {
   call void @nounwind()
   ret void
 }
 
-define i32 @caller() {
+define i32 @caller() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @foo( )
       to label %Normal unwind label %Except
 
 Normal:   ; preds = %0
   ret i32 0
 
 Except:   ; preds = %0
-        landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+        landingpad { i8*, i32 }
                 catch i8* null
   ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/Reg2Mem/crash.ll

 ; RUN: opt -reg2mem -disable-output < %s
 ; PR14782
 
 declare void @f1()
 
 declare i32 @__gxx_personality_sj0(...)
 
 declare void @f2()
 
 declare void @f3()
 
 declare void @f4_()
 
 declare void @_Z12xxxdtsP10xxxpq()
 
-define hidden void @_ZN12xxxyzIi9xxxwLi29ELi0EE4f3NewES0_i() ssp align 2 {
+define hidden void @_ZN12xxxyzIi9xxxwLi29ELi0EE4f3NewES0_i() ssp align 2 personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*) {
 bb:
   invoke void @f4_()
           to label %bb1 unwind label %.thread
 
 .thread:                                          ; preds = %bb
-  %tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp = landingpad { i8*, i32 }
           cleanup
   br label %bb13
 
 bb1:                                              ; preds = %bb
   invoke void @f1()
           to label %.noexc unwind label %bb10
 
 .noexc:                                           ; preds = %bb1
   invoke void @f4_()
           to label %bb6 unwind label %bb2
 
 bb2:                                              ; preds = %.noexc
-  %tmp3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp3 = landingpad { i8*, i32 }
           cleanup
   invoke void @f3()
           to label %.body unwind label %bb4
 
 bb4:                                              ; preds = %bb2
-  %tmp5 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp5 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 
 bb6:                                              ; preds = %.noexc
   invoke void @_Z12xxxdtsP10xxxpq()
           to label %_ZN6xxxdIN12xxxyzIi9xxxwLi29ELi0EE4fr1jS3_.exit unwind label %bb10
 
 _ZN6xxxdIN12xxxyzIi9xxxwLi29ELi0EE4fr1jS3_.exit:  ; preds = %bb6
   invoke void @f2()
           to label %bb7 unwind label %bb8
 
 bb7:                                              ; preds = %_ZN6xxxdIN12xxxyzIi9xxxwLi29ELi0EE4fr1jS3_.exit
   ret void
 
 bb8:                                              ; preds = %_ZN6xxxdIN12xxxyzIi9xxxwLi29ELi0EE4fr1jS3_.exit
-  %tmp9 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp9 = landingpad { i8*, i32 }
           cleanup
   br label %_ZN10xxxpqdlev.exit
 
 bb10:                                             ; preds = %bb6, %bb1
   %.1 = phi i1 [ true, %bb1 ], [ false, %bb6 ]
-  %tmp11 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp11 = landingpad { i8*, i32 }
           cleanup
   br label %.body
 
 .body:                                            ; preds = %bb10, %bb2
   %.1.lpad-body = phi i1 [ %.1, %bb10 ], [ true, %bb2 ]
   invoke void @f2()
           to label %bb12 unwind label %bb14
 
 bb12:                                             ; preds = %.body
   br i1 %.1.lpad-body, label %bb13, label %_ZN10xxxpqdlev.exit
 
 bb13:                                             ; preds = %bb12, %.thread
   invoke void @xxx_MemFree()
           to label %_ZN10xxxpqdlev.exit unwind label %bb14
 
 _ZN10xxxpqdlev.exit:                              ; preds = %bb13, %bb12, %bb8
   resume { i8*, i32 } undef
 
 bb14:                                             ; preds = %bb13, %.body
-  %tmp15 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_sj0 to i8*)
+  %tmp15 = landingpad { i8*, i32 }
           catch i8* null
   unreachable
 }
 
 declare void @xxx_MemFree()

llvm/trunk/test/Transforms/RewriteStatepointsForGC/live-vector.ll

entry:
   %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
   %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0)
   ret <2 x i64 addrspace(1)*> %obj
 }
 
 declare i32 @fake_personality_function()
 
 ; When a statepoint is an invoke rather than a call
-define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" {
+define <2 x i64 addrspace(1)*> @test4(<2 x i64 addrspace(1)*>* %ptr) gc "statepoint-example" personality i32 ()* @fake_personality_function {
 ; CHECK-LABEL: test4
 ; CHECK: load
 ; CHECK-NEXT: extractelement
 ; CHECK-NEXT: extractelement
 ; CHECK-NEXT: gc.statepoint
 entry:
   %obj = load <2 x i64 addrspace(1)*>, <2 x i64 addrspace(1)*>* %ptr
   invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0)

 ; CHECK: gc.relocate
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: gc.relocate
 ; CHECK-NEXT: bitcast
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: insertelement
 ; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %14
 exceptional_return:                               ; preds = %entry
-  %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* @fake_personality_function
+  %landing_pad4 = landingpad { i8*, i32 }
           cleanup
   ret <2 x i64 addrspace(1)*> %obj
 }
 
 ; Can we handle an insert element with a constant offset?  This effectively
 ; tests both the equal and inequal case since we have to relocate both indices
 ; in the vector.
 define <2 x i64 addrspace(1)*> @test5(i64 addrspace(1)* %p) 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/preprocess.ll

unreached:
   %obj = phi i64 addrspace(1)* [null, %unreached]
   call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0)
   call void (...) @consume(i64 addrspace(1)* %obj)
   br label %unreached
 }
 
 ; Need to delete unreachable gc.statepoint invoke - tested seperately given
 ; a correct implementation could only remove the instructions, not the block
-define void @test8() gc "statepoint-example" {
+define void @test8() gc "statepoint-example" personality i32 ()* undef {
 ; CHECK-LABEL: test8
 ; CHECK-NOT: gc.statepoint
   ret void
 
 unreached:
   invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0)
           to label %normal_return unwind label %exceptional_return
 
 normal_return:                                    ; preds = %entry
   ret void
 
 exceptional_return:                               ; preds = %entry
-  %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* undef
+  %landing_pad4 = landingpad { i8*, i32 }
           cleanup
   ret void
 }
 
 declare void @foo()
 ; Bound the last check-not
 ; CHECK-LABEL: @foo
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll

 ;; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 
 ;; This test is to verify that RewriteStatepointsForGC correctly relocates values
 ;; defined by invoke instruction results. 
 
 declare i64* addrspace(1)* @non_gc_call()
 
 declare void @gc_call()
 
 declare i32* @fake_personality_function()
 
 ; Function Attrs: nounwind
-define i64* addrspace(1)* @test() gc "statepoint-example" {
+define i64* addrspace(1)* @test() gc "statepoint-example" personality i32* ()* @fake_personality_function {
 entry:
   %obj = invoke i64* addrspace(1)* @non_gc_call()
           to label %normal_dest unwind label %unwind_dest
 
 unwind_dest: 
-  %lpad = landingpad { i8*, i32 } personality i32* ()* @fake_personality_function
+  %lpad = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } undef
 
 normal_dest:
 ;; CHECK-LABEL: normal_dest:
 ;; CHECK-NEXT: gc.statepoint
 ;; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
 ;; CHECK-NEXT: bitcast
   %safepoint_token = call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @gc_call, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
   ret i64* addrspace(1)* %obj
 }
 
 declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
 

llvm/trunk/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll

entry:
   ; CHECK: bitcast
   ; CHECK: getelementptr
   call void @use_obj32(i32 addrspace(1)* %ptr)
   ret void
 }
 
 declare i32 @fake_personality_function()
 
-define void @"test_invoke"(i32 addrspace(1)* %base) gc "statepoint-example" {
+define void @"test_invoke"(i32 addrspace(1)* %base) gc "statepoint-example" personality i32 ()* @fake_personality_function {
 ; CHECK-LABEL: test_invoke
 entry:
   %ptr.gep = getelementptr i32, i32 addrspace(1)* %base, i32 15
   ; CHECK: getelementptr
   %ptr.cast = bitcast i32 addrspace(1)* %ptr.gep to i64 addrspace(1)*
   ; CHECK: bitcast
   %ptr.cast2 = bitcast i32 addrspace(1)* %ptr.gep to i16 addrspace(1)*
   ; CHECK: bitcast
normal:
   ; CHECK: getelementptr
   ; CHECK: bitcast
   call void @use_obj64(i64 addrspace(1)* %ptr.cast)
   call void @use_obj16(i16 addrspace(1)* %ptr.cast2)
   ret void
 
 exception:
   ; CHECK-LABEL: exception:
-  %landing_pad4 = landingpad { i8*, i32 } personality i32 ()* @fake_personality_function
+  %landing_pad4 = landingpad { i8*, i32 }
           cleanup
   ; CHECK: gc.relocate
   ; CHECK: bitcast
   ; CHECK: getelementptr
   ; CHECK: bitcast
   ; CHECK: getelementptr
   ; CHECK: bitcast
   call void @use_obj64(i64 addrspace(1)* %ptr.cast)

llvm/trunk/test/Transforms/SCCP/2003-08-26-InvokeHandling.ll

 ; The PHI cannot be eliminated from this testcase, SCCP is mishandling invoke's!
 ; RUN: opt < %s -sccp -S | grep phi
 
 declare void @foo()
 
-define i32 @test(i1 %cond) {
+define i32 @test(i1 %cond) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 Entry:
   br i1 %cond, label %Inv, label %Cont
 Inv:    ; preds = %Entry
   invoke void @foo( )
       to label %Ok unwind label %LPad
 Ok:   ; preds = %Inv
   br label %Cont
 LPad:
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  catch i8* null
         br label %Cont
 Cont:   ; preds = %Ok, %Inv, %Entry
   %X = phi i32 [ 0, %Entry ], [ 1, %Ok ], [ 0, %LPad ]    ; <i32> [#uses=1]
   ret i32 %X
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SCCP/2004-11-16-DeadInvoke.ll

 ; RUN: opt < %s -sccp -disable-output
 
 declare i32 @foo()
 
-define void @caller() {
+define void @caller() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   br i1 true, label %T, label %F
 F:    ; preds = %0
   %X = invoke i32 @foo( )
       to label %T unwind label %LP    ; <i32> [#uses=0]
 LP:
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  catch i8* null
         br label %T
 T:
   ret void
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SCCP/2007-05-16-InvokeCrash.ll

 ; RUN: opt < %s -sccp -disable-output
 ; PR1431
 
-define void @_ada_bench() {
+define void @_ada_bench() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br label %cond_next
 cond_next:    ; preds = %cond_next, %entry
   %indvar46 = phi i32 [ 0, %entry ], [ %indvar.next47, %cond_next ]    ; <i32> [#uses=1]
   %indvar.next47 = add i32 %indvar46, 1   ; <i32> [#uses=2]
   %exitcond48 = icmp eq i32 %indvar.next47, 10000    ; <i1> [#uses=1]
   br i1 %exitcond48, label %cond_next40, label %cond_next
 cond_next40:    ; preds = %cond_next40, %cond_next
bb114:    ; preds = %bb67
   %tmp147 = invoke double @log( double 5.000000e-01 )
       to label %bb149 unwind label %cleanup   ; <double> [#uses=0]
 bb149:    ; preds = %bb114
   %tmp175 = invoke double @sqrt( double 5.000000e-01 )
       to label %bb177 unwind label %cleanup   ; <double> [#uses=0]
 bb177:    ; preds = %bb149
   unreachable
 cleanup:    ; preds = %bb149, %bb114, %bb67
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  cleanup
   resume { i8*, i32 } %val
 }
 
 declare double @sin(double)
 
 declare double @log(double)
 
 declare double @sqrt(double)
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SCCP/2009-01-14-IPSCCP-Invoke.ll

 ; RUN: opt < %s -ipsccp -S | grep "ret i32 42"
 ; RUN: opt < %s -ipsccp -S | grep "ret i32 undef"
 ; PR3325
 
-define i32 @main() {
+define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %tmp1 = invoke i32 @f()
       to label %UnifiedReturnBlock unwind label %lpad
 
 lpad:
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  cleanup
   unreachable
 
 UnifiedReturnBlock:
   ret i32 %tmp1
 }
 
 define internal i32 @f() {
        ret i32 42
 }
 
 declare i8* @__cxa_begin_catch(i8*) nounwind
 
 declare void @__cxa_end_catch()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SCCP/ipsccp-basic.ll

 ;;======================== test4
 
 define internal {i64,i64} @test4a() {
   %a = insertvalue {i64,i64} undef, i64 4, 1
   %b = insertvalue {i64,i64} %a, i64 5, 0
   ret {i64,i64} %b
 }
 
-define i64 @test4b() {
+define i64 @test4b() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %a = invoke {i64,i64} @test4a()
           to label %A unwind label %B
 A:
   %b = extractvalue {i64,i64} %a, 0
   %c = call i64 @test4c(i64 %b)
   ret i64 %c
 B:
-  %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %val = landingpad { i8*, i32 }
            catch i8* null
   ret i64 0
 }
 ; CHECK: define i64 @test4b()
 ; CHECK:   %c = call i64 @test4c(i64 5)
 ; CHECK-NEXT:  ret i64 5
 
 

 
 ; PR4313
 define internal {i64,i64} @test5a() {
   %a = insertvalue {i64,i64} undef, i64 4, 1
   %b = insertvalue {i64,i64} %a, i64 5, 0
   ret {i64,i64} %b
 }
 
-define i64 @test5b() {
+define i64 @test5b() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %a = invoke {i64,i64} @test5a()
           to label %A unwind label %B
 A:
   %c = call i64 @test5c({i64,i64} %a)
   ret i64 %c
 B:
-  %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %val = landingpad { i8*, i32 }
            catch i8* null
   ret i64 0
 }
 
 ; CHECK: define i64 @test5b()
 ; CHECK:     A:
 ; CHECK-NEXT:  %c = call i64 @test5c({ i64, i64 } %a)
 ; CHECK-NEXT:  ret i64 5

llvm/trunk/test/Transforms/SLPVectorizer/X86/ordering.ll

entry:
   %add = fadd double %mul4, %mul8
   %cmp11 = fcmp olt double %add, 0.000000e+00
   ret void
 }
 
 declare i8* @objc_msgSend(i8*, i8*, ...)
 declare i32 @personality_v0(...)
 
-define void @invoketest() {
+define void @invoketest() personality i8* bitcast (i32 (...)* @personality_v0 to i8*) {
 entry:
   br i1 undef, label %cond.true, label %cond.false
 
 cond.true:
   %call49 = invoke double bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to double (i8*, i8*)*)(i8* undef, i8* undef) 
           to label %cond.true54 unwind label %lpad
 
 cond.false:
if.then63:
   %conv70 = fpext float %conv69 to double
   %div71 = fdiv double %cond126, %conv70
   %conv78 = fptrunc double undef to float
   %conv79 = fpext float %conv78 to double
   %div80 = fdiv double %cond61, %conv79
   br label %if.end98
 
 lpad:
-  %l = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @personality_v0 to i8*)
+  %l = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } %l
 
 if.end98:
   %dimensionsResult.sroa.0.0 = phi double [ %div71, %if.then63 ], [ %cond126, %cond.end60 ]
   %dimensionsResult.sroa.6.0 = phi double [ %div80, %if.then63 ], [ %cond61, %cond.end60 ]
   br label %if.end99
 
 if.end99:
   ret void
 }

llvm/trunk/test/Transforms/SLPVectorizer/X86/phi_landingpad.ll

 ; RUN: opt < %s -slp-vectorizer -mtriple=x86_64-apple-macosx10.9.0 -disable-output
 
 target datalayout = "f64:64:64-v64:64:64"
 
-define void @test_phi_in_landingpad() {
+define void @test_phi_in_landingpad() personality i8*
+          bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @foo()
           to label %inner unwind label %lpad
 
 inner:
   %x0 = fsub double undef, undef
   %y0 = fsub double undef, undef
   invoke void @foo()
           to label %done unwind label %lpad
 
 lpad:
   %x1 = phi double [ undef, %entry ], [ undef, %inner ]
   %y1 = phi double [ undef, %entry ], [ undef, %inner ]
-  landingpad { i8*, i32 } personality i8*
-          bitcast (i32 (...)* @__gxx_personality_v0 to i8*) catch i8* null
+  landingpad { i8*, i32 } catch i8* null
   br label %done
 
 done:
   phi double [ %x0, %inner ], [ %x1, %lpad ]
   phi double [ %y0, %inner ], [ %y1, %lpad ]
   ret void
 }
 
 declare void @foo()
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SafeStack/escape-gep-invoke.ll

 ; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s
 ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
 
 %struct.pair = type { i32, i32 }
 
 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
 
 ; Addr-of a struct element passed into an invoke instruction.
 ;   (GEP followed by an invoke)
 ;  safestack attribute
 ; Requires protector.
-define i32 @foo() uwtable safestack {
+define i32 @foo() uwtable safestack personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   ; CHECK: __safestack_unsafe_stack_ptr
   %c = alloca %struct.pair, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   store i32 0, i32* %a, align 4
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   invoke void @_Z3exceptPi(i32* %a1)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ret i32 0
 }
 
 declare void @_Z3exceptPi(i32*)
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SafeStack/invoke.ll

 ; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s
 ; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
 
 @.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
 
 ; Addr-of a variable passed into an invoke instruction.
 ;  safestack attribute
 ; Requires protector and stack restore after landing pad.
-define i32 @foo() uwtable safestack {
+define i32 @foo() uwtable safestack personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   ; CHECK: %[[SP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
   ; CHECK: %[[STATICTOP:.*]] = getelementptr i8, i8* %[[SP]], i32 -16
   %a = alloca i32, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   store i32 0, i32* %a, align 4
   invoke void @_Z3exceptPi(i32* %a)
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 0
 
 lpad:
   ; CHECK: landingpad
   ; CHECK-NEXT: catch
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   ; CHECK-NEXT: store i8* %[[STATICTOP]], i8** @__safestack_unsafe_stack_ptr
   ret i32 0
 }
 
 declare void @_Z3exceptPi(i32*)
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/ScalarRepl/2011-09-22-PHISpeculateInvoke.ll

 ; RUN: opt < %s -scalarrepl -S | FileCheck %s
 ; PR10987
 
 ; Make sure scalarrepl doesn't move a load across an invoke which could
 ; modify the loaded value.
 ; (The PHI could theoretically be transformed by splitting the critical
 ; edge, but scalarrepl doesn't modify the CFG, at least at the moment.)
 
 declare void @extern_fn(i32*)
 declare i32 @extern_fn2(i32)
 declare i32 @__gcc_personality_v0(i32, i64, i8*, i8*)
 
-define void @odd_fn(i1) noinline {
+define void @odd_fn(i1) noinline personality i32 (i32, i64, i8*, i8*)* @__gcc_personality_v0 {
   %retptr1 = alloca i32
   %retptr2 = alloca i32
   br i1 %0, label %then, label %else
 
 then:                                             ; preds = %2
   invoke void @extern_fn(i32* %retptr1)
           to label %join unwind label %unwind
 
 else:                                             ; preds = %2
   store i32 3, i32* %retptr2
   br label %join
 
 join:                                             ; preds = %then, %else
   %storemerge.in = phi i32* [ %retptr2, %else ], [ %retptr1, %then ]
   %storemerge = load i32, i32* %storemerge.in
   %x3 = call i32 @extern_fn2(i32 %storemerge)
   ret void
 
 unwind:                                           ; preds = %then
-  %info = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gcc_personality_v0
+  %info = landingpad { i8*, i32 }
           cleanup
   call void @extern_fn(i32* null)
   unreachable
 }
 
 ; CHECK-LABEL: define void @odd_fn(
 ; CHECK: %storemerge.in = phi i32* [ %retptr2, %else ], [ %retptr1, %then ]

llvm/trunk/test/Transforms/SimplifyCFG/2003-08-05-InvokeCrash.ll

 ; Do not remove the invoke!
 ;
 ; RUN: opt < %s -simplifycfg -disable-output
 
-define i32 @test() {
+define i32 @test() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %A = invoke i32 @test( )
       to label %Ret unwind label %Ret2    ; <i32> [#uses=1]
 Ret:    ; preds = %0
   ret i32 %A
 Ret2:   ; preds = %0
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  catch i8* null
   ret i32 undef
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SimplifyCFG/2005-10-02-InvokeSimplify.ll

 ; RUN: opt < %s -simplifycfg -disable-output
 
-define i1 @foo() {
+define i1 @foo() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %X = invoke i1 @foo( )
       to label %N unwind label %F   ; <i1> [#uses=1]
 F:    ; preds = %0
-        %val = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+        %val = landingpad { i8*, i32 }
                  catch i8* null
   ret i1 false
 N:    ; preds = %0
   br i1 %X, label %A, label %B
 A:    ; preds = %N
   ret i1 true
 B:    ; preds = %N
   ret i1 true
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SimplifyCFG/2007-11-22-InvokeNoUnwind.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 ; CHECK-NOT: invoke
 
 declare i32 @func(i8*) nounwind
 
-define i32 @test() {
+define i32 @test() personality i32 (...)* @__gxx_personality_v0 {
   invoke i32 @func( i8* null )
       to label %Cont unwind label %Other    ; <i32>:1 [#uses=0]
 
 Cont:   ; preds = %0
   ret i32 0
 
 Other:    ; preds = %0
-  landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+  landingpad { i8*, i32 }
     catch i8* null
   ret i32 1
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SimplifyCFG/2010-03-30-InvokeCrash.ll

 ; RUN: opt -simplifycfg -disable-output < %s
 ; END.
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @bar(i32)
 
-define void @foo() {
+define void @foo() personality i32 (...)* @__gxx_personality_v0 {
 entry:
  invoke void @bar(i32 undef)
          to label %r unwind label %u
 
 r:                                                ; preds = %entry
  ret void
 
 u:                                                ; preds = %entry
- %val = landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+ %val = landingpad { i8*, i32 }
           cleanup
  resume { i8*, i32 } %val
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SimplifyCFG/2011-09-05-TrivialLPad.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 ; CHECK-NOT: invoke
 ; CHECK-NOT: landingpad
 
 declare void @bar()
 
-define i32 @foo() {
+define i32 @foo() personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {
 entry:
   invoke void @bar()
           to label %return unwind label %lpad
 
 return:
   ret i32 0
 
 lpad:
-  %lp = landingpad { i8*, i32 } personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0
+  %lp = landingpad { i8*, i32 }
           cleanup
   resume { i8*, i32 } %lp
 }
 
 declare i32 @__gxx_personality_v0(i32, i64, i8*, i8*)

llvm/trunk/test/Transforms/SimplifyCFG/UnreachableEliminate.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 define void @test1(i1 %C, i1* %BP) {
 ; CHECK-LABEL: @test1(
 ; CHECK: entry:
 ; CHECK-NEXT: ret void
 entry:
         br i1 %C, label %T, label %F
 T:
         store i1 %C, i1* %BP
         unreachable
 F:
         ret void
 }
 
-define void @test2() {
+define void @test2() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @test2(
 ; CHECK: entry:
 ; CHECK-NEXT: call void @test2()
 ; CHECK-NEXT: ret void
 entry:
         invoke void @test2( )
                         to label %N unwind label %U
 U:
-  %res = landingpad { i8* } personality i32 (...)* @__gxx_personality_v0
+  %res = landingpad { i8* }
           cleanup
         unreachable
 N:
         ret void
 }
 
 declare i32 @__gxx_personality_v0(...)
 

llvm/trunk/test/Transforms/SimplifyCFG/duplicate-landingpad.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare i32 @__gxx_personality_v0(...)
 declare void @fn()
 
 
 ; CHECK-LABEL: @test1
-define void @test1() {
+define void @test1() personality i32 (...)* @__gxx_personality_v0 {
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: to label %invoke2 unwind label %lpad2
   invoke void @fn()
     to label %invoke2 unwind label %lpad1
 
 invoke2:
 ; CHECK-LABEL: invoke2:
 ; CHECK: to label %invoke.cont unwind label %lpad2
   invoke void @fn()
     to label %invoke.cont unwind label %lpad2
 
 invoke.cont:
   ret void
 
 lpad1:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
          cleanup
   br label %shared_resume
 
 lpad2:
 ; CHECK-LABEL: lpad2:
-; CHECK: landingpad { i8*, i32 } personality i32 (...)* @__gxx_personality_v0
+; CHECK: landingpad { i8*, i32 }
 ; CHECK-NEXT: cleanup
 ; CHECK-NEXT: call void @fn()
 ; CHECK-NEXT: ret void
-  %exn2 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn2 = landingpad {i8*, i32}
           cleanup
   br label %shared_resume
 
 shared_resume:
   call void @fn()
   ret void
 }
 
 ; Don't trigger if blocks aren't the same/empty
-define void @neg1() {
+define void @neg1() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @neg1
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: to label %invoke2 unwind label %lpad1
   invoke void @fn()
     to label %invoke2 unwind label %lpad1
 
 invoke2:
 ; CHECK-LABEL: invoke2:
 ; CHECK: to label %invoke.cont unwind label %lpad2
   invoke void @fn()
     to label %invoke.cont unwind label %lpad2
 
 invoke.cont:
   ret void
 
 lpad1:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
          filter [0 x i8*] zeroinitializer
   call void @fn()
   br label %shared_resume
 
 lpad2:
-  %exn2 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn2 = landingpad {i8*, i32}
           cleanup
   br label %shared_resume
 
 shared_resume:
   call void @fn()
   ret void
 }
 
 ; Should not trigger when the landing pads are not the exact same
-define void @neg2() {
+define void @neg2() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @neg2
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: to label %invoke2 unwind label %lpad1
   invoke void @fn()
     to label %invoke2 unwind label %lpad1
 
 invoke2:
 ; CHECK-LABEL: invoke2:
 ; CHECK: to label %invoke.cont unwind label %lpad2
   invoke void @fn()
     to label %invoke.cont unwind label %lpad2
 
 invoke.cont:
   ret void
 
 lpad1:
-  %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn = landingpad {i8*, i32}
          filter [0 x i8*] zeroinitializer
   br label %shared_resume
 
 lpad2:
-  %exn2 = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+  %exn2 = landingpad {i8*, i32}
           cleanup
   br label %shared_resume
 
 shared_resume:
   call void @fn()
   ret void
 }

llvm/trunk/test/Transforms/SimplifyCFG/invoke.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 declare i32 @__gxx_personality_v0(...)
 declare void @__cxa_call_unexpected(i8*)
 declare void @purefn() nounwind readnone
 declare i32 @read_only() nounwind readonly
 declare i32 @nounwind_fn() nounwind
 declare i32 @fn()
 
 
 ; CHECK-LABEL: @f1(
-define i8* @f1() nounwind uwtable ssp {
+define i8* @f1() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: call void @llvm.trap()
 ; CHECK: unreachable
   %call = invoke noalias i8* undef()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i8* %call
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @__cxa_call_unexpected(i8* %1) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f2(
-define i8* @f2() nounwind uwtable ssp {
+define i8* @f2() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: call void @llvm.trap()
 ; CHECK: unreachable
   %call = invoke noalias i8* null()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i8* %call
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @__cxa_call_unexpected(i8* %1) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f3(
-define i32 @f3() nounwind uwtable ssp {
+define i32 @f3() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT: entry
 entry:
 ; CHECK-NEXT: ret i32 3
   %call = invoke i32 @read_only()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
   ret i32 3
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @__cxa_call_unexpected(i8* %1) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f4(
-define i32 @f4() nounwind uwtable ssp {
+define i32 @f4() nounwind uwtable ssp personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-NEXT: entry
 entry:
 ; CHECK-NEXT: call i32 @read_only()
   %call = invoke i32 @read_only()
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:
 ; CHECK-NEXT: ret i32 %call
   ret i32 %call
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   %1 = extractvalue { i8*, i32 } %0, 0
   tail call void @__cxa_call_unexpected(i8* %1) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f5(
-define i32 @f5(i1 %cond, i8* %a, i8* %b) {
+define i32 @f5(i1 %cond, i8* %a, i8* %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   br i1 %cond, label %x, label %y
 
 x:
 ; CHECK: invoke i32 @fn()
   %call = invoke i32 @fn()
           to label %cont unwind label %lpad
 
 y:
 ; CHECK: call i32 @nounwind_fn()
   %call2 = invoke i32 @nounwind_fn()
            to label %cont unwind label %lpad
 
 cont:
 ; CHECK: phi i32
 ; CHECK: ret i32 %phi
   %phi = phi i32 [%call, %x], [%call2, %y]
   ret i32 %phi
 
 lpad:
 ; CHECK-NOT: phi
   %phi2 = phi i8* [%a, %x], [%b, %y]
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
 ; CHECK: __cxa_call_unexpected(i8* %a)
   tail call void @__cxa_call_unexpected(i8* %phi2) noreturn nounwind
   unreachable
 }
 
 ; CHECK-LABEL: @f6(
-define void @f6() {
+define void @f6() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @purefn()
           to label %invoke.cont1 unwind label %lpad
 
 invoke.cont1:
   %foo = invoke i32 @fn()
           to label %invoke.cont2 unwind label %lpad
 
 invoke.cont2:
   ret void
 
 lpad:
 ; CHECK-NOT: phi
   %tmp = phi i8* [ null, %invoke.cont1 ], [ null, %entry ]
-  landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  landingpad { i8*, i32 }
           cleanup
   ret void
 }

llvm/trunk/test/Transforms/SimplifyCFG/invoke_unwind.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 
 declare void @bar()
 
 ; This testcase checks to see if the simplifycfg pass is converting invoke
 ; instructions to call instructions if the handler just rethrows the exception.
-define i32 @test1() {
+define i32 @test1() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT: call void @bar()
 ; CHECK-NEXT: ret i32 0
         invoke void @bar( )
                         to label %1 unwind label %Rethrow
         ret i32 0
 Rethrow:
-        %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
+        %exn = landingpad {i8*, i32}
                  catch i8* null
         resume { i8*, i32 } %exn
 }
 
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Transforms/SimplifyCFG/seh-nounwind.ll

 ; RUN: opt -S -simplifycfg < %s | FileCheck %s
 
 ; Don't remove invokes of nounwind functions if the personality handles async
 ; exceptions. The @div function in this test can fault, even though it can't
 ; throw a synchronous exception.
 
 define i32 @div(i32 %n, i32 %d) nounwind {
 entry:
   %div = sdiv i32 %n, %d
   ret i32 %div
 }
 
-define i32 @main() nounwind {
+define i32 @main() nounwind personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   %call = invoke i32 @div(i32 10, i32 0)
           to label %__try.cont unwind label %lpad
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*)
+  %0 = landingpad { i8*, i32 }
           catch i8* null
   br label %__try.cont
 
 __try.cont:
   %retval.0 = phi i32 [ %call, %entry ], [ 0, %lpad ]
   ret i32 %retval.0
 }
 
 ; CHECK-LABEL: define i32 @main()
 ; CHECK: invoke i32 @div(i32 10, i32 0)
 
 declare i32 @__C_specific_handler(...)

llvm/trunk/test/Transforms/SimplifyCFG/statepoint-invoke-unwind.ll

 ; RUN: opt < %s -simplifycfg -S | FileCheck %s
 ; Test that statepoint intrinsic is marked with Throwable attribute and it is
 ; not optimized into call
 
 declare i64 addrspace(1)* @gc_call()
 declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64f(i64, i32, i64 addrspace(1)* ()*, i32, i32, ...)
 declare i32* @fake_personality_function()
 
-define i32 @test() gc "statepoint-example" {
+define i32 @test() gc "statepoint-example" personality i32* ()* @fake_personality_function {
 ; CHECK-LABEL: test
 entry:
   ; CHECK-LABEL: entry:
   ; CHECK-NEXT: %sp = invoke i32 (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f
   %sp = invoke i32 (i64, i32, i64 addrspace(1)* ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 0, i32 0, i64 addrspace(1)* ()* @gc_call, i32 0, i32 0, i32 0, i32 0)
                 to label %normal unwind label %exception
 
 exception:
-  %lpad = landingpad { i8*, i32 } personality i32* ()* @fake_personality_function
+  %lpad = landingpad { i8*, i32 }
           cleanup
   ret i32 0
 
 normal:
   ret i32 1
 }

llvm/trunk/test/Verifier/dominates.ll

 ; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
 
 define i32 @f1(i32 %x) {
        %y = add i32 %z, 1
        %z = add i32 %x, 1
        ret i32 %y
 ; CHECK: Instruction does not dominate all uses!
 ; CHECK-NEXT:  %z = add i32 %x, 1
 ; CHECK-NEXT:  %y = add i32 %z, 1
 }
 
 declare i32 @g()
-define void @f2(i32 %x) {
+define void @f2(i32 %x) personality i32 ()* @g {
 bb0:
   %y1 = invoke i32 @g() to label %bb1 unwind label %bb2
 bb1:
   ret void
 bb2:
   %y2 = phi i32 [%y1, %bb0]
-  %y3 = landingpad i32 personality i32 ()* @g
+  %y3 = landingpad i32
           cleanup
   ret void
 ; CHECK: Instruction does not dominate all uses!
 ; CHECK-NEXT:  %y1 = invoke i32 @g()
 ; CHECK-NEXT:        to label %bb1 unwind label %bb2
 ; CHECK-NEXT:  %y2 = phi i32 [ %y1, %bb0 ]
 }
 
-define void @f3(i32 %x) {
+define void @f3(i32 %x) personality i32 ()* @g {
 bb0:
   %y1 = invoke i32 @g() to label %bb1 unwind label %bb2
 bb1:
   ret void
 bb2:
-  %y2 = landingpad i32 personality i32 ()* @g
+  %y2 = landingpad i32
           cleanup
   br label %bb3
 bb3:
   %y3 = phi i32 [%y1, %bb2]
   ret void
 ; CHECK: Instruction does not dominate all uses!
 ; CHECK-NEXT:  %y1 = invoke i32 @g()
 ; CHECK-NEXT:          to label %bb1 unwind label %bb2

llvm/trunk/test/Verifier/invoke.ll

 
 
 declare i32 @__gxx_personality_v0(...)
 declare void @llvm.donothing()
 declare void @llvm.trap()
 declare i8 @llvm.expect.i8(i8,i8)
 declare i32 @fn(i8 (i8, i8)*)
 
-define void @f1() {
+define void @f1() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; OK
   invoke void @llvm.donothing()
   to label %conta unwind label %contb
 
 conta:
   ret void
 
 contb:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret void
 }
 
-define i8 @f2() {
+define i8 @f2() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
 ; CHECK: Cannot invoke an intrinsinc other than donothing or patchpoint
   invoke void @llvm.trap()
   to label %cont unwind label %lpad
 
 cont:
   ret i8 3
 
 lpad:
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret i8 2
 }
 
 define i32 @f3() {
 entry:
 ; CHECK: Cannot take the address of an intrinsic
   %call = call i32 @fn(i8 (i8, i8)* @llvm.expect.i8)
   ret i32 %call
 }
 
-define void @f4() {
+define void @f4() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   invoke void @llvm.donothing()
   to label %cont unwind label %cont
 
 cont:
 ; CHECK: Block containing LandingPadInst must be jumped to only by the unwind edge of an invoke.
-  %0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %0 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret void
 }

llvm/trunk/test/Verifier/range-2.ll

entry:
   %v2 = call i8 @f2(i8* %x), !range !1
   %v3 = call i8 @f3(i8* %x), !range !2
   %v4 = call i8 @f4(i8* %x), !range !3
   %v5 = call i8 @f5(i8* %x), !range !4
   ret void
 }
 
 ; We can annotate the range of the return value of an INVOKE.
-define void @invoke_all(i8* %x) {
+define void @invoke_all(i8* %x) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %v1 = invoke i8 @f1(i8* %x) to label %cont unwind label %lpad, !range !0
   %v2 = invoke i8 @f2(i8* %x) to label %cont unwind label %lpad, !range !1
   %v3 = invoke i8 @f3(i8* %x) to label %cont unwind label %lpad, !range !2
   %v4 = invoke i8 @f4(i8* %x) to label %cont unwind label %lpad, !range !3
   %v5 = invoke i8 @f5(i8* %x) to label %cont unwind label %lpad, !range !4
 
 cont:
   ret void
 
 lpad:
-  %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*)
+  %4 = landingpad { i8*, i32 }
           filter [0 x i8*] zeroinitializer
   ret void
 }
 declare i32 @__gxx_personality_v0(...)

llvm/trunk/test/Verifier/statepoint.ll

 ; CHECK-LABEL: equal
 ; CHECK: statepoint
 ; CHECK-NEXT: %reloc = call 
 ; CHECK-NEXT: call
 ; CHECK-NEXT: ret voi
 }
 
 ; Basic test for invoke statepoints
-define i8 addrspace(1)* @test3(i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1) gc "statepoint-example" {
+define i8 addrspace(1)* @test3(i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @"personality_function" {
 ; CHECK-LABEL: test3
 entry:
   ; CHECK-LABEL: entry
   ; CHECK: statepoint
   %0 = invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1)
           to label %normal_dest unwind label %exceptional_return
 
 normal_dest:
   ; CHECK-LABEL: normal_dest:
   ; CHECK: gc.relocate
   ; CHECK: gc.relocate
   ; CHECK: ret
   %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 12, i32 12)
   %obj1.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 12, i32 12)
   ret i8 addrspace(1)* %obj.relocated
 
 exceptional_return:
   ; CHECK-LABEL: exceptional_return
   ; CHECK: gc.relocate
   ; CHECK: gc.relocate
-  %landing_pad = landingpad { i8*, i32 } personality i32 ()* @"personality_function"
+  %landing_pad = landingpad { i8*, i32 }
           cleanup
   %relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
   %obj.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 12, i32 12)
   %obj1.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 12, i32 12)
   ret i8 addrspace(1)* %obj1.relocated1
 }

llvm/trunk/tools/verify-uselistorder/verify-uselistorder.cpp

if (G.hasInitializer())
       map(G.getInitializer());
   for (const GlobalAlias &A : M.aliases())
     map(A.getAliasee());
   for (const Function &F : M) {
     if (F.hasPrefixData())
       map(F.getPrefixData());
     if (F.hasPrologueData())
       map(F.getPrologueData());
+    if (F.hasPersonalityFn())
+      map(F.getPersonalityFn());
   }
 
   // Function bodies.
   for (const Function &F : M) {
     for (const Argument &A : F.args())
       map(&A);
     for (const BasicBlock &BB : F)
       map(&BB);
if (G.hasInitializer())
       changeValueUseList(G.getInitializer());
   for (GlobalAlias &A : M.aliases())
     changeValueUseList(A.getAliasee());
   for (Function &F : M) {
     if (F.hasPrefixData())
       changeValueUseList(F.getPrefixData());
     if (F.hasPrologueData())
       changeValueUseList(F.getPrologueData());
+    if (F.hasPersonalityFn())
+      changeValueUseList(F.getPersonalityFn());
   }
 
   // Function bodies.
   for (Function &F : M) {
     for (Argument &A : F.args())
       changeValueUseList(&A);
     for (BasicBlock &BB : F)
       changeValueUseList(&BB);

llvm/trunk/unittests/IR/DominatorTreeTest.cpp

struct DPass : public FunctionPass {
         initializeDPassPass(*PassRegistry::getPassRegistry());
       }
     };
     char DPass::ID = 0;
 
     std::unique_ptr<Module> makeLLVMModule(DPass *P) {
       const char *ModuleStrig =
         "declare i32 @g()\n" \
-        "define void @f(i32 %x) {\n" \
+        "define void @f(i32 %x) personality i32 ()* @g {\n" \
         "bb0:\n" \
         "  %y1 = add i32 %x, 1\n" \
         "  %y2 = add i32 %x, 1\n" \
         "  %y3 = invoke i32 @g() to label %bb1 unwind label %bb2\n" \
         "bb1:\n" \
         "  %y4 = add i32 %x, 1\n" \
         "  br label %bb4\n" \
         "bb2:\n" \
-        "  %y5 = landingpad i32 personality i32 ()* @g\n" \
+        "  %y5 = landingpad i32\n" \
         "          cleanup\n" \
         "  br label %bb4\n" \
         "bb3:\n" \
         "  %y6 = add i32 %x, 1\n" \
         "  %y7 = add i32 %x, 1\n" \
         "  ret void\n" \
         "bb4:\n" \
         "  %y8 = phi i32 [0, %bb2], [%y4, %bb1]\n"

llvm/trunk/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, CreateCondBr) {
   EXPECT_EQ(2u, TI->getNumSuccessors());
   EXPECT_EQ(TBB, TI->getSuccessor(0));
   EXPECT_EQ(FBB, TI->getSuccessor(1));
   EXPECT_EQ(Weights, TI->getMetadata(LLVMContext::MD_prof));
 }
 
 TEST_F(IRBuilderTest, LandingPadName) {
   IRBuilder<> Builder(BB);
-  LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(),
-                                                Builder.getInt32(0), 0, "LP");
+  LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(), 0, "LP");
   EXPECT_EQ(LP->getName(), "LP");
 }
 
 TEST_F(IRBuilderTest, DataLayout) {
   std::unique_ptr<Module> M(new Module("test", Ctx));
   M->setDataLayout("e-n32");
   EXPECT_TRUE(M->getDataLayout().isLegalInteger(32));
   M->setDataLayout("e");