This is an archive of the discontinued LLVM Phabricator instance.

Differential D56557

[opaque pointer types] Update InvokeInst creation APIs to consistently accept a callee-type argument.
ClosedPublic

Authored by jyknight on Jan 10 2019, 1:22 PM.

Details

Reviewers
whitequark
deadalnix
niravd
Commits
rGeb2c4af1bf8e: [opaque pointer types] Update InvokeInst creation APIs to consistently accept a…
rL351122: [opaque pointer types] Update InvokeInst creation APIs to consistently
Summary

Note: this also adds a new C API and soft-deprecates the old C API.

Diff Detail

Repository
rL LLVM

Event Timeline

jyknight created this revision.Jan 10 2019, 1:22 PM
Herald added a subscriber: hiraditya. · View Herald TranscriptJan 10 2019, 1:22 PM
Harbormaster completed remote builds in B26652: Diff 181142.Jan 10 2019, 1:22 PM
jyknight updated this revision to Diff 181153.Jan 10 2019, 2:07 PM

(Ran clang format; forgot to do before uploading before)

Harbormaster completed remote builds in B26658: Diff 181153.Jan 10 2019, 2:09 PM
whitequark requested changes to this revision.Jan 10 2019, 7:35 PM
whitequark added inline comments.
llvm/include/llvm-c/Core.h
3411 ↗(On Diff #181153)

Please add NameLen as this is the convention for all new C APIs.

This revision now requires changes to proceed.Jan 10 2019, 7:35 PM
whitequark added inline comments.Jan 10 2019, 7:40 PM
llvm/include/llvm-c/Core.h
3411 ↗(On Diff #181153)

(See discussion over at https://reviews.llvm.org/D56556#1353734).

jyknight mentioned this in D56556: [opaque pointer types] Update CallInst creation APIs to consistently accept a callee-type argument..Jan 14 2019, 9:37 AM
niravd accepted this revision.Jan 14 2019, 12:09 PM
niravd added a subscriber: niravd.

LGTM.

This revision was not accepted when it landed; it landed in state Needs Revision.Jan 14 2019, 1:41 PM
Closed by commit rL351122: [opaque pointer types] Update InvokeInst creation APIs to consistently (authored by jyknight). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm-c/
6 lines
llvm/
IR/
50 lines
150 lines
lib/
IR/
19 lines

Diff 181644

llvm/trunk/include/llvm-c/Core.h

Show First 20 Lines • Show All 3,392 Lines • ▼ Show 20 LinesLLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef, LLVMValueRef *RetVals,
unsigned N); unsigned N);
LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest);
LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); LLVMBasicBlockRef Then, LLVMBasicBlockRef Else);
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V,
LLVMBasicBlockRef Else, unsigned NumCases); LLVMBasicBlockRef Else, unsigned NumCases);
LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
unsigned NumDests); unsigned NumDests);
// LLVMBuildInvoke is deprecated in favor of LLVMBuildInvoke2, in preparation
// for opaque pointer types.
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn,
LLVMValueRef *Args, unsigned NumArgs, LLVMValueRef *Args, unsigned NumArgs,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
const char *Name); const char *Name);
LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn,
LLVMValueRef *Args, unsigned NumArgs,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
const char *Name);
LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef);
/* Exception Handling */ /* Exception Handling */
LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn); LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn);
LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
LLVMValueRef PersFn, unsigned NumClauses, LLVMValueRef PersFn, unsigned NumClauses,
const char *Name); const char *Name);
LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad, LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
▲ Show 20 Lines • Show All 468 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 883 Lines • ▼ Show 20 Linespublic:
/// Create an indirect branch instruction with the specified address /// Create an indirect branch instruction with the specified address
/// operand, with an optional hint for the number of destinations that will be /// operand, with an optional hint for the number of destinations that will be
/// added (for efficient allocation). /// added (for efficient allocation).
IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) { IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
return Insert(IndirectBrInst::Create(Addr, NumDests)); return Insert(IndirectBrInst::Create(Addr, NumDests));
} }
/// Create an invoke instruction. /// Create an invoke instruction.
InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
BasicBlock *UnwindDest, BasicBlock *NormalDest, BasicBlock *UnwindDest,
ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> OpBundles,
const Twine &Name = "") {
return Insert(
InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
Name);
}
InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
BasicBlock *NormalDest, BasicBlock *UnwindDest,
ArrayRef<Value *> Args = None, ArrayRef<Value *> Args = None,
const Twine &Name = "") { const Twine &Name = "") {
return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args), return Insert(InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args),
Name); Name);
} }
InvokeInst *CreateInvoke(Function *Callee, BasicBlock *NormalDest,
BasicBlock *UnwindDest, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> OpBundles,
const Twine &Name = "") {
return CreateInvoke(Callee->getFunctionType(), Callee, NormalDest,
UnwindDest, Args, OpBundles, Name);
}
InvokeInst *CreateInvoke(Function *Callee, BasicBlock *NormalDest,
BasicBlock *UnwindDest,
ArrayRef<Value *> Args = None,
const Twine &Name = "") {
return CreateInvoke(Callee->getFunctionType(), Callee, NormalDest,
UnwindDest, Args, Name);
}
// Deprecated [opaque pointer types]
InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest, InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
BasicBlock *UnwindDest, ArrayRef<Value *> Args, BasicBlock *UnwindDest, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> OpBundles, ArrayRef<OperandBundleDef> OpBundles,
const Twine &Name = "") { const Twine &Name = "") {
return Insert(InvokeInst::Create(Callee, NormalDest, UnwindDest, Args, return CreateInvoke(
OpBundles), Name); cast<FunctionType>(
cast<PointerType>(Callee->getType())->getElementType()),
Callee, NormalDest, UnwindDest, Args, OpBundles, Name);
}
// Deprecated [opaque pointer types]
InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
BasicBlock *UnwindDest,
ArrayRef<Value *> Args = None,
const Twine &Name = "") {
return CreateInvoke(
cast<FunctionType>(
cast<PointerType>(Callee->getType())->getElementType()),
Callee, NormalDest, UnwindDest, Args, Name);
} }
ResumeInst *CreateResume(Value *Exn) { ResumeInst *CreateResume(Value *Exn) {
return Insert(ResumeInst::Create(Exn)); return Insert(ResumeInst::Create(Exn));
} }
CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad, CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
BasicBlock *UnwindBB = nullptr) { BasicBlock *UnwindBB = nullptr) {
▲ Show 20 Lines • Show All 1,330 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 3,597 Lines • ▼ Show 20 Linesclass InvokeInst : public CallBase {
/// The index from the end of the operand array to the unwind destination. /// The index from the end of the operand array to the unwind destination.
static constexpr int UnwindDestOpEndIdx = -2; static constexpr int UnwindDestOpEndIdx = -2;
InvokeInst(const InvokeInst &BI); InvokeInst(const InvokeInst &BI);
/// Construct an InvokeInst given a range of arguments. /// Construct an InvokeInst given a range of arguments.
/// ///
/// Construct an InvokeInst from a range of arguments /// Construct an InvokeInst from a range of arguments
inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
int NumOperands, const Twine &NameStr,
Instruction *InsertBefore)
: InvokeInst(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, Bundles, NumOperands,
NameStr, InsertBefore) {}
inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, int NumOperands, ArrayRef<OperandBundleDef> Bundles, int NumOperands,
const Twine &NameStr, Instruction *InsertBefore); const Twine &NameStr, Instruction *InsertBefore);
/// Construct an InvokeInst given a range of arguments.
///
/// Construct an InvokeInst from a range of arguments
inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
int NumOperands, const Twine &NameStr,
BasicBlock *InsertAtEnd);
void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles, BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr) { ArrayRef<OperandBundleDef> Bundles, int NumOperands,
init(cast<FunctionType>( const Twine &NameStr, BasicBlock *InsertAtEnd);
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, Bundles, NameStr);
}
void init(FunctionType *FTy, Value *Func, BasicBlock *IfNormal, void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr); ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
/// Compute the number of operands to allocate. /// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) { static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
// We need one operand for the called function, plus our extra operands and // We need one operand for the called function, plus our extra operands and
// the input operand counts provided. // the input operand counts provided.
return 1 + NumExtraOperands + NumArgs + NumBundleInputs; return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
} }
protected: protected:
// Note: Instruction needs to be a friend here to call cloneImpl. // Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction; friend class Instruction;
InvokeInst *cloneImpl() const; InvokeInst *cloneImpl() const;
public: public:
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr,
Instruction *InsertBefore = nullptr) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, None, NameStr,
InsertBefore);
}
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = None,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, Bundles, NameStr,
InsertBefore);
}
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr, const Twine &NameStr,
Instruction *InsertBefore = nullptr) { Instruction *InsertBefore = nullptr) {
int NumOperands = ComputeNumOperands(Args.size()); int NumOperands = ComputeNumOperands(Args.size());
return new (NumOperands) return new (NumOperands)
InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands, InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
NameStr, InsertBefore); NameStr, InsertBefore);
} }
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = None, ArrayRef<OperandBundleDef> Bundles = None,
const Twine &NameStr = "", const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) { Instruction *InsertBefore = nullptr) {
int NumOperands = int NumOperands =
ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)); ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo); unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
return new (NumOperands, DescriptorBytes) return new (NumOperands, DescriptorBytes)
InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands, InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
NameStr, InsertBefore); NameStr, InsertBefore);
} }
static InvokeInst *Create(Value *Func, static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfNormal, BasicBlock *IfException, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<Value *> Args, const Twine &NameStr, const Twine &NameStr, BasicBlock *InsertAtEnd) {
BasicBlock *InsertAtEnd) {
int NumOperands = ComputeNumOperands(Args.size()); int NumOperands = ComputeNumOperands(Args.size());
return new (NumOperands) InvokeInst(Func, IfNormal, IfException, Args, None, return new (NumOperands)
NumOperands, NameStr, InsertAtEnd); InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
NameStr, InsertAtEnd);
} }
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal, static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, ArrayRef<OperandBundleDef> Bundles,
const Twine &NameStr, BasicBlock *InsertAtEnd) { const Twine &NameStr, BasicBlock *InsertAtEnd) {
int NumOperands = int NumOperands =
ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)); ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo); unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
return new (NumOperands, DescriptorBytes) return new (NumOperands, DescriptorBytes)
InvokeInst(Func, IfNormal, IfException, Args, Bundles, NumOperands, InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
NameStr, InsertAtEnd); NameStr, InsertAtEnd);
} }
static InvokeInst *Create(Function *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr,
Instruction *InsertBefore = nullptr) {
return Create(Func->getFunctionType(), Func, IfNormal, IfException, Args,
None, NameStr, InsertBefore);
}
static InvokeInst *Create(Function *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = None,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
return Create(Func->getFunctionType(), Func, IfNormal, IfException, Args,
Bundles, NameStr, InsertBefore);
}
static InvokeInst *Create(Function *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr, BasicBlock *InsertAtEnd) {
return Create(Func->getFunctionType(), Func, IfNormal, IfException, Args,
NameStr, InsertAtEnd);
}
static InvokeInst *Create(Function *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles,
const Twine &NameStr, BasicBlock *InsertAtEnd) {
return Create(Func->getFunctionType(), Func, IfNormal, IfException, Args,
Bundles, NameStr, InsertAtEnd);
}
// Deprecated [opaque pointer types]
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr,
Instruction *InsertBefore = nullptr) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, None, NameStr,
InsertBefore);
}
// Deprecated [opaque pointer types]
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = None,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, Bundles, NameStr,
InsertBefore);
}
// Deprecated [opaque pointer types]
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr, BasicBlock *InsertAtEnd) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, NameStr, InsertAtEnd);
}
// Deprecated [opaque pointer types]
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles,
const Twine &NameStr, BasicBlock *InsertAtEnd) {
return Create(cast<FunctionType>(
cast<PointerType>(Func->getType())->getElementType()),
Func, IfNormal, IfException, Args, Bundles, NameStr,
InsertAtEnd);
}
/// Create a clone of \p II with a different set of operand bundles and /// Create a clone of \p II with a different set of operand bundles and
/// insert it before \p InsertPt. /// insert it before \p InsertPt.
/// ///
/// The returned invoke instruction is identical to \p II in every way except /// The returned invoke instruction is identical to \p II in every way except
/// that the operand bundles for the new instruction are set to the operand /// that the operand bundles for the new instruction are set to the operand
/// bundles in \p Bundles. /// bundles in \p Bundles.
static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles, static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
Instruction *InsertPt = nullptr); Instruction *InsertPt = nullptr);
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 LinesInvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
ArrayRef<OperandBundleDef> Bundles, int NumOperands, ArrayRef<OperandBundleDef> Bundles, int NumOperands,
const Twine &NameStr, Instruction *InsertBefore) const Twine &NameStr, Instruction *InsertBefore)
: CallBase(Ty->getReturnType(), Instruction::Invoke, : CallBase(Ty->getReturnType(), Instruction::Invoke,
OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands, OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
InsertBefore) { InsertBefore) {
init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr); init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
} }
InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal, InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args, BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, int NumOperands, ArrayRef<OperandBundleDef> Bundles, int NumOperands,
const Twine &NameStr, BasicBlock *InsertAtEnd) const Twine &NameStr, BasicBlock *InsertAtEnd)
: CallBase(cast<FunctionType>( : CallBase(Ty->getReturnType(), Instruction::Invoke,
cast<PointerType>(Func->getType())->getElementType())
->getReturnType(),
Instruction::Invoke,
OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands, OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
InsertAtEnd) { InsertAtEnd) {
init(Func, IfNormal, IfException, Args, Bundles, NameStr); init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ResumeInst Class // ResumeInst Class
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
//===--------------------------------------------------------------------------- //===---------------------------------------------------------------------------
/// Resume the propagation of an exception. /// Resume the propagation of an exception.
▲ Show 20 Lines • Show All 1,137 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Core.cpp

Show First 20 Lines • Show All 2,969 Lines • ▼ Show 20 LinesLLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
unsigned NumDests) { unsigned NumDests) {
return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests)); return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
} }
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn,
LLVMValueRef *Args, unsigned NumArgs, LLVMValueRef *Args, unsigned NumArgs,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
const char *Name) { const char *Name) {
return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch), Value *V = unwrap(Fn);
makeArrayRef(unwrap(Args), NumArgs), FunctionType *FnT =
Name)); cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());
return wrap(
unwrap(B)->CreateInvoke(FnT, unwrap(Fn), unwrap(Then), unwrap(Catch),
makeArrayRef(unwrap(Args), NumArgs), Name));
}
LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
LLVMValueRef *Args, unsigned NumArgs,
LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
const char *Name) {
return wrap(unwrap(B)->CreateInvoke(
unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch),
makeArrayRef(unwrap(Args), NumArgs), Name));
} }
LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
LLVMValueRef PersFn, unsigned NumClauses, LLVMValueRef PersFn, unsigned NumClauses,
const char *Name) { const char *Name) {
// The personality used to live on the landingpad instruction, but now it // The personality used to live on the landingpad instruction, but now it
// lives on the parent function. For compatibility, take the provided // lives on the parent function. For compatibility, take the provided
// personality and put it on the parent function. // personality and put it on the parent function.
▲ Show 20 Lines • Show All 880 Lines • Show Last 20 Lines