Move the personality function from LandingPadInst to Function
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. Differential Revision: http://reviews.llvm.org/D10429 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@239940 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
4412d4b51f
commit
cc714e2142
|
@ -741,7 +741,7 @@ global variable. The operand fields are:
|
|||
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:
|
||||
|
@ -795,6 +795,8 @@ function. The operand fields are:
|
|||
* *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
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
|
@ -635,8 +635,9 @@ 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
|
||||
|
@ -683,7 +684,8 @@ Syntax::
|
|||
[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
|
||||
|
@ -1130,6 +1132,14 @@ 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
|
||||
|
@ -7283,8 +7293,8 @@ 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>
|
||||
|
@ -7296,14 +7306,13 @@ 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
|
||||
|
@ -7318,7 +7327,7 @@ 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.
|
||||
|
@ -7341,8 +7350,6 @@ The ``landingpad`` instruction has several restrictions:
|
|||
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:
|
||||
""""""""
|
||||
|
@ -7350,13 +7357,13 @@ 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]
|
||||
|
||||
|
|
|
@ -206,7 +206,7 @@ class InvokeInst;
|
|||
llvm_unreachable("invalid enum");
|
||||
}
|
||||
|
||||
bool canSimplifyInvokeNoUnwind(const InvokeInst *II);
|
||||
bool canSimplifyInvokeNoUnwind(const Function *F);
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
|
|
|
@ -342,7 +342,7 @@ namespace bitc {
|
|||
// 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
|
||||
|
@ -352,6 +352,7 @@ namespace bitc {
|
|||
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 {
|
||||
|
|
|
@ -25,6 +25,7 @@
|
|||
#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 {
|
||||
|
@ -119,11 +120,22 @@ private:
|
|||
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
|
||||
|
||||
|
@ -601,6 +613,11 @@ 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
|
||||
|
|
|
@ -1556,9 +1556,9 @@ public:
|
|||
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);
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
|
|
@ -2437,34 +2437,27 @@ private:
|
|||
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.
|
||||
|
@ -2482,21 +2475,21 @@ public:
|
|||
/// 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.
|
||||
|
@ -2512,7 +2505,7 @@ public:
|
|||
};
|
||||
|
||||
template <>
|
||||
struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<2> {
|
||||
struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
|
||||
};
|
||||
|
||||
DEFINE_TRANSPARENT_OPERAND_ACCESSORS(LandingPadInst, Value)
|
||||
|
|
|
@ -150,6 +150,19 @@ public:
|
|||
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.
|
||||
|
|
|
@ -80,9 +80,8 @@ EHPersonality llvm::classifyEHPersonality(const Value *Pers) {
|
|||
.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.
|
||||
|
|
|
@ -4057,7 +4057,7 @@ bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
|
|||
/// 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();
|
||||
|
@ -4139,6 +4139,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
|
|||
LocTy UnnamedAddrLoc;
|
||||
Constant *Prefix = nullptr;
|
||||
Constant *Prologue = nullptr;
|
||||
Constant *PersonalityFn = nullptr;
|
||||
Comdat *C;
|
||||
|
||||
if (ParseArgumentList(ArgList, isVarArg) ||
|
||||
|
@ -4155,7 +4156,9 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
|
|||
(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))
|
||||
|
@ -4254,6 +4257,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
|
|||
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);
|
||||
|
@ -5105,14 +5109,11 @@ int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
|
|||
/// ::= '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){
|
||||
|
|
|
@ -150,6 +150,7 @@ class BitcodeReader : public GVMaterializer {
|
|||
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;
|
||||
|
||||
|
@ -2031,11 +2032,13 @@ std::error_code BitcodeReader::resolveGlobalAndAliasInits() {
|
|||
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;
|
||||
|
@ -2093,6 +2096,19 @@ std::error_code BitcodeReader::resolveGlobalAndAliasInits() {
|
|||
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();
|
||||
}
|
||||
|
||||
|
@ -3023,6 +3039,9 @@ std::error_code BitcodeReader::parseModule(bool Resume,
|
|||
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
|
||||
|
@ -3976,21 +3995,35 @@ std::error_code BitcodeReader::parseFunctionBody(Function *F) {
|
|||
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 (Record.size() < 4)
|
||||
return error("Invalid record");
|
||||
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");
|
||||
Value *PersFn = nullptr;
|
||||
if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
|
||||
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 =
|
||||
|
|
|
@ -695,7 +695,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
|
|||
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());
|
||||
|
@ -712,6 +712,8 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
|
|||
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);
|
||||
|
@ -1859,7 +1861,6 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
|
|||
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) {
|
||||
|
|
|
@ -93,6 +93,9 @@ static OrderMap orderModule(const Module &M) {
|
|||
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();
|
||||
|
||||
|
@ -274,6 +277,8 @@ static UseListOrderStack predictUseListOrder(const Module &M) {
|
|||
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;
|
||||
|
@ -326,6 +331,11 @@ ValueEnumerator::ValueEnumerator(const Module &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
|
||||
|
|
|
@ -548,6 +548,10 @@ void AsmPrinter::EmitFunctionHeader() {
|
|||
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();
|
||||
|
|
|
@ -181,27 +181,22 @@ size_t DwarfEHPrepare::pruneUnreachableResumes(
|
|||
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);
|
||||
|
|
|
@ -259,8 +259,8 @@ void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
|
|||
|
||||
// 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;
|
||||
|
||||
|
@ -546,8 +546,10 @@ void llvm::ComputeUsesVAFloatArgument(const CallInst &I,
|
|||
/// 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);
|
||||
|
|
|
@ -938,8 +938,10 @@ bool SelectionDAGISel::PrepareEHLandingPad() {
|
|||
// 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)) {
|
||||
|
|
|
@ -144,10 +144,14 @@ public:
|
|||
BasicBlock *CleanupBB = BasicBlock::Create(C, CleanupBBName, &F);
|
||||
Type *ExnTy =
|
||||
StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C), nullptr);
|
||||
Constant *PersFn = F.getParent()->getOrInsertFunction(
|
||||
"__gcc_personality_v0", FunctionType::get(Type::getInt32Ty(C), true));
|
||||
if (!F.hasPersonalityFn()) {
|
||||
Constant *PersFn = F.getParent()->getOrInsertFunction(
|
||||
"__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);
|
||||
|
||||
|
|
|
@ -227,7 +227,7 @@ Value *SjLjEHPrepare::setupFunctionContext(Function &F,
|
|||
// 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(
|
||||
|
|
|
@ -111,7 +111,7 @@ private:
|
|||
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,
|
||||
|
@ -379,7 +379,7 @@ bool WinEHPrepare::runOnFunction(Function &Fn) {
|
|||
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))
|
||||
|
@ -1265,8 +1265,7 @@ static bool isCatchBlock(BasicBlock *BB) {
|
|||
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");
|
||||
|
@ -1275,7 +1274,7 @@ static BasicBlock *createStubLandingPad(Function *Handler,
|
|||
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);
|
||||
|
@ -1290,8 +1289,7 @@ static BasicBlock *createStubLandingPad(Function *Handler,
|
|||
// 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) {
|
||||
|
@ -1323,7 +1321,7 @@ void WinEHPrepare::addStubInvokeToHandlerIfNeeded(Function *Handler,
|
|||
// 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);
|
||||
|
@ -1379,6 +1377,7 @@ bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
|
|||
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();
|
||||
|
@ -1456,7 +1455,7 @@ bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
|
|||
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 =
|
||||
|
|
|
@ -109,6 +109,10 @@ static OrderMap orderModule(const Module *M) {
|
|||
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())
|
||||
|
@ -2540,6 +2544,10 @@ void AssemblyWriter::printFunction(const Function *F) {
|
|||
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);
|
||||
|
@ -2782,8 +2790,8 @@ void AssemblyWriter::printInstruction(const Instruction &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";
|
||||
|
|
|
@ -2249,11 +2249,8 @@ LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
|
|||
}
|
||||
|
||||
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) {
|
||||
|
|
|
@ -248,8 +248,8 @@ void Function::eraseFromParent() {
|
|||
|
||||
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");
|
||||
|
@ -279,6 +279,9 @@ Function::~Function() {
|
|||
|
||||
// Remove the function from the on-the-side GC table.
|
||||
clearGC();
|
||||
|
||||
// FIXME: needed by operator delete
|
||||
setFunctionNumOperands(1);
|
||||
}
|
||||
|
||||
void Function::BuildLazyArguments() const {
|
||||
|
@ -331,6 +334,8 @@ void Function::dropAllReferences() {
|
|||
|
||||
// Metadata is stored in a side-table.
|
||||
clearMetadata();
|
||||
|
||||
setPersonalityFn(nullptr);
|
||||
}
|
||||
|
||||
void Function::addAttribute(unsigned i, Attribute::AttrKind attr) {
|
||||
|
@ -426,6 +431,10 @@ void Function::copyAttributesFrom(const GlobalValue *Src) {
|
|||
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
|
||||
|
@ -976,3 +985,22 @@ Optional<uint64_t> Function::getEntryCount() const {
|
|||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -153,18 +153,16 @@ Value *PHINode::hasConstantValue() const {
|
|||
// LandingPadInst Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn,
|
||||
unsigned NumReservedValues, const Twine &NameStr,
|
||||
Instruction *InsertBefore)
|
||||
: Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
|
||||
init(PersonalityFn, 1 + NumReservedValues, NameStr);
|
||||
LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
|
||||
const Twine &NameStr, Instruction *InsertBefore)
|
||||
: Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
|
||||
init(NumReservedValues, NameStr);
|
||||
}
|
||||
|
||||
LandingPadInst::LandingPadInst(Type *RetTy, Value *PersonalityFn,
|
||||
unsigned NumReservedValues, const Twine &NameStr,
|
||||
BasicBlock *InsertAtEnd)
|
||||
: Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) {
|
||||
init(PersonalityFn, 1 + NumReservedValues, NameStr);
|
||||
LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
|
||||
const Twine &NameStr, BasicBlock *InsertAtEnd)
|
||||
: Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) {
|
||||
init(NumReservedValues, NameStr);
|
||||
}
|
||||
|
||||
LandingPadInst::LandingPadInst(const LandingPadInst &LP)
|
||||
|
@ -180,28 +178,22 @@ LandingPadInst::LandingPadInst(const LandingPadInst &LP)
|
|||
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);
|
||||
}
|
||||
|
@ -211,7 +203,7 @@ void LandingPadInst::init(Value *PersFn, unsigned NumReservedValues,
|
|||
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);
|
||||
}
|
||||
|
||||
|
|
|
@ -50,6 +50,9 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
|
|||
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)
|
||||
|
|
|
@ -181,11 +181,6 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
|
|||
/// \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;
|
||||
|
@ -196,8 +191,7 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
|
|||
|
||||
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();
|
||||
|
@ -231,7 +225,6 @@ public:
|
|||
// FIXME: We strip const here because the inst visitor strips const.
|
||||
visit(const_cast<Function &>(F));
|
||||
InstsInThisBlock.clear();
|
||||
PersonalityFn = nullptr;
|
||||
SawFrameEscape = false;
|
||||
|
||||
return !Broken;
|
||||
|
@ -1757,6 +1750,8 @@ void Verifier::visitFunction(const Function &F) {
|
|||
"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.
|
||||
|
@ -2795,22 +2790,16 @@ void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
|
|||
&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)) {
|
||||
|
|
|
@ -1194,6 +1194,11 @@ bool ModuleLinker::linkFunctionBody(Function &Dst, Function &Src) {
|
|||
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()) {
|
||||
|
|
|
@ -146,16 +146,10 @@ bool WinEHStatePass::runOnFunction(Function &F) {
|
|||
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);
|
||||
|
|
|
@ -228,6 +228,9 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
|
|||
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)
|
||||
|
|
|
@ -177,7 +177,7 @@ 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);
|
||||
|
|
|
@ -2353,7 +2353,8 @@ 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).
|
||||
|
@ -2620,7 +2621,6 @@ Instruction *InstCombiner::visitLandingPadInst(LandingPadInst &LI) {
|
|||
// 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]);
|
||||
|
@ -2691,7 +2691,8 @@ bool InstCombiner::run() {
|
|||
}
|
||||
|
||||
// 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');
|
||||
|
||||
|
@ -2846,7 +2847,8 @@ static bool AddReachableCodeToWorklist(BasicBlock *BB, const DataLayout &DL,
|
|||
}
|
||||
|
||||
// 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');
|
||||
|
|
|
@ -949,35 +949,23 @@ bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
|
|||
}
|
||||
|
||||
// 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);
|
||||
// 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.
|
||||
else if (CalledPersonality != CallerPersonality)
|
||||
return false;
|
||||
}
|
||||
|
||||
// Get an iterator to the last basic block in the function, which will have
|
||||
|
|
|
@ -1173,10 +1173,11 @@ static void changeToCall(InvokeInst *II) {
|
|||
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;
|
||||
|
@ -1247,7 +1248,7 @@ static bool markAliveBlocks(BasicBlock *BB,
|
|||
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);
|
||||
|
@ -1272,7 +1273,7 @@ static bool markAliveBlocks(BasicBlock *BB,
|
|||
/// 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())
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
; 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
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
; 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()
|
||||
|
@ -10,7 +10,7 @@ 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
|
||||
}
|
||||
|
|
|
@ -63,7 +63,7 @@ entry:
|
|||
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
|
||||
|
@ -97,7 +97,7 @@ 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 }
|
||||
}
|
||||
|
|
|
@ -12,13 +12,13 @@ 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
|
||||
|
@ -43,7 +43,7 @@ eh.resume: ; preds = %catch.dispatch
|
|||
}
|
||||
|
||||
; 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
|
||||
|
@ -53,7 +53,7 @@ invoke.cont:
|
|||
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
|
||||
|
@ -65,7 +65,7 @@ lpad: ; preds = %entry
|
|||
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
|
||||
|
|
|
@ -13,7 +13,7 @@ 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:
|
||||
|
@ -21,7 +21,7 @@ entry:
|
|||
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
|
||||
|
@ -45,7 +45,7 @@ eh.resume: ; preds = %catch.dispatch
|
|||
}
|
||||
|
||||
; 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:
|
||||
|
@ -53,7 +53,7 @@ entry:
|
|||
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
|
||||
|
@ -77,7 +77,7 @@ eh.resume: ; preds = %catch.dispatch
|
|||
}
|
||||
|
||||
; 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)
|
||||
|
@ -86,7 +86,7 @@ entry:
|
|||
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
|
||||
|
@ -112,7 +112,7 @@ eh.resume: ; preds = %catch.dispatch
|
|||
}
|
||||
|
||||
; 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()
|
||||
|
@ -121,7 +121,7 @@ entry:
|
|||
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
|
||||
|
@ -166,7 +166,7 @@ try.cont: ; preds = %invoke.cont2, %entr
|
|||
}
|
||||
|
||||
; 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:
|
||||
|
@ -175,7 +175,7 @@ entry:
|
|||
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
|
||||
|
@ -211,7 +211,7 @@ eh.resume: ; preds = %catch.dispatch
|
|||
}
|
||||
|
||||
; 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:
|
||||
|
@ -223,7 +223,7 @@ invoke.cont:
|
|||
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
|
||||
|
@ -235,7 +235,7 @@ lpad: ; preds = %entry
|
|||
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
|
||||
|
|
|
@ -2,6 +2,6 @@
|
|||
|
||||
; 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
|
||||
}
|
||||
|
|
|
@ -13,27 +13,33 @@ 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
|
||||
|
|
|
@ -14,13 +14,13 @@
|
|||
; }
|
||||
;}
|
||||
|
||||
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
|
||||
|
@ -35,7 +35,7 @@ try.cont: ; preds = %entry, %invoke.cont
|
|||
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
|
||||
|
@ -44,7 +44,7 @@ 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
|
||||
|
|
|
@ -7,12 +7,12 @@
|
|||
; 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
|
||||
|
@ -46,7 +46,7 @@ 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
|
||||
|
||||
|
|
|
@ -21,13 +21,13 @@
|
|||
|
||||
@_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
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
%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*
|
||||
|
@ -39,7 +39,7 @@ 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
|
||||
|
|
|
@ -40,7 +40,7 @@ entry:
|
|||
|
||||
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]
|
||||
|
@ -71,7 +71,7 @@ try.cont: ; preds = %lpad
|
|||
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
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
; 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]
|
||||
|
@ -34,7 +34,7 @@ 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
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
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
|
||||
|
||||
|
@ -35,13 +35,13 @@ 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
|
||||
|
@ -57,7 +57,7 @@ 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
|
||||
|
@ -67,7 +67,7 @@ eh.resume:
|
|||
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
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
%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
|
||||
|
@ -37,7 +37,7 @@ 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
|
||||
|
|
|
@ -25,13 +25,13 @@ 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
|
||||
|
||||
|
@ -47,7 +47,7 @@ try.cont: ; preds = %invoke.cont2, %entr
|
|||
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
|
||||
|
@ -56,7 +56,7 @@ 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
|
||||
}
|
||||
|
|
|
@ -8,13 +8,13 @@ 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
|
||||
|
|
|
@ -4,13 +4,13 @@
|
|||
@_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
|
||||
|
|
|
@ -14,13 +14,13 @@
|
|||
; }
|
||||
;}
|
||||
|
||||
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
|
||||
|
@ -35,7 +35,7 @@ try.cont: ; preds = %entry, %invoke.cont
|
|||
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
|
||||
|
@ -44,7 +44,7 @@ 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
|
||||
|
|
|
@ -74,7 +74,7 @@ bb:
|
|||
%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
|
||||
|
||||
|
@ -83,7 +83,7 @@ false:
|
|||
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
|
||||
|
||||
|
|
|
@ -34,14 +34,13 @@ 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)
|
||||
|
@ -58,7 +57,6 @@ try.cont:
|
|||
|
||||
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
|
||||
|
@ -68,7 +66,6 @@ eh.resume:
|
|||
|
||||
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)
|
||||
|
|
|
@ -73,14 +73,13 @@ 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)
|
||||
|
@ -97,7 +96,6 @@ try.cont:
|
|||
|
||||
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
|
||||
|
@ -107,7 +105,6 @@ eh.resume:
|
|||
|
||||
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)
|
||||
|
|
|
@ -17,7 +17,7 @@ target triple = "armv5e--netbsd-eabi"
|
|||
@_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
|
||||
|
@ -26,7 +26,7 @@ define void @f() uwtable {
|
|||
|
||||
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,7 +7,7 @@
|
|||
|
||||
@_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*
|
||||
|
@ -16,7 +16,7 @@ entry:
|
|||
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
|
||||
|
|
|
@ -5,7 +5,7 @@ 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
|
||||
|
@ -14,7 +14,7 @@ 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
|
||||
}
|
||||
|
|
|
@ -14,7 +14,7 @@ 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
|
||||
|
@ -24,7 +24,7 @@ entry:
|
|||
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
|
||||
|
@ -45,7 +45,7 @@ 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
|
||||
|
||||
|
|
|
@ -25,12 +25,12 @@ 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)
|
||||
|
|
|
@ -23,12 +23,12 @@ 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)
|
||||
|
|
|
@ -89,14 +89,13 @@ 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)
|
||||
|
@ -113,7 +112,6 @@ try.cont:
|
|||
|
||||
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
|
||||
|
@ -123,7 +121,6 @@ eh.resume:
|
|||
|
||||
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)
|
||||
|
|
|
@ -15,13 +15,13 @@
|
|||
; 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*))
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
@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
|
||||
|
@ -12,7 +12,7 @@ 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
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
; <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
|
||||
|
@ -20,12 +20,12 @@ 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
|
||||
|
||||
|
@ -34,7 +34,7 @@ eh.resume:
|
|||
}
|
||||
|
||||
; 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
|
||||
|
@ -58,7 +58,7 @@ _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
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
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()
|
||||
|
@ -17,14 +17,14 @@ for.cond: ; preds = %entry, %for.cond
|
|||
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
|
||||
|
@ -32,7 +32,7 @@ lpad5: ; preds = %for.cond
|
|||
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
|
||||
|
@ -45,7 +45,7 @@ ehcleanup: ; preds = %lpad5, %lpad
|
|||
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
|
||||
|
@ -90,7 +90,7 @@ declare void @terminatev()
|
|||
|
||||
@.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)
|
||||
|
@ -131,14 +131,14 @@ invoke.cont6: ; preds = %_ZNSt3__113__vector
|
|||
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
|
||||
|
@ -161,7 +161,7 @@ eh.resume: ; preds = %ehcleanup
|
|||
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)
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
; __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]*}}:
|
||||
|
@ -22,7 +22,7 @@ unreachable:
|
|||
unreachable
|
||||
|
||||
handler:
|
||||
%tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @baz to i8*)
|
||||
%tmp = landingpad { i8*, i32 }
|
||||
cleanup
|
||||
resume { i8*, i32 } undef
|
||||
}
|
||||
|
|
|
@ -3,12 +3,12 @@
|
|||
; 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
|
||||
}
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
%"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
|
||||
|
@ -45,7 +45,7 @@ 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
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
; 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
|
||||
|
@ -9,7 +9,7 @@ entry:
|
|||
ret void
|
||||
|
||||
cleanup144: ; preds = %entry
|
||||
%exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
|
||||
%exn = landingpad {i8*, i32}
|
||||
cleanup
|
||||
resume { i8*, i32 } %exn
|
||||
}
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
%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
|
||||
|
@ -14,13 +14,13 @@ 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
|
||||
|
||||
|
|
|
@ -19,7 +19,7 @@ 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]
|
||||
|
@ -62,14 +62,14 @@ invcont38: ; preds = %invcont25, %bb1.i,
|
|||
|
||||
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
|
||||
}
|
||||
|
|
|
@ -5,7 +5,7 @@ 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()
|
||||
|
@ -15,7 +15,7 @@ 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
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
; 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"
|
||||
|
||||
|
@ -19,7 +19,7 @@ _ZN6Gambit5ArrayIiEC2Ej.exit36:
|
|||
|
||||
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
|
||||
}
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
; 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:
|
||||
|
@ -13,7 +13,7 @@ normal:
|
|||
ret void
|
||||
|
||||
handler:
|
||||
%exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
|
||||
%exn = landingpad {i8*, i32}
|
||||
catch i8* null
|
||||
ret void
|
||||
}
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
@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
|
||||
|
@ -26,7 +26,7 @@ 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
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
@_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
|
||||
|
||||
|
@ -17,8 +17,7 @@ entry:
|
|||
; 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
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
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
|
||||
|
@ -19,7 +19,7 @@ unreachable:
|
|||
unreachable
|
||||
|
||||
return:
|
||||
%0 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @foo to i8*)
|
||||
%0 = landingpad { i8*, i32 }
|
||||
catch i8* null
|
||||
ret void
|
||||
}
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
@_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*
|
||||
|
@ -24,7 +24,7 @@ entry:
|
|||
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
|
||||
|
@ -56,7 +56,7 @@ 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
|
||||
|
|
|
@ -19,7 +19,7 @@ target triple = "powerpc64-apple-darwin8"
|
|||
; 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]
|
||||
|
@ -33,7 +33,7 @@ bb30.preheader: ; preds = %entry
|
|||
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
|
||||
|
|
|
@ -61,7 +61,7 @@ target triple = "powerpc64-bgq-linux"
|
|||
@.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
|
||||
|
||||
|
@ -124,7 +124,7 @@ _ZNK4Foam8ZoneMeshINS_9pointZoneENS_8polyMeshEE15checkDefinitionEb.exit: ; preds
|
|||
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
|
||||
|
||||
|
@ -157,7 +157,7 @@ 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
|
||||
|
||||
|
@ -181,7 +181,7 @@ if.else: ; preds = %for.cond.cleanup69
|
|||
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
|
||||
|
||||
|
@ -200,12 +200,12 @@ 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
|
||||
|
@ -215,7 +215,7 @@ if.end213: ; preds = %invoke.cont176
|
|||
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
|
||||
|
||||
|
@ -247,12 +247,12 @@ invoke.cont231: ; preds = %_ZNSsD2Ev.exit1792
|
|||
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
|
||||
|
@ -262,7 +262,7 @@ invoke.cont243: ; preds = %invoke.cont231
|
|||
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
|
||||
|
||||
|
@ -283,7 +283,7 @@ 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
|
||||
|
||||
|
@ -314,7 +314,7 @@ invoke.cont676: ; preds = %invoke.cont674
|
|||
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
|
||||
|
||||
|
@ -342,7 +342,7 @@ if.else888: ; preds = %_ZN4Foam11regionSpl
|
|||
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
|
||||
|
||||
|
@ -371,7 +371,7 @@ 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
|
||||
|
||||
|
@ -382,7 +382,7 @@ _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
|
||||
|
@ -391,7 +391,7 @@ eh.resume: ; preds = %_ZN4Foam4ListIiED2E
|
|||
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
|
||||
}
|
||||
|
|
|
@ -9,7 +9,7 @@ target triple = "powerpc64-bgq-linux"
|
|||
%"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
|
||||
|
||||
|
@ -42,7 +42,7 @@ 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
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@ target triple = "powerpc64-bgq-linux"
|
|||
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
|
||||
|
@ -50,14 +50,14 @@ 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
|
||||
|
|
|
@ -46,7 +46,7 @@ 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
|
||||
|
@ -66,7 +66,7 @@ _ZN4Foam6stringC2ERKS0_.exit.i: ; preds = %invoke.cont
|
|||
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
|
||||
|
||||
|
@ -90,17 +90,17 @@ memptr.end.i: ; preds = %invoke.cont8
|
|||
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
|
||||
|
||||
|
@ -119,12 +119,12 @@ 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
|
||||
|
||||
|
|
|
@ -11,7 +11,7 @@ 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
|
||||
|
||||
|
@ -41,7 +41,7 @@ for.cond.i.i30: ; preds = %for.cond.i.i30, %in
|
|||
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
|
||||
}
|
||||
|
|
|
@ -71,7 +71,7 @@
|
|||
; 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
|
||||
|
@ -102,7 +102,7 @@ entry:
|
|||
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
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
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
|
||||
|
@ -13,7 +13,7 @@ unreachable:
|
|||
unreachable
|
||||
|
||||
handler:
|
||||
%tmp = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)* @baz to i8*)
|
||||
%tmp = landingpad { i8*, i32 }
|
||||
cleanup
|
||||
resume { i8*, i32 } undef
|
||||
}
|
||||
|
|
|
@ -76,7 +76,7 @@ declare %class.btCapsuleShape* @_ZN14btCapsuleShapeC1Eff(%class.btCapsuleShape*,
|
|||
|
||||
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
|
||||
|
@ -635,7 +635,7 @@ for.inc: ; preds = %for.body
|
|||
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
|
||||
|
@ -648,7 +648,7 @@ 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
|
||||
|
@ -661,7 +661,7 @@ 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
|
||||
|
@ -674,7 +674,7 @@ 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
|
||||
|
@ -687,7 +687,7 @@ 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
|
||||
|
@ -700,7 +700,7 @@ 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
|
||||
|
@ -713,7 +713,7 @@ 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
|
||||
|
@ -726,7 +726,7 @@ 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
|
||||
|
@ -739,7 +739,7 @@ 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
|
||||
|
@ -752,7 +752,7 @@ 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
|
||||
|
@ -765,7 +765,7 @@ 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
|
||||
|
@ -1264,7 +1264,7 @@ invoke.cont517: ; preds = %invoke.cont488
|
|||
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
|
||||
|
@ -1274,7 +1274,7 @@ lpad258: ; preds = %for.end
|
|||
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
|
||||
|
@ -1284,7 +1284,7 @@ lpad284: ; preds = %invoke.cont259
|
|||
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
|
||||
|
@ -1294,7 +1294,7 @@ lpad313: ; preds = %invoke.cont285
|
|||
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
|
||||
|
@ -1304,7 +1304,7 @@ lpad342: ; preds = %invoke.cont314
|
|||
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
|
||||
|
@ -1314,7 +1314,7 @@ lpad371: ; preds = %invoke.cont343
|
|||
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
|
||||
|
@ -1324,7 +1324,7 @@ lpad400: ; preds = %invoke.cont372
|
|||
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
|
||||
|
@ -1334,7 +1334,7 @@ lpad429: ; preds = %invoke.cont401
|
|||
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
|
||||
|
@ -1344,7 +1344,7 @@ lpad458: ; preds = %invoke.cont430
|
|||
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
|
||||
|
@ -1354,7 +1354,7 @@ lpad487: ; preds = %invoke.cont459
|
|||
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
|
||||
|
@ -1371,7 +1371,7 @@ eh.resume: ; preds = %lpad516, %lpad487,
|
|||
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
|
||||
|
|
|
@ -51,7 +51,7 @@ $"\01??_R0H@8" = comdat any
|
|||
@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
|
||||
|
@ -59,7 +59,7 @@ entry:
|
|||
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
|
||||
|
@ -86,7 +86,7 @@ eh.resume: ; preds = %lpad
|
|||
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
|
||||
|
@ -109,7 +109,7 @@ 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
|
||||
|
@ -141,7 +141,7 @@ try.cont: ; preds = %invoke.cont2, %invo
|
|||
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
|
||||
|
|
|
@ -25,7 +25,7 @@ target triple = "x86_64-pc-windows-msvc"
|
|||
; 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
|
||||
|
@ -36,13 +36,13 @@ 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
|
||||
|
|
|
@ -50,7 +50,7 @@ $_TI1H = comdat any
|
|||
; 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
|
||||
|
@ -62,7 +62,7 @@ entry:
|
|||
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
|
||||
|
@ -78,7 +78,7 @@ catch: ; preds = %lpad
|
|||
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
|
||||
|
@ -113,7 +113,7 @@ unreachable: ; preds = %catch, %entry
|
|||
; 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: }
|
||||
|
|
|
@ -29,7 +29,7 @@ target triple = "x86_64-pc-windows-msvc"
|
|||
; 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
|
||||
|
@ -41,13 +41,13 @@ 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
|
||||
|
|
|
@ -31,7 +31,7 @@ $"\01??_R0H@8" = comdat any
|
|||
@"\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
|
||||
|
@ -41,7 +41,7 @@ $"\01??_R0H@8" = comdat any
|
|||
; 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
|
||||
|
@ -66,27 +66,27 @@ invoke.cont2: ; preds = %invoke.cont
|
|||
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
|
||||
|
@ -94,14 +94,14 @@ lpad1: ; preds = %invoke.cont
|
|||
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
|
||||
|
@ -128,7 +128,7 @@ try.cont: ; preds = %invoke.cont2, %invo
|
|||
|
||||
; 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
|
||||
|
@ -202,7 +202,7 @@ eh.resume: ; preds = %catch.dispatch7
|
|||
; 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: }
|
||||
|
|
|
@ -26,7 +26,7 @@ $"\01??_R0H@8" = comdat any
|
|||
@"\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()
|
||||
|
@ -37,14 +37,14 @@ invoke.cont2: ; preds = %invoke.cont
|
|||
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
|
||||
|
|
|
@ -19,14 +19,14 @@ 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
|
||||
|
|
|
@ -62,7 +62,7 @@ $"\01??_R0H@8" = comdat any
|
|||
; 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
|
||||
|
@ -99,13 +99,13 @@ invoke.cont: ; preds = %for.body
|
|||
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
|
||||
|
|
|
@ -45,7 +45,7 @@ $"\01??_R0H@8" = comdat any
|
|||
; 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*
|
||||
|
@ -59,14 +59,14 @@ 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
|
||||
|
|
|
@ -30,7 +30,7 @@ target triple = "x86_64-pc-windows-msvc"
|
|||
; 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*
|
||||
|
@ -44,13 +44,13 @@ invoke.cont: ; preds = %entry
|
|||
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
|
||||
|
|
|
@ -35,7 +35,7 @@ target triple = "x86_64-pc-windows-msvc"
|
|||
; 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*
|
||||
|
@ -48,7 +48,7 @@ invoke.cont: ; preds = %entry
|
|||
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
|
||||
|
|
|
@ -45,7 +45,7 @@ $"\01??_R0?AVSomeClass@@@8" = comdat any
|
|||
@"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
|
||||
|
@ -55,7 +55,7 @@ $"\01??_R0?AVSomeClass@@@8" = comdat any
|
|||
; 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
|
||||
|
@ -69,7 +69,7 @@ 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@@"
|
||||
|
@ -82,7 +82,7 @@ invoke.cont: ; preds = %entry
|
|||
; 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@@"
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue