[llvm] [RemoveDIs] Add iterator-taking constructors and Create methods (PR #82778)
Jeremy Morse via llvm-commits
llvm-commits at lists.llvm.org
Fri Feb 23 07:45:23 PST 2024
https://github.com/jmorse created https://github.com/llvm/llvm-project/pull/82778
Part of removing debug-intrinsics from LLVM requires using iterators whenever we insert an instruction into a block. That means we need all instruction constructors and factory functions to have an iterator taking option, which this patch adds.
The whole of this patch should be NFC: it's adding new flavours of existing constructors, and plumbing those through to the Instruction constructor that takes iterators. It's almost entirely boilerplate copy-and-paste too.
~
This PR is a candidate for the "most boring PR of the year", given that it adds prototypes and handlers for a bunch of methods with slightly different signature to do the same thing. However, I figure it's worth /some/ review of the general approach, just to confirm that I haven't missed anything obvious that's going on.
There are a large number of clang-format issues with the patch, mostly due to adjacent code with noncompliant indentation and the like. I've patched up the lines that I'm adding, I don't wish to pollute git history by clang-formatting all the surrounding code.
>From e49779b5e5bcb016ee96d0d169bea5b263a1c9f3 Mon Sep 17 00:00:00 2001
From: Jeremy Morse <jeremy.morse at sony.com>
Date: Thu, 22 Feb 2024 15:33:12 +0000
Subject: [PATCH] [RemoveDIs] Add iterator-taking constructors and Create
methods
Part of removing debug-intrinsics from LLVM requires using iterators
whenever we insert an instruction into a block. That means we need all
instructor constructors and factory functions to have an iterator taking
option, which this patch adds.
The whole of this patch should be NFC: it's adding new flavours of existing
constructors, and plumbing those through to the Instruction constructor
that takes iterators. It's almost entirely boilerplate copy-and-paste too.
---
llvm/include/llvm/IR/InstrTypes.h | 219 ++++++++++
llvm/include/llvm/IR/Instruction.h | 2 +
llvm/include/llvm/IR/Instructions.h | 631 +++++++++++++++++++++++++++-
llvm/lib/IR/Instruction.cpp | 10 +
llvm/lib/IR/Instructions.cpp | 504 +++++++++++++++++++++-
5 files changed, 1350 insertions(+), 16 deletions(-)
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index 6eba902fa04165..4ee51cd192ed7c 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -54,6 +54,10 @@ typedef unsigned ID;
class UnaryInstruction : public Instruction {
protected:
+ UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock::iterator IB)
+ : Instruction(Ty, iType, &Op<0>(), 1, IB) {
+ Op<0>() = V;
+ }
UnaryInstruction(Type *Ty, unsigned iType, Value *V,
Instruction *IB = nullptr)
: Instruction(Ty, iType, &Op<0>(), 1, IB) {
@@ -101,6 +105,8 @@ class UnaryOperator : public UnaryInstruction {
void AssertOK();
protected:
+ UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
+ const Twine &Name, BasicBlock::iterator InsertBefore);
UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
const Twine &Name, Instruction *InsertBefore);
UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
@@ -112,6 +118,12 @@ class UnaryOperator : public UnaryInstruction {
UnaryOperator *cloneImpl() const;
public:
+ /// Construct a unary instruction, given the opcode and an operand.
+ /// Insert the instruction into a BasicBlock right before the specified
+ /// instruction (InsertBefore must be a valid iterator).
+ ///
+ static UnaryOperator *Create(UnaryOps Op, Value *S, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
/// Construct a unary instruction, given the opcode and an operand.
/// Optionally (if InstBefore is specified) insert the instruction
@@ -150,6 +162,20 @@ class UnaryOperator : public UnaryInstruction {
return Create(Instruction::OPC, V, Name, I);\
}
#include "llvm/IR/Instruction.def"
+#define HANDLE_UNARY_INST(N, OPC, CLASS) \
+ static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
+ BasicBlock::iterator It) {\
+ return Create(Instruction::OPC, V, Name, It);\
+ }
+#include "llvm/IR/Instruction.def"
+
+ static UnaryOperator *
+ CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
+ const Twine &Name, BasicBlock::iterator InsertBefore) {
+ UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
+ UO->copyIRFlags(CopyO);
+ return UO;
+ }
static UnaryOperator *
CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
@@ -160,6 +186,13 @@ class UnaryOperator : public UnaryInstruction {
return UO;
}
+ static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
+ InsertBefore);
+ }
+
static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
const Twine &Name = "",
Instruction *InsertBefore = nullptr) {
@@ -188,6 +221,8 @@ class BinaryOperator : public Instruction {
void AssertOK();
protected:
+ BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
+ const Twine &Name, BasicBlock::iterator InsertBefore);
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
const Twine &Name, Instruction *InsertBefore);
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
@@ -206,6 +241,14 @@ class BinaryOperator : public Instruction {
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+ /// Construct a binary instruction, given the opcode and the two
+ /// operands. Insert the instruction into a BasicBlock right before the
+ /// specified instruction.
+ ///
+ static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore);
+
/// Construct a binary instruction, given the opcode and the two
/// operands. Optionally (if InstBefore is specified) insert the instruction
/// into a BasicBlock right before the specified instruction. The specified
@@ -243,6 +286,20 @@ class BinaryOperator : public Instruction {
return Create(Instruction::OPC, V1, V2, Name, I);\
}
#include "llvm/IR/Instruction.def"
+#define HANDLE_BINARY_INST(N, OPC, CLASS) \
+ static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
+ const Twine &Name, BasicBlock::iterator It) {\
+ return Create(Instruction::OPC, V1, V2, Name, It);\
+ }
+#include "llvm/IR/Instruction.def"
+
+ static BinaryOperator *
+ CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Value *CopyO,
+ const Twine &Name, BasicBlock::iterator InsertBefore) {
+ BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore);
+ BO->copyIRFlags(CopyO);
+ return BO;
+ }
static BinaryOperator *
CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Value *CopyO,
@@ -297,6 +354,12 @@ class BinaryOperator : public Instruction {
BO->setHasNoSignedWrap(true);
return BO;
}
+ static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
+ const Twine &Name, BasicBlock::iterator It) {
+ BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
+ BO->setHasNoSignedWrap(true);
+ return BO;
+ }
static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
const Twine &Name = "") {
@@ -316,6 +379,12 @@ class BinaryOperator : public Instruction {
BO->setHasNoUnsignedWrap(true);
return BO;
}
+ static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
+ const Twine &Name, BasicBlock::iterator It) {
+ BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
+ BO->setHasNoUnsignedWrap(true);
+ return BO;
+ }
static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
const Twine &Name = "") {
@@ -335,6 +404,13 @@ class BinaryOperator : public Instruction {
BO->setIsExact(true);
return BO;
}
+ static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
+ const Twine &Name,
+ BasicBlock::iterator It) {
+ BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
+ BO->setIsExact(true);
+ return BO;
+ }
static inline BinaryOperator *
CreateDisjoint(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name = "");
@@ -344,6 +420,9 @@ class BinaryOperator : public Instruction {
static inline BinaryOperator *CreateDisjoint(BinaryOps Opc, Value *V1,
Value *V2, const Twine &Name,
Instruction *I);
+ static inline BinaryOperator *CreateDisjoint(BinaryOps Opc, Value *V1,
+ Value *V2, const Twine &Name,
+ BasicBlock::iterator It);
#define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2, \
@@ -357,6 +436,10 @@ class BinaryOperator : public Instruction {
static BinaryOperator *Create##NUWNSWEXACT##OPC( \
Value *V1, Value *V2, const Twine &Name, Instruction *I) { \
return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
+ } \
+ static BinaryOperator *Create##NUWNSWEXACT##OPC( \
+ Value *V1, Value *V2, const Twine &Name, BasicBlock::iterator It) { \
+ return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, It); \
}
DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
@@ -382,18 +465,26 @@ class BinaryOperator : public Instruction {
///
/// Create the NEG and NOT instructions out of SUB and XOR instructions.
///
+ static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
BasicBlock *InsertAtEnd);
+ static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
BasicBlock *InsertAtEnd);
+ static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
BasicBlock *InsertAtEnd);
+ static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
@@ -469,6 +560,13 @@ BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
return BO;
}
+BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
+ Value *V2, const Twine &Name,
+ BasicBlock::iterator It) {
+ BinaryOperator *BO = Create(Opc, V1, V2, Name, It);
+ cast<PossiblyDisjointInst>(BO)->setIsDisjoint(true);
+ return BO;
+}
//===----------------------------------------------------------------------===//
// CastInst Class
@@ -482,6 +580,12 @@ BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1,
/// Base class of casting instructions.
class CastInst : public UnaryInstruction {
protected:
+ /// Constructor with insert-before-instruction semantics for subclasses
+ CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(Ty, iType, S, InsertBefore) {
+ setName(NameStr);
+ }
/// Constructor with insert-before-instruction semantics for subclasses
CastInst(Type *Ty, unsigned iType, Value *S,
const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
@@ -496,6 +600,19 @@ class CastInst : public UnaryInstruction {
}
public:
+ /// Provides a way to construct any of the CastInst subclasses using an
+ /// opcode instead of the subclass's constructor. The opcode must be in the
+ /// CastOps category (Instruction::isCast(opcode) returns true). This
+ /// constructor has insert-before-instruction semantics to automatically
+ /// insert the new CastInst before InsertBefore, which must be a valid
+ /// iterator. Construct any of the CastInst subclasses.
+ static CastInst *
+ Create(Instruction::CastOps, ///< The opcode of the cast instruction
+ Value *S, ///< The value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
/// Provides a way to construct any of the CastInst subclasses using an
/// opcode instead of the subclass's constructor. The opcode must be in the
/// CastOps category (Instruction::isCast(opcode) returns true). This
@@ -523,6 +640,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create a ZExt or BitCast cast instruction
+ static CastInst *CreateZExtOrBitCast(
+ Value *S, ///< The value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a ZExt or BitCast cast instruction
static CastInst *CreateZExtOrBitCast(
Value *S, ///< The value to be casted (operand 0)
@@ -539,6 +664,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create a SExt or BitCast cast instruction
+ static CastInst *CreateSExtOrBitCast(
+ Value *S, ///< The value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a SExt or BitCast cast instruction
static CastInst *CreateSExtOrBitCast(
Value *S, ///< The value to be casted (operand 0)
@@ -563,6 +696,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
+ static CastInst *CreatePointerCast(
+ Value *S, ///< The pointer value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
static CastInst *CreatePointerCast(
Value *S, ///< The pointer value to be casted (operand 0)
@@ -579,6 +720,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create a BitCast or an AddrSpaceCast cast instruction.
+ static CastInst *CreatePointerBitCastOrAddrSpaceCast(
+ Value *S, ///< The pointer value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a BitCast or an AddrSpaceCast cast instruction.
static CastInst *CreatePointerBitCastOrAddrSpaceCast(
Value *S, ///< The pointer value to be casted (operand 0)
@@ -587,6 +736,19 @@ class CastInst : public UnaryInstruction {
Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);
+ /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
+ ///
+ /// If the value is a pointer type and the destination an integer type,
+ /// creates a PtrToInt cast. If the value is an integer type and the
+ /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
+ /// a bitcast.
+ static CastInst *CreateBitOrPointerCast(
+ Value *S, ///< The pointer value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
///
/// If the value is a pointer type and the destination an integer type,
@@ -600,6 +762,15 @@ class CastInst : public UnaryInstruction {
Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);
+ /// Create a ZExt, BitCast, or Trunc for int -> int casts.
+ static CastInst *CreateIntegerCast(
+ Value *S, ///< The pointer value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ bool isSigned, ///< Whether to regard S as signed or not
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a ZExt, BitCast, or Trunc for int -> int casts.
static CastInst *CreateIntegerCast(
Value *S, ///< The pointer value to be casted (operand 0)
@@ -618,6 +789,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
+ static CastInst *CreateFPCast(
+ Value *S, ///< The floating point value to be casted
+ Type *Ty, ///< The floating point type to cast to
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
static CastInst *CreateFPCast(
Value *S, ///< The floating point value to be casted
@@ -634,6 +813,14 @@ class CastInst : public UnaryInstruction {
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// Create a Trunc or BitCast cast instruction
+ static CastInst *CreateTruncOrBitCast(
+ Value *S, ///< The value to be casted (operand 0)
+ Type *Ty, ///< The type to which cast should be made
+ const Twine &Name, ///< Name for the instruction
+ BasicBlock::iterator InsertBefore ///< Place to insert the instruction
+ );
+
/// Create a Trunc or BitCast cast instruction
static CastInst *CreateTruncOrBitCast(
Value *S, ///< The value to be casted (operand 0)
@@ -830,6 +1017,10 @@ class CmpInst : public Instruction {
}
protected:
+ CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, Value *LHS,
+ Value *RHS, const Twine &Name, BasicBlock::iterator InsertBefore,
+ Instruction *FlagsSource = nullptr);
+
CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
Value *LHS, Value *RHS, const Twine &Name = "",
Instruction *InsertBefore = nullptr,
@@ -844,6 +1035,13 @@ class CmpInst : public Instruction {
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }
+ /// Construct a compare instruction, given the opcode, the predicate and
+ /// the two operands. Insert the instruction into a BasicBlock right before
+ /// the specified instruction.
+ /// Create a CmpInst
+ static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2,
+ const Twine &Name, BasicBlock::iterator InsertBefore);
+
/// Construct a compare instruction, given the opcode, the predicate and
/// the two operands. Optionally (if InstBefore is specified) insert the
/// instruction into a BasicBlock right before the specified instruction.
@@ -1300,6 +1498,15 @@ class CallBase : public Instruction {
public:
using Instruction::getContext;
+ /// Create a clone of \p CB with a different set of operand bundles and
+ /// insert it before \p InsertPt.
+ ///
+ /// The returned call instruction is identical \p CB in every way except that
+ /// the operand bundles for the new instruction are set to the operand bundles
+ /// in \p Bundles.
+ static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
+ BasicBlock::iterator InsertPt);
+
/// Create a clone of \p CB with a different set of operand bundles and
/// insert it before \p InsertPt.
///
@@ -1309,6 +1516,14 @@ class CallBase : public Instruction {
static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
Instruction *InsertPt = nullptr);
+ /// Create a clone of \p CB with the operand bundle with the tag matching
+ /// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
+ ///
+ /// The returned call instruction is identical \p CI in every way except that
+ /// the specified operand bundle has been replaced.
+ static CallBase *Create(CallBase *CB, OperandBundleDef Bundle,
+ BasicBlock::iterator InsertPt);
+
/// Create a clone of \p CB with the operand bundle with the tag matching
/// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
///
@@ -2391,6 +2606,10 @@ class FuncletPadInst : public Instruction {
private:
FuncletPadInst(const FuncletPadInst &CPI);
+ explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
+ ArrayRef<Value *> Args, unsigned Values,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
ArrayRef<Value *> Args, unsigned Values,
const Twine &NameStr, Instruction *InsertBefore);
diff --git a/llvm/include/llvm/IR/Instruction.h b/llvm/include/llvm/IR/Instruction.h
index c0e159a342d5b5..75f399ec2fcd53 100644
--- a/llvm/include/llvm/IR/Instruction.h
+++ b/llvm/include/llvm/IR/Instruction.h
@@ -1007,6 +1007,8 @@ class Instruction : public User,
setValueSubclassData(Storage);
}
+ Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
+ InstListType::iterator InsertBefore);
Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
Instruction *InsertBefore = nullptr);
Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h
index 1db4ff2f09bca7..bc357074e5cb21 100644
--- a/llvm/include/llvm/IR/Instructions.h
+++ b/llvm/include/llvm/IR/Instructions.h
@@ -73,16 +73,22 @@ class AllocaInst : public UnaryInstruction {
AllocaInst *cloneImpl() const;
public:
+ explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
+ const Twine &Name, BasicBlock::iterator InsertBefore);
explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
const Twine &Name, Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
const Twine &Name, BasicBlock *InsertAtEnd);
+ AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
+ BasicBlock::iterator InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace,
const Twine &Name, BasicBlock *InsertAtEnd);
+ AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
+ const Twine &Name, BasicBlock::iterator);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
const Twine &Name = "", Instruction *InsertBefore = nullptr);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
@@ -192,17 +198,26 @@ class LoadInst : public UnaryInstruction {
LoadInst *cloneImpl() const;
public:
+ LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
+ LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
+ BasicBlock::iterator InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
BasicBlock *InsertAtEnd);
+ LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
+ Align Align, BasicBlock::iterator InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
Align Align, Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
Align Align, BasicBlock *InsertAtEnd);
+ LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
+ Align Align, AtomicOrdering Order, SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
Align Align, AtomicOrdering Order,
SyncScope::ID SSID = SyncScope::System,
@@ -456,6 +471,8 @@ class FenceInst : public Instruction {
public:
// Ordering may only be Acquire, Release, AcquireRelease, or
// SequentiallyConsistent.
+ FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore);
FenceInst(LLVMContext &C, AtomicOrdering Ordering,
SyncScope::ID SSID = SyncScope::System,
Instruction *InsertBefore = nullptr);
@@ -536,6 +553,10 @@ class AtomicCmpXchgInst : public Instruction {
AtomicCmpXchgInst *cloneImpl() const;
public:
+ AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
+ AtomicOrdering SuccessOrdering,
+ AtomicOrdering FailureOrdering, SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore);
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
AtomicOrdering SuccessOrdering,
AtomicOrdering FailureOrdering, SyncScope::ID SSID,
@@ -798,6 +819,9 @@ class AtomicRMWInst : public Instruction {
typename Bitfield::Element<BinOp, Offset, 5, BinOp::LAST_BINOP>;
public:
+ AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
+ AtomicOrdering Ordering, SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore);
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
AtomicOrdering Ordering, SyncScope::ID SSID,
Instruction *InsertBefore = nullptr);
@@ -953,9 +977,13 @@ class GetElementPtrInst : public Instruction {
GetElementPtrInst(const GetElementPtrInst &GEPI);
/// Constructors - Create a getelementptr instruction with a base pointer an
- /// list of indices. The first ctor can optionally insert before an existing
- /// instruction, the second appends the new instruction to the specified
- /// BasicBlock.
+ /// list of indices. The first and second ctor can optionally insert before an
+ /// existing instruction, the third appends the new instruction to the
+ /// specified BasicBlock.
+ inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
+ ArrayRef<Value *> IdxList, unsigned Values,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
ArrayRef<Value *> IdxList, unsigned Values,
const Twine &NameStr, Instruction *InsertBefore);
@@ -972,6 +1000,16 @@ class GetElementPtrInst : public Instruction {
GetElementPtrInst *cloneImpl() const;
public:
+ static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
+ ArrayRef<Value *> IdxList,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ unsigned Values = 1 + unsigned(IdxList.size());
+ assert(PointeeType && "Must specify element type");
+ return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
+ NameStr, InsertBefore);
+ }
+
static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
ArrayRef<Value *> IdxList,
const Twine &NameStr = "",
@@ -994,6 +1032,16 @@ class GetElementPtrInst : public Instruction {
/// Create an "inbounds" getelementptr. See the documentation for the
/// "inbounds" flag in LangRef.html for details.
+ static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
+ ArrayRef<Value *> IdxList,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ GetElementPtrInst *GEP =
+ Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
+ GEP->setIsInBounds(true);
+ return GEP;
+ }
+
static GetElementPtrInst *
CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
const Twine &NameStr = "",
@@ -1152,6 +1200,18 @@ struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
};
+GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
+ ArrayRef<Value *> IdxList, unsigned Values,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr,
+ OperandTraits<GetElementPtrInst>::op_end(this) - Values,
+ Values, InsertBefore),
+ SourceElementType(PointeeType),
+ ResultElementType(getIndexedType(PointeeType, IdxList)) {
+ init(Ptr, IdxList, NameStr);
+}
+
GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
ArrayRef<Value *> IdxList, unsigned Values,
const Twine &NameStr,
@@ -1206,6 +1266,21 @@ class ICmpInst: public CmpInst {
ICmpInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics.
+ ICmpInst(
+ BasicBlock::iterator InsertBefore, ///< Where to insert
+ Predicate pred, ///< The predicate to use for the comparison
+ Value *LHS, ///< The left-hand-side of the expression
+ Value *RHS, ///< The right-hand-side of the expression
+ const Twine &NameStr = "" ///< Name of the instruction
+ ) : CmpInst(makeCmpResultType(LHS->getType()),
+ Instruction::ICmp, pred, LHS, RHS, NameStr,
+ InsertBefore) {
+#ifndef NDEBUG
+ AssertOK();
+#endif
+ }
+
/// Constructor with insert-before-instruction semantics.
ICmpInst(
Instruction *InsertBefore, ///< Where to insert
@@ -1378,6 +1453,19 @@ class FCmpInst: public CmpInst {
FCmpInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics.
+ FCmpInst(
+ BasicBlock::iterator InsertBefore, ///< Where to insert
+ Predicate pred, ///< The predicate to use for the comparison
+ Value *LHS, ///< The left-hand-side of the expression
+ Value *RHS, ///< The right-hand-side of the expression
+ const Twine &NameStr = "" ///< Name of the instruction
+ ) : CmpInst(makeCmpResultType(LHS->getType()),
+ Instruction::FCmp, pred, LHS, RHS, NameStr,
+ InsertBefore) {
+ AssertOK();
+ }
+
/// Constructor with insert-before-instruction semantics.
FCmpInst(
Instruction *InsertBefore, ///< Where to insert
@@ -1477,6 +1565,15 @@ class FCmpInst: public CmpInst {
class CallInst : public CallBase {
CallInst(const CallInst &CI);
+ /// Construct a CallInst from a range of arguments
+ inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
+
+ inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
+ const Twine &NameStr, BasicBlock::iterator InsertBefore)
+ : CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore) {}
+
/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
@@ -1493,6 +1590,9 @@ class CallInst : public CallBase {
ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
BasicBlock *InsertAtEnd);
+ explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
+
explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
Instruction *InsertBefore);
@@ -1517,11 +1617,23 @@ class CallInst : public CallBase {
CallInst *cloneImpl() const;
public:
+ static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
+ }
+
static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
}
+ static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new (ComputeNumOperands(Args.size()))
+ CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore);
+ }
+
static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
const Twine &NameStr,
Instruction *InsertBefore = nullptr) {
@@ -1529,6 +1641,18 @@ class CallInst : public CallBase {
CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore);
}
+ static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ const int NumOperands =
+ ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
+ const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
+
+ return new (NumOperands, DescriptorBytes)
+ CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
+ }
+
static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = std::nullopt,
const Twine &NameStr = "",
@@ -1563,12 +1687,26 @@ class CallInst : public CallBase {
CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
}
+ static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
+ InsertBefore);
+ }
+
static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
InsertBefore);
}
+ static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
+ NameStr, InsertBefore);
+ }
+
static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = std::nullopt,
const Twine &NameStr = "",
@@ -1577,6 +1715,13 @@ class CallInst : public CallBase {
NameStr, InsertBefore);
}
+ static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
+ InsertBefore);
+ }
+
static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
const Twine &NameStr,
Instruction *InsertBefore = nullptr) {
@@ -1609,6 +1754,8 @@ class CallInst : public CallBase {
/// The returned call instruction is identical \p CI in every way except that
/// the operand bundles for the new instruction are set to the operand bundles
/// in \p Bundles.
+ static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
+ BasicBlock::iterator InsertPt);
static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
Instruction *InsertPt = nullptr);
@@ -1682,6 +1829,17 @@ CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
init(Ty, Func, Args, Bundles, NameStr);
}
+CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : CallBase(Ty->getReturnType(), Instruction::Call,
+ OperandTraits<CallBase>::op_end(this) -
+ (Args.size() + CountBundleInputs(Bundles) + 1),
+ unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
+ InsertBefore) {
+ init(Ty, Func, Args, Bundles, NameStr);
+}
+
CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
Instruction *InsertBefore)
@@ -1700,6 +1858,14 @@ CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
/// This class represents the LLVM 'select' instruction.
///
class SelectInst : public Instruction {
+ SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(S1->getType(), Instruction::Select, &Op<0>(), 3,
+ InsertBefore) {
+ init(C, S1, S2);
+ setName(NameStr);
+ }
+
SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
Instruction *InsertBefore)
: Instruction(S1->getType(), Instruction::Select,
@@ -1730,6 +1896,16 @@ class SelectInst : public Instruction {
SelectInst *cloneImpl() const;
public:
+ static SelectInst *Create(Value *C, Value *S1, Value *S2,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore,
+ Instruction *MDFrom = nullptr) {
+ SelectInst *Sel = new (3) SelectInst(C, S1, S2, NameStr, InsertBefore);
+ if (MDFrom)
+ Sel->copyMetadata(*MDFrom);
+ return Sel;
+ }
+
static SelectInst *Create(Value *C, Value *S1, Value *S2,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr,
@@ -1802,6 +1978,12 @@ class VAArgInst : public UnaryInstruction {
VAArgInst *cloneImpl() const;
public:
+ VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
+ setName(NameStr);
+ }
+
VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr)
: UnaryInstruction(Ty, VAArg, List, InsertBefore) {
@@ -1835,6 +2017,8 @@ class VAArgInst : public UnaryInstruction {
/// element from a VectorType value
///
class ExtractElementInst : public Instruction {
+ ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
@@ -1847,6 +2031,12 @@ class ExtractElementInst : public Instruction {
ExtractElementInst *cloneImpl() const;
public:
+ static ExtractElementInst *Create(Value *Vec, Value *Idx,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new (2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
+ }
+
static ExtractElementInst *Create(Value *Vec, Value *Idx,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
@@ -1899,6 +2089,8 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
/// element into a VectorType value
///
class InsertElementInst : public Instruction {
+ InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
@@ -1912,6 +2104,12 @@ class InsertElementInst : public Instruction {
InsertElementInst *cloneImpl() const;
public:
+ static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new (3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
+ }
+
static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
@@ -1981,19 +2179,27 @@ class ShuffleVectorInst : public Instruction {
ShuffleVectorInst *cloneImpl() const;
public:
+ ShuffleVectorInst(Value *V1, Value *Mask, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
ShuffleVectorInst(Value *V1, Value *Mask, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
ShuffleVectorInst(Value *V1, Value *Mask, const Twine &NameStr,
BasicBlock *InsertAtEnd);
+ ShuffleVectorInst(Value *V1, ArrayRef<int> Mask, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
ShuffleVectorInst(Value *V1, ArrayRef<int> Mask, const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
ShuffleVectorInst(Value *V1, ArrayRef<int> Mask, const Twine &NameStr,
BasicBlock *InsertAtEnd);
+ ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, const Twine &NameStr,
+ BasicBlock::iterator InsertBefor);
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
const Twine &NameStr = "",
Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
const Twine &NameStr, BasicBlock *InsertAtEnd);
+ ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
+ const Twine &NameStr, BasicBlock::iterator InsertBefor);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
const Twine &NameStr = "",
Instruction *InsertBefor = nullptr);
@@ -2468,9 +2674,12 @@ class ExtractValueInst : public UnaryInstruction {
ExtractValueInst(const ExtractValueInst &EVI);
/// Constructors - Create a extractvalue instruction with a base aggregate
- /// value and a list of indices. The first ctor can optionally insert before
- /// an existing instruction, the second appends the new instruction to the
- /// specified BasicBlock.
+ /// value and a list of indices. The first and second ctor can optionally
+ /// insert before an existing instruction, the third appends the new
+ /// instruction to the specified BasicBlock.
+ inline ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
inline ExtractValueInst(Value *Agg,
ArrayRef<unsigned> Idxs,
const Twine &NameStr,
@@ -2488,6 +2697,13 @@ class ExtractValueInst : public UnaryInstruction {
ExtractValueInst *cloneImpl() const;
public:
+ static ExtractValueInst *Create(Value *Agg, ArrayRef<unsigned> Idxs,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new
+ ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
+ }
+
static ExtractValueInst *Create(Value *Agg,
ArrayRef<unsigned> Idxs,
const Twine &NameStr = "",
@@ -2548,6 +2764,14 @@ class ExtractValueInst : public UnaryInstruction {
}
};
+ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
+ ExtractValue, Agg, InsertBefore) {
+ init(Idxs, NameStr);
+}
+
ExtractValueInst::ExtractValueInst(Value *Agg,
ArrayRef<unsigned> Idxs,
const Twine &NameStr,
@@ -2579,9 +2803,12 @@ class InsertValueInst : public Instruction {
InsertValueInst(const InsertValueInst &IVI);
/// Constructors - Create a insertvalue instruction with a base aggregate
- /// value, a value to insert, and a list of indices. The first ctor can
- /// optionally insert before an existing instruction, the second appends
+ /// value, a value to insert, and a list of indices. The first and second ctor
+ /// can optionally insert before an existing instruction, the third appends
/// the new instruction to the specified BasicBlock.
+ inline InsertValueInst(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
inline InsertValueInst(Value *Agg, Value *Val,
ArrayRef<unsigned> Idxs,
const Twine &NameStr,
@@ -2590,8 +2817,10 @@ class InsertValueInst : public Instruction {
ArrayRef<unsigned> Idxs,
const Twine &NameStr, BasicBlock *InsertAtEnd);
- /// Constructors - These two constructors are convenience methods because one
- /// and two index insertvalue instructions are so common.
+ /// Constructors - These three constructors are convenience methods because
+ /// one and two index insertvalue instructions are so common.
+ InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
@@ -2612,6 +2841,12 @@ class InsertValueInst : public Instruction {
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }
+ static InsertValueInst *Create(Value *Agg, Value *Val,
+ ArrayRef<unsigned> Idxs, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
+ }
+
static InsertValueInst *Create(Value *Agg, Value *Val,
ArrayRef<unsigned> Idxs,
const Twine &NameStr = "",
@@ -2683,6 +2918,16 @@ struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
};
+InsertValueInst::InsertValueInst(Value *Agg,
+ Value *Val,
+ ArrayRef<unsigned> Idxs,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Agg->getType(), InsertValue, OperandTraits<InsertValueInst>::op_begin(this),
+ 2, InsertBefore) {
+ init(Agg, Val, Idxs, NameStr);
+}
+
InsertValueInst::InsertValueInst(Value *Agg,
Value *Val,
ArrayRef<unsigned> Idxs,
@@ -2722,6 +2967,15 @@ class PHINode : public Instruction {
PHINode(const PHINode &PN);
+ explicit PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
+ ReservedSpace(NumReservedValues) {
+ assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!");
+ setName(NameStr);
+ allocHungoffUses(ReservedSpace);
+ }
+
explicit PHINode(Type *Ty, unsigned NumReservedValues,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr)
@@ -2757,6 +3011,12 @@ class PHINode : public Instruction {
public:
/// Constructors - NumReservedValues is a hint for the number of incoming
/// edges that this phi node will have (use 0 if you really have no idea).
+ static PHINode *Create(Type *Ty, unsigned NumReservedValues,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
+ }
+
static PHINode *Create(Type *Ty, unsigned NumReservedValues,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
@@ -2981,6 +3241,9 @@ class LandingPadInst : public Instruction {
enum ClauseType { Catch, Filter };
private:
+ explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
const Twine &NameStr, Instruction *InsertBefore);
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
@@ -3003,6 +3266,9 @@ class LandingPadInst : public Instruction {
/// 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, unsigned NumReservedClauses,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
@@ -3077,6 +3343,8 @@ class ReturnInst : public Instruction {
// ReturnInst() - 'ret void' instruction
// ReturnInst( null) - 'ret void' instruction
// ReturnInst(Value* X) - 'ret X' instruction
+ // ReturnInst(null, Iterator It) - 'ret void' instruction, insert before I
+ // ReturnInst(Value* X, Iterator It) - 'ret X' instruction, insert before I
// ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
// ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
// ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
@@ -3084,6 +3352,8 @@ class ReturnInst : public Instruction {
//
// NOTE: If the Value* passed is of type void then the constructor behaves as
// if it was passed NULL.
+ explicit ReturnInst(LLVMContext &C, Value *retVal,
+ BasicBlock::iterator InsertBefore);
explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
Instruction *InsertBefore = nullptr);
ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
@@ -3096,6 +3366,11 @@ class ReturnInst : public Instruction {
ReturnInst *cloneImpl() const;
public:
+ static ReturnInst *Create(LLVMContext &C, Value *retVal,
+ BasicBlock::iterator InsertBefore) {
+ return new (!!retVal) ReturnInst(C, retVal, InsertBefore);
+ }
+
static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
Instruction *InsertBefore = nullptr) {
return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
@@ -3160,10 +3435,15 @@ class BranchInst : public Instruction {
// BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
// BranchInst(BB *B) - 'br B'
// BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
+ // BranchInst(BB* B, Iter It) - 'br B' insert before I
+ // BranchInst(BB* T, BB *F, Value *C, Iter It) - 'br C, T, F', insert before I
// BranchInst(BB* B, Inst *I) - 'br B' insert before I
// BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
// BranchInst(BB* B, BB *I) - 'br B' insert at end
// BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
+ explicit BranchInst(BasicBlock *IfTrue, BasicBlock::iterator InsertBefore);
+ BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
+ BasicBlock::iterator InsertBefore);
explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
Instruction *InsertBefore = nullptr);
@@ -3207,11 +3487,21 @@ class BranchInst : public Instruction {
const BasicBlock *operator->() const { return operator*(); }
};
+ static BranchInst *Create(BasicBlock *IfTrue,
+ BasicBlock::iterator InsertBefore) {
+ return new(1) BranchInst(IfTrue, InsertBefore);
+ }
+
static BranchInst *Create(BasicBlock *IfTrue,
Instruction *InsertBefore = nullptr) {
return new(1) BranchInst(IfTrue, InsertBefore);
}
+ static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
+ Value *Cond, BasicBlock::iterator InsertBefore) {
+ return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
+ }
+
static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
Value *Cond, Instruction *InsertBefore = nullptr) {
return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
@@ -3304,6 +3594,13 @@ class SwitchInst : public Instruction {
// Operand[2n+1] = BasicBlock to go to on match
SwitchInst(const SwitchInst &SI);
+ /// Create a new switch instruction, specifying a value to switch on and a
+ /// default destination. The number of additional cases can be specified here
+ /// to make memory allocation more efficient. This constructor can also
+ /// auto-insert before another instruction.
+ SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
+ BasicBlock::iterator InsertBefore);
+
/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor can also
@@ -3484,6 +3781,12 @@ class SwitchInst : public Instruction {
using CaseIt = CaseIteratorImpl<CaseHandle>;
using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;
+ static SwitchInst *Create(Value *Value, BasicBlock *Default,
+ unsigned NumCases,
+ BasicBlock::iterator InsertBefore) {
+ return new SwitchInst(Value, Default, NumCases, InsertBefore);
+ }
+
static SwitchInst *Create(Value *Value, BasicBlock *Default,
unsigned NumCases,
Instruction *InsertBefore = nullptr) {
@@ -3704,6 +4007,13 @@ class IndirectBrInst : public Instruction {
// Operand[n+1] = n-th destination
IndirectBrInst(const IndirectBrInst &IBI);
+ /// Create a new indirectbr instruction, specifying an
+ /// Address to jump to. The number of expected destinations can be specified
+ /// here to make memory allocation more efficient. This constructor can also
+ /// autoinsert before another instruction.
+ IndirectBrInst(Value *Address, unsigned NumDests,
+ BasicBlock::iterator InsertBefore);
+
/// Create a new indirectbr instruction, specifying an
/// Address to jump to. The number of expected destinations can be specified
/// here to make memory allocation more efficient. This constructor can also
@@ -3758,6 +4068,11 @@ class IndirectBrInst : public Instruction {
const BasicBlock *operator->() const { return operator*(); }
};
+ static IndirectBrInst *Create(Value *Address, unsigned NumDests,
+ BasicBlock::iterator InsertBefore) {
+ return new IndirectBrInst(Address, NumDests, InsertBefore);
+ }
+
static IndirectBrInst *Create(Value *Address, unsigned NumDests,
Instruction *InsertBefore = nullptr) {
return new IndirectBrInst(Address, NumDests, InsertBefore);
@@ -3845,6 +4160,12 @@ class InvokeInst : public CallBase {
InvokeInst(const InvokeInst &BI);
+ /// Construct an InvokeInst given a range of arguments.
+ inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, int NumOperands,
+ const Twine &NameStr, BasicBlock::iterator InsertBefore);
+
/// Construct an InvokeInst given a range of arguments.
///
/// Construct an InvokeInst from a range of arguments
@@ -3876,6 +4197,16 @@ class InvokeInst : public CallBase {
InvokeInst *cloneImpl() const;
public:
+ static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ int NumOperands = ComputeNumOperands(Args.size());
+ return new (NumOperands)
+ InvokeInst(Ty, Func, IfNormal, IfException, Args, std::nullopt,
+ NumOperands, NameStr, InsertBefore);
+ }
+
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr,
@@ -3886,6 +4217,20 @@ class InvokeInst : public CallBase {
NumOperands, NameStr, InsertBefore);
}
+ static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ int NumOperands =
+ ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
+ unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
+
+ return new (NumOperands, DescriptorBytes)
+ InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
+ NameStr, InsertBefore);
+ }
+
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = std::nullopt,
@@ -3922,6 +4267,14 @@ class InvokeInst : public CallBase {
NameStr, InsertAtEnd);
}
+ static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
+ IfException, Args, std::nullopt, NameStr, InsertBefore);
+ }
+
static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
const Twine &NameStr,
@@ -3930,6 +4283,15 @@ class InvokeInst : public CallBase {
IfException, Args, std::nullopt, NameStr, InsertBefore);
}
+ static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
+ IfException, Args, Bundles, NameStr, InsertBefore);
+ }
+
static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles = std::nullopt,
@@ -3960,6 +4322,8 @@ class InvokeInst : public CallBase {
/// 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
/// bundles in \p Bundles.
+ static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
+ BasicBlock::iterator InsertPt);
static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
Instruction *InsertPt = nullptr);
@@ -4013,6 +4377,16 @@ class InvokeInst : public CallBase {
}
};
+InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
+ BasicBlock *IfException, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, int NumOperands,
+ const Twine &NameStr, BasicBlock::iterator InsertBefore)
+ : CallBase(Ty->getReturnType(), Instruction::Invoke,
+ OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
+ InsertBefore) {
+ init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
+}
+
InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException, ArrayRef<Value *> Args,
ArrayRef<OperandBundleDef> Bundles, int NumOperands,
@@ -4047,6 +4421,13 @@ class CallBrInst : public CallBase {
CallBrInst(const CallBrInst &BI);
+ /// Construct a CallBrInst given a range of arguments.
+ inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests,
+ ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
+ int NumOperands, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
+
/// Construct a CallBrInst given a range of arguments.
///
/// Construct a CallBrInst from a range of arguments
@@ -4081,6 +4462,17 @@ class CallBrInst : public CallBase {
CallBrInst *cloneImpl() const;
public:
+ static CallBrInst *Create(FunctionType *Ty, Value *Func,
+ BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests,
+ ArrayRef<Value *> Args, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
+ return new (NumOperands)
+ CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, std::nullopt,
+ NumOperands, NameStr, InsertBefore);
+ }
+
static CallBrInst *Create(FunctionType *Ty, Value *Func,
BasicBlock *DefaultDest,
ArrayRef<BasicBlock *> IndirectDests,
@@ -4092,6 +4484,20 @@ class CallBrInst : public CallBase {
NumOperands, NameStr, InsertBefore);
}
+ static CallBrInst *
+ Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
+ CountBundleInputs(Bundles));
+ unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
+
+ return new (NumOperands, DescriptorBytes)
+ CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
+ NumOperands, NameStr, InsertBefore);
+ }
+
static CallBrInst *
Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
@@ -4132,6 +4538,14 @@ class CallBrInst : public CallBase {
NumOperands, NameStr, InsertAtEnd);
}
+ static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests,
+ ArrayRef<Value *> Args, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
+ IndirectDests, Args, NameStr, InsertBefore);
+ }
+
static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
ArrayRef<BasicBlock *> IndirectDests,
ArrayRef<Value *> Args, const Twine &NameStr,
@@ -4140,6 +4554,16 @@ class CallBrInst : public CallBase {
IndirectDests, Args, NameStr, InsertBefore);
}
+ static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests,
+ ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
+ IndirectDests, Args, Bundles, NameStr, InsertBefore);
+ }
+
static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
ArrayRef<BasicBlock *> IndirectDests,
ArrayRef<Value *> Args,
@@ -4174,6 +4598,8 @@ class CallBrInst : public CallBase {
/// The returned callbr instruction is identical to \p CBI in every way
/// except that the operand bundles for the new instruction are set to the
/// operand bundles in \p Bundles.
+ static CallBrInst *Create(CallBrInst *CBI, ArrayRef<OperandBundleDef> Bundles,
+ BasicBlock::iterator InsertPt);
static CallBrInst *Create(CallBrInst *CBI,
ArrayRef<OperandBundleDef> Bundles,
Instruction *InsertPt = nullptr);
@@ -4245,6 +4671,17 @@ class CallBrInst : public CallBase {
}
};
+CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
+ ArrayRef<BasicBlock *> IndirectDests,
+ ArrayRef<Value *> Args,
+ ArrayRef<OperandBundleDef> Bundles, int NumOperands,
+ const Twine &NameStr, BasicBlock::iterator InsertBefore)
+ : CallBase(Ty->getReturnType(), Instruction::CallBr,
+ OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
+ InsertBefore) {
+ init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
+}
+
CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
ArrayRef<BasicBlock *> IndirectDests,
ArrayRef<Value *> Args,
@@ -4278,6 +4715,7 @@ class ResumeInst : public Instruction {
ResumeInst(const ResumeInst &RI);
explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
+ explicit ResumeInst(Value *Exn, BasicBlock::iterator InsertBefore);
ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
protected:
@@ -4287,6 +4725,10 @@ class ResumeInst : public Instruction {
ResumeInst *cloneImpl() const;
public:
+ static ResumeInst *Create(Value *Exn, BasicBlock::iterator InsertBefore) {
+ return new (1) ResumeInst(Exn, InsertBefore);
+ }
+
static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
return new(1) ResumeInst(Exn, InsertBefore);
}
@@ -4343,6 +4785,14 @@ class CatchSwitchInst : public Instruction {
// Operand[n] = BasicBlock to go to on match
CatchSwitchInst(const CatchSwitchInst &CSI);
+ /// Create a new switch instruction, specifying a
+ /// default destination. The number of additional handlers can be specified
+ /// here to make memory allocation more efficient.
+ /// This constructor can also autoinsert before another instruction.
+ CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
+ unsigned NumHandlers, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
+
/// Create a new switch instruction, specifying a
/// default destination. The number of additional handlers can be specified
/// here to make memory allocation more efficient.
@@ -4374,6 +4824,13 @@ class CatchSwitchInst : public Instruction {
public:
void operator delete(void *Ptr) { return User::operator delete(Ptr); }
+ static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
+ unsigned NumHandlers, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
+ InsertBefore);
+ }
+
static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
unsigned NumHandlers,
const Twine &NameStr = "",
@@ -4511,6 +4968,11 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)
//===----------------------------------------------------------------------===//
class CleanupPadInst : public FuncletPadInst {
private:
+ explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
+ unsigned Values, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
+ NameStr, InsertBefore) {}
explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
unsigned Values, const Twine &NameStr,
Instruction *InsertBefore)
@@ -4523,6 +4985,14 @@ class CleanupPadInst : public FuncletPadInst {
NameStr, InsertAtEnd) {}
public:
+ static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ unsigned Values = 1 + Args.size();
+ return new (Values)
+ CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
+ }
+
static CleanupPadInst *Create(Value *ParentPad,
ArrayRef<Value *> Args = std::nullopt,
const Twine &NameStr = "",
@@ -4553,6 +5023,11 @@ class CleanupPadInst : public FuncletPadInst {
//===----------------------------------------------------------------------===//
class CatchPadInst : public FuncletPadInst {
private:
+ explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
+ unsigned Values, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
+ NameStr, InsertBefore) {}
explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
unsigned Values, const Twine &NameStr,
Instruction *InsertBefore)
@@ -4565,6 +5040,14 @@ class CatchPadInst : public FuncletPadInst {
NameStr, InsertAtEnd) {}
public:
+ static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore) {
+ unsigned Values = 1 + Args.size();
+ return new (Values)
+ CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
+ }
+
static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr) {
@@ -4604,6 +5087,8 @@ class CatchPadInst : public FuncletPadInst {
class CatchReturnInst : public Instruction {
CatchReturnInst(const CatchReturnInst &RI);
+ CatchReturnInst(Value *CatchPad, BasicBlock *BB,
+ BasicBlock::iterator InsertBefore);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
@@ -4616,6 +5101,13 @@ class CatchReturnInst : public Instruction {
CatchReturnInst *cloneImpl() const;
public:
+ static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
+ BasicBlock::iterator InsertBefore) {
+ assert(CatchPad);
+ assert(BB);
+ return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
+ }
+
static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
Instruction *InsertBefore = nullptr) {
assert(CatchPad);
@@ -4688,6 +5180,8 @@ class CleanupReturnInst : public Instruction {
private:
CleanupReturnInst(const CleanupReturnInst &RI);
+ CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
+ BasicBlock::iterator InsertBefore);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
Instruction *InsertBefore = nullptr);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
@@ -4702,6 +5196,16 @@ class CleanupReturnInst : public Instruction {
CleanupReturnInst *cloneImpl() const;
public:
+ static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
+ BasicBlock::iterator InsertBefore) {
+ assert(CleanupPad);
+ unsigned Values = 1;
+ if (UnwindBB)
+ ++Values;
+ return new (Values)
+ CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
+ }
+
static CleanupReturnInst *Create(Value *CleanupPad,
BasicBlock *UnwindBB = nullptr,
Instruction *InsertBefore = nullptr) {
@@ -4799,6 +5303,7 @@ class UnreachableInst : public Instruction {
UnreachableInst *cloneImpl() const;
public:
+ explicit UnreachableInst(LLVMContext &C, BasicBlock::iterator InsertBefore);
explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
@@ -4840,6 +5345,14 @@ class TruncInst : public CastInst {
TruncInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ TruncInst(
+ Value *S, ///< The value to be truncated
+ Type *Ty, ///< The (smaller) type to truncate to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
TruncInst(
Value *S, ///< The value to be truncated
@@ -4879,6 +5392,14 @@ class ZExtInst : public CastInst {
ZExtInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ ZExtInst(
+ Value *S, ///< The value to be zero extended
+ Type *Ty, ///< The type to zero extend to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
ZExtInst(
Value *S, ///< The value to be zero extended
@@ -4918,6 +5439,14 @@ class SExtInst : public CastInst {
SExtInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ SExtInst(
+ Value *S, ///< The value to be sign extended
+ Type *Ty, ///< The type to sign extend to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
SExtInst(
Value *S, ///< The value to be sign extended
@@ -4957,6 +5486,14 @@ class FPTruncInst : public CastInst {
FPTruncInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ FPTruncInst(
+ Value *S, ///< The value to be truncated
+ Type *Ty, ///< The type to truncate to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
FPTruncInst(
Value *S, ///< The value to be truncated
@@ -4996,6 +5533,14 @@ class FPExtInst : public CastInst {
FPExtInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ FPExtInst(
+ Value *S, ///< The value to be extended
+ Type *Ty, ///< The type to extend to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
FPExtInst(
Value *S, ///< The value to be extended
@@ -5035,6 +5580,14 @@ class UIToFPInst : public CastInst {
UIToFPInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ UIToFPInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
UIToFPInst(
Value *S, ///< The value to be converted
@@ -5074,6 +5627,14 @@ class SIToFPInst : public CastInst {
SIToFPInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ SIToFPInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
SIToFPInst(
Value *S, ///< The value to be converted
@@ -5113,6 +5674,14 @@ class FPToUIInst : public CastInst {
FPToUIInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ FPToUIInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
FPToUIInst(
Value *S, ///< The value to be converted
@@ -5152,6 +5721,14 @@ class FPToSIInst : public CastInst {
FPToSIInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ FPToSIInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
FPToSIInst(
Value *S, ///< The value to be converted
@@ -5187,6 +5764,14 @@ class IntToPtrInst : public CastInst {
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;
+ /// Constructor with insert-before-instruction semantics
+ IntToPtrInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
IntToPtrInst(
Value *S, ///< The value to be converted
@@ -5234,6 +5819,14 @@ class PtrToIntInst : public CastInst {
PtrToIntInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ PtrToIntInst(
+ Value *S, ///< The value to be converted
+ Type *Ty, ///< The type to convert to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
PtrToIntInst(
Value *S, ///< The value to be converted
@@ -5285,6 +5878,14 @@ class BitCastInst : public CastInst {
BitCastInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ BitCastInst(
+ Value *S, ///< The value to be casted
+ Type *Ty, ///< The type to casted to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
BitCastInst(
Value *S, ///< The value to be casted
@@ -5325,6 +5926,14 @@ class AddrSpaceCastInst : public CastInst {
AddrSpaceCastInst *cloneImpl() const;
public:
+ /// Constructor with insert-before-instruction semantics
+ AddrSpaceCastInst(
+ Value *S, ///< The value to be casted
+ Type *Ty, ///< The type to casted to
+ const Twine &NameStr, ///< A name for the new instruction
+ BasicBlock::iterator InsertBefore ///< Where to insert the new instruction
+ );
+
/// Constructor with insert-before-instruction semantics
AddrSpaceCastInst(
Value *S, ///< The value to be casted
@@ -5467,6 +6076,8 @@ class FreezeInst : public UnaryInstruction {
FreezeInst *cloneImpl() const;
public:
+ explicit FreezeInst(Value *S, const Twine &NameStr,
+ BasicBlock::iterator InsertBefore);
explicit FreezeInst(Value *S,
const Twine &NameStr = "",
Instruction *InsertBefore = nullptr);
diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp
index 345b050b7077a9..c54f8d7aca4a96 100644
--- a/llvm/lib/IR/Instruction.cpp
+++ b/llvm/lib/IR/Instruction.cpp
@@ -22,6 +22,16 @@
#include "llvm/IR/Type.h"
using namespace llvm;
+Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
+ InstListType::iterator InsertBefore)
+ : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
+
+ // When called with an iterator, there must be a block to insert into.
+ BasicBlock *BB = InsertBefore->getParent();
+ assert(BB && "Instruction to insert before is not in a basic block!");
+ insertInto(BB, InsertBefore);
+}
+
Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
Instruction *InsertBefore)
: User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp
index fc5c9b201487e0..25778570ebf34a 100644
--- a/llvm/lib/IR/Instructions.cpp
+++ b/llvm/lib/IR/Instructions.cpp
@@ -230,6 +230,13 @@ bool PHINode::hasConstantOrUndefValue() const {
// LandingPadInst Implementation
//===----------------------------------------------------------------------===//
+LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
+ init(NumReservedValues, NameStr);
+}
+
LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
const Twine &NameStr, Instruction *InsertBefore)
: Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertBefore) {
@@ -736,6 +743,20 @@ CallInst::CallInst(const CallInst &CI)
SubclassOptionalData = CI.SubclassOptionalData;
}
+CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
+ BasicBlock::iterator InsertPt) {
+ std::vector<Value *> Args(CI->arg_begin(), CI->arg_end());
+
+ auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledOperand(),
+ Args, OpB, CI->getName(), InsertPt);
+ NewCI->setTailCallKind(CI->getTailCallKind());
+ NewCI->setCallingConv(CI->getCallingConv());
+ NewCI->SubclassOptionalData = CI->SubclassOptionalData;
+ NewCI->setAttributes(CI->getAttributes());
+ NewCI->setDebugLoc(CI->getDebugLoc());
+ return NewCI;
+}
+
CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
Instruction *InsertPt) {
std::vector<Value *> Args(CI->arg_begin(), CI->arg_end());
@@ -960,7 +981,17 @@ ReturnInst::ReturnInst(const ReturnInst &RI)
SubclassOptionalData = RI.SubclassOptionalData;
}
-ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore)
+ReturnInst::ReturnInst(LLVMContext &C, Value *retVal,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(C), Instruction::Ret,
+ OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
+ InsertBefore) {
+ if (retVal)
+ Op<0>() = retVal;
+}
+
+ReturnInst::ReturnInst(LLVMContext &C, Value *retVal,
+ Instruction *InsertBefore)
: Instruction(Type::getVoidTy(C), Instruction::Ret,
OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
InsertBefore) {
@@ -990,6 +1021,12 @@ ResumeInst::ResumeInst(const ResumeInst &RI)
Op<0>() = RI.Op<0>();
}
+ResumeInst::ResumeInst(Value *Exn, BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
+ OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
+ Op<0>() = Exn;
+}
+
ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
: Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
@@ -1027,6 +1064,16 @@ void CleanupReturnInst::init(Value *CleanupPad, BasicBlock *UnwindBB) {
Op<1>() = UnwindBB;
}
+CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
+ unsigned Values,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(CleanupPad->getContext()),
+ Instruction::CleanupRet,
+ OperandTraits<CleanupReturnInst>::op_end(this) - Values,
+ Values, InsertBefore) {
+ init(CleanupPad, UnwindBB);
+}
+
CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
unsigned Values, Instruction *InsertBefore)
: Instruction(Type::getVoidTy(CleanupPad->getContext()),
@@ -1060,6 +1107,14 @@ CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI)
Op<1>() = CRI.Op<1>();
}
+CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
+ OperandTraits<CatchReturnInst>::op_begin(this), 2,
+ InsertBefore) {
+ init(CatchPad, BB);
+}
+
CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
Instruction *InsertBefore)
: Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
@@ -1179,6 +1234,16 @@ FuncletPadInst::FuncletPadInst(const FuncletPadInst &FPI)
setParentPad(FPI.getParentPad());
}
+FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
+ ArrayRef<Value *> Args, unsigned Values,
+ const Twine &NameStr,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(ParentPad->getType(), Op,
+ OperandTraits<FuncletPadInst>::op_end(this) - Values, Values,
+ InsertBefore) {
+ init(ParentPad, Args, NameStr);
+}
+
FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
ArrayRef<Value *> Args, unsigned Values,
const Twine &NameStr, Instruction *InsertBefore)
@@ -1201,6 +1266,10 @@ FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
// UnreachableInst Implementation
//===----------------------------------------------------------------------===//
+UnreachableInst::UnreachableInst(LLVMContext &Context,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
+ 0, InsertBefore) {}
UnreachableInst::UnreachableInst(LLVMContext &Context,
Instruction *InsertBefore)
: Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
@@ -1219,6 +1288,14 @@ void BranchInst::AssertOK() {
"May only branch on boolean predicates!");
}
+BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
+ OperandTraits<BranchInst>::op_end(this) - 1, 1,
+ InsertBefore) {
+ assert(IfTrue && "Branch destination may not be null!");
+ Op<-1>() = IfTrue;
+}
+
BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore)
: Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
OperandTraits<BranchInst>::op_end(this) - 1, 1,
@@ -1227,6 +1304,20 @@ BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore)
Op<-1>() = IfTrue;
}
+BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
+ OperandTraits<BranchInst>::op_end(this) - 3, 3,
+ InsertBefore) {
+ // Assign in order of operand index to make use-list order predictable.
+ Op<-3>() = Cond;
+ Op<-2>() = IfFalse;
+ Op<-1>() = IfTrue;
+#ifndef NDEBUG
+ AssertOK();
+#endif
+}
+
BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
Instruction *InsertBefore)
: Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
@@ -1309,11 +1400,19 @@ static Align computeAllocaDefaultAlign(Type *Ty, BasicBlock *BB) {
return DL.getPrefTypeAlign(Ty);
}
+static Align computeAllocaDefaultAlign(Type *Ty, BasicBlock::iterator It) {
+ return computeAllocaDefaultAlign(Ty, It->getParent());
+}
+
static Align computeAllocaDefaultAlign(Type *Ty, Instruction *I) {
assert(I && "Insertion position cannot be null when alignment not provided!");
return computeAllocaDefaultAlign(Ty, I->getParent());
}
+AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertBefore) {}
+
AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
Instruction *InsertBefore)
: AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertBefore) {}
@@ -1322,6 +1421,12 @@ AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
BasicBlock *InsertAtEnd)
: AllocaInst(Ty, AddrSpace, /*ArraySize=*/nullptr, Name, InsertAtEnd) {}
+AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
+ const Twine &Name, BasicBlock::iterator InsertBefore)
+ : AllocaInst(Ty, AddrSpace, ArraySize,
+ computeAllocaDefaultAlign(Ty, InsertBefore), Name,
+ InsertBefore) {}
+
AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
const Twine &Name, Instruction *InsertBefore)
: AllocaInst(Ty, AddrSpace, ArraySize,
@@ -1334,6 +1439,17 @@ AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
computeAllocaDefaultAlign(Ty, InsertAtEnd), Name,
InsertAtEnd) {}
+AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
+ Align Align, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca,
+ getAISize(Ty->getContext(), ArraySize), InsertBefore),
+ AllocatedType(Ty) {
+ setAlignment(Align);
+ assert(!Ty->isVoidTy() && "Cannot allocate void!");
+ setName(Name);
+}
+
AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
Align Align, const Twine &Name,
Instruction *InsertBefore)
@@ -1391,11 +1507,19 @@ static Align computeLoadStoreDefaultAlign(Type *Ty, BasicBlock *BB) {
return DL.getABITypeAlign(Ty);
}
+static Align computeLoadStoreDefaultAlign(Type *Ty, BasicBlock::iterator It) {
+ return computeLoadStoreDefaultAlign(Ty, It->getParent());
+}
+
static Align computeLoadStoreDefaultAlign(Type *Ty, Instruction *I) {
assert(I && "Insertion position cannot be null when alignment not provided!");
return computeLoadStoreDefaultAlign(Ty, I->getParent());
}
+LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
+ BasicBlock::iterator InsertBef)
+ : LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertBef) {}
+
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
Instruction *InsertBef)
: LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertBef) {}
@@ -1404,6 +1528,11 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
BasicBlock *InsertAE)
: LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertAE) {}
+LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
+ BasicBlock::iterator InsertBef)
+ : LoadInst(Ty, Ptr, Name, isVolatile,
+ computeLoadStoreDefaultAlign(Ty, InsertBef), InsertBef) {}
+
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
Instruction *InsertBef)
: LoadInst(Ty, Ptr, Name, isVolatile,
@@ -1414,6 +1543,11 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
: LoadInst(Ty, Ptr, Name, isVolatile,
computeLoadStoreDefaultAlign(Ty, InsertAE), InsertAE) {}
+LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
+ Align Align, BasicBlock::iterator InsertBef)
+ : LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic,
+ SyncScope::System, InsertBef) {}
+
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
Align Align, Instruction *InsertBef)
: LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic,
@@ -1424,6 +1558,17 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
: LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic,
SyncScope::System, InsertAE) {}
+LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
+ Align Align, AtomicOrdering Order, SyncScope::ID SSID,
+ BasicBlock::iterator InsertBef)
+ : UnaryInstruction(Ty, Load, Ptr, InsertBef) {
+ setVolatile(isVolatile);
+ setAlignment(Align);
+ setAtomic(Order, SSID);
+ AssertOK();
+ setName(Name);
+}
+
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
Align Align, AtomicOrdering Order, SyncScope::ID SSID,
Instruction *InsertBef)
@@ -1565,6 +1710,19 @@ void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal,
"Cmp type and NewVal type must be same!");
}
+AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
+ Align Alignment,
+ AtomicOrdering SuccessOrdering,
+ AtomicOrdering FailureOrdering,
+ SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(
+ StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())),
+ AtomicCmpXchg, OperandTraits<AtomicCmpXchgInst>::op_begin(this),
+ OperandTraits<AtomicCmpXchgInst>::operands(this), InsertBefore) {
+ Init(Ptr, Cmp, NewVal, Alignment, SuccessOrdering, FailureOrdering, SSID);
+}
+
AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
Align Alignment,
AtomicOrdering SuccessOrdering,
@@ -1617,6 +1775,16 @@ void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val,
"AtomicRMW instructions must be atomic!");
}
+AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
+ Align Alignment, AtomicOrdering Ordering,
+ SyncScope::ID SSID,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Val->getType(), AtomicRMW,
+ OperandTraits<AtomicRMWInst>::op_begin(this),
+ OperandTraits<AtomicRMWInst>::operands(this), InsertBefore) {
+ Init(Operation, Ptr, Val, Alignment, Ordering, SSID);
+}
+
AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
Align Alignment, AtomicOrdering Ordering,
SyncScope::ID SSID, Instruction *InsertBefore)
@@ -1682,6 +1850,13 @@ StringRef AtomicRMWInst::getOperationName(BinOp Op) {
// FenceInst Implementation
//===----------------------------------------------------------------------===//
+FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
+ SyncScope::ID SSID, BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) {
+ setOrdering(Ordering);
+ setSyncScopeID(SSID);
+}
+
FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering,
SyncScope::ID SSID,
Instruction *InsertBefore)
@@ -1827,6 +2002,19 @@ bool GetElementPtrInst::collectOffset(
// ExtractElementInst Implementation
//===----------------------------------------------------------------------===//
+ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
+ const Twine &Name,
+ BasicBlock::iterator InsertBef)
+ : Instruction(
+ cast<VectorType>(Val->getType())->getElementType(), ExtractElement,
+ OperandTraits<ExtractElementInst>::op_begin(this), 2, InsertBef) {
+ assert(isValidOperands(Val, Index) &&
+ "Invalid extractelement instruction operands!");
+ Op<0>() = Val;
+ Op<1>() = Index;
+ setName(Name);
+}
+
ExtractElementInst::ExtractElementInst(Value *Val, Value *Index,
const Twine &Name,
Instruction *InsertBef)
@@ -1866,6 +2054,20 @@ bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) {
// InsertElementInst Implementation
//===----------------------------------------------------------------------===//
+InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
+ const Twine &Name,
+ BasicBlock::iterator InsertBef)
+ : Instruction(Vec->getType(), InsertElement,
+ OperandTraits<InsertElementInst>::op_begin(this), 3,
+ InsertBef) {
+ assert(isValidOperands(Vec, Elt, Index) &&
+ "Invalid insertelement instruction operands!");
+ Op<0>() = Vec;
+ Op<1>() = Elt;
+ Op<2>() = Index;
+ setName(Name);
+}
+
InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
const Twine &Name,
Instruction *InsertBef)
@@ -1917,6 +2119,11 @@ static Value *createPlaceholderForShuffleVector(Value *V) {
return PoisonValue::get(V->getType());
}
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *Mask, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name,
+ InsertBefore) {}
+
ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *Mask, const Twine &Name,
Instruction *InsertBefore)
: ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name,
@@ -1927,6 +2134,12 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *Mask, const Twine &Name,
: ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name,
InsertAtEnd) {}
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef<int> Mask,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name,
+ InsertBefore) {}
+
ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef<int> Mask,
const Twine &Name,
Instruction *InsertBefore)
@@ -1938,6 +2151,25 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef<int> Mask,
: ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name,
InsertAtEnd) {}
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(
+ VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
+ cast<VectorType>(Mask->getType())->getElementCount()),
+ ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this),
+ OperandTraits<ShuffleVectorInst>::operands(this), InsertBefore) {
+ assert(isValidOperands(V1, V2, Mask) &&
+ "Invalid shuffle vector instruction operands!");
+
+ Op<0>() = V1;
+ Op<1>() = V2;
+ SmallVector<int, 16> MaskArr;
+ getShuffleMask(cast<Constant>(Mask), MaskArr);
+ setShuffleMask(MaskArr);
+ setName(Name);
+}
+
ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
const Twine &Name,
Instruction *InsertBefore)
@@ -1975,6 +2207,22 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
setName(Name);
}
+ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(
+ VectorType::get(cast<VectorType>(V1->getType())->getElementType(),
+ Mask.size(), isa<ScalableVectorType>(V1->getType())),
+ ShuffleVector, OperandTraits<ShuffleVectorInst>::op_begin(this),
+ OperandTraits<ShuffleVectorInst>::operands(this), InsertBefore) {
+ assert(isValidOperands(V1, V2, Mask) &&
+ "Invalid shuffle vector instruction operands!");
+ Op<0>() = V1;
+ Op<1>() = V2;
+ setShuffleMask(Mask);
+ setName(Name);
+}
+
ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
const Twine &Name,
Instruction *InsertBefore)
@@ -2802,6 +3050,15 @@ Type *ExtractValueInst::getIndexedType(Type *Agg,
// UnaryOperator Class
//===----------------------------------------------------------------------===//
+UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(Ty, iType, S, InsertBefore) {
+ Op<0>() = S;
+ setName(Name);
+ AssertOK();
+}
+
UnaryOperator::UnaryOperator(UnaryOps iType, Value *S,
Type *Ty, const Twine &Name,
Instruction *InsertBefore)
@@ -2820,6 +3077,11 @@ UnaryOperator::UnaryOperator(UnaryOps iType, Value *S,
AssertOK();
}
+UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore);
+}
+
UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S,
const Twine &Name,
Instruction *InsertBefore) {
@@ -2855,6 +3117,17 @@ void UnaryOperator::AssertOK() {
// BinaryOperator Class
//===----------------------------------------------------------------------===//
+BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Ty, iType, OperandTraits<BinaryOperator>::op_begin(this),
+ OperandTraits<BinaryOperator>::operands(this), InsertBefore) {
+ Op<0>() = S1;
+ Op<1>() = S2;
+ setName(Name);
+ AssertOK();
+}
+
BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
Type *Ty, const Twine &Name,
Instruction *InsertBefore)
@@ -2965,6 +3238,13 @@ BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2,
return Res;
}
+BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ Value *Zero = ConstantInt::get(Op->getType(), 0);
+ return new BinaryOperator(Instruction::Sub, Zero, Op, Op->getType(), Name,
+ InsertBefore);
+}
+
BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name,
Instruction *InsertBefore) {
Value *Zero = ConstantInt::get(Op->getType(), 0);
@@ -3324,6 +3604,29 @@ unsigned CastInst::isEliminableCastPair(
}
}
+CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ assert(castIsValid(op, S, Ty) && "Invalid cast!");
+ // Construct and return the appropriate CastInst subclass
+ switch (op) {
+ case Trunc: return new TruncInst (S, Ty, Name, InsertBefore);
+ case ZExt: return new ZExtInst (S, Ty, Name, InsertBefore);
+ case SExt: return new SExtInst (S, Ty, Name, InsertBefore);
+ case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertBefore);
+ case FPExt: return new FPExtInst (S, Ty, Name, InsertBefore);
+ case UIToFP: return new UIToFPInst (S, Ty, Name, InsertBefore);
+ case SIToFP: return new SIToFPInst (S, Ty, Name, InsertBefore);
+ case FPToUI: return new FPToUIInst (S, Ty, Name, InsertBefore);
+ case FPToSI: return new FPToSIInst (S, Ty, Name, InsertBefore);
+ case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertBefore);
+ case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertBefore);
+ case BitCast: return new BitCastInst (S, Ty, Name, InsertBefore);
+ case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertBefore);
+ default: llvm_unreachable("Invalid opcode provided");
+ }
+}
+
CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
const Twine &Name, Instruction *InsertBefore) {
assert(castIsValid(op, S, Ty) && "Invalid cast!");
@@ -3368,6 +3671,13 @@ CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
}
}
+CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
+ return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
+ return Create(Instruction::ZExt, S, Ty, Name, InsertBefore);
+}
+
CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
const Twine &Name,
Instruction *InsertBefore) {
@@ -3384,6 +3694,13 @@ CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
return Create(Instruction::ZExt, S, Ty, Name, InsertAtEnd);
}
+CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
+ return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
+ return Create(Instruction::SExt, S, Ty, Name, InsertBefore);
+}
+
CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
const Twine &Name,
Instruction *InsertBefore) {
@@ -3400,6 +3717,13 @@ CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd);
}
+CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
+ return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
+ return Create(Instruction::Trunc, S, Ty, Name, InsertBefore);
+}
+
CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty,
const Twine &Name,
Instruction *InsertBefore) {
@@ -3435,8 +3759,25 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
}
/// Create a BitCast or a PtrToInt cast instruction
-CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
- const Twine &Name,
+CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
+ assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
+ "Invalid cast");
+ assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
+ assert((!Ty->isVectorTy() ||
+ cast<VectorType>(Ty)->getElementCount() ==
+ cast<VectorType>(S->getType())->getElementCount()) &&
+ "Invalid cast");
+
+ if (Ty->isIntOrIntVectorTy())
+ return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
+
+ return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertBefore);
+}
+
+/// Create a BitCast or a PtrToInt cast instruction
+CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name,
Instruction *InsertBefore) {
assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) &&
@@ -3467,9 +3808,18 @@ CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
}
CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
- Value *S, Type *Ty,
- const Twine &Name,
- Instruction *InsertBefore) {
+ Value *S, Type *Ty, const Twine &Name, BasicBlock::iterator InsertBefore) {
+ assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
+ assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
+
+ if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace())
+ return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertBefore);
+
+ return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
+}
+
+CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
+ Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore) {
assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast");
assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast");
@@ -3490,6 +3840,20 @@ CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty,
return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
}
+CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, bool isSigned,
+ const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() &&
+ "Invalid integer cast");
+ unsigned SrcBits = C->getType()->getScalarSizeInBits();
+ unsigned DstBits = Ty->getScalarSizeInBits();
+ Instruction::CastOps opcode =
+ (SrcBits == DstBits ? Instruction::BitCast :
+ (SrcBits > DstBits ? Instruction::Trunc :
+ (isSigned ? Instruction::SExt : Instruction::ZExt)));
+ return Create(opcode, C, Ty, Name, InsertBefore);
+}
+
CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
bool isSigned, const Twine &Name,
Instruction *InsertBefore) {
@@ -3518,6 +3882,18 @@ CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
return Create(opcode, C, Ty, Name, InsertAtEnd);
}
+CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore) {
+ assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() &&
+ "Invalid cast");
+ unsigned SrcBits = C->getType()->getScalarSizeInBits();
+ unsigned DstBits = Ty->getScalarSizeInBits();
+ Instruction::CastOps opcode =
+ (SrcBits == DstBits ? Instruction::BitCast :
+ (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
+ return Create(opcode, C, Ty, Name, InsertBefore);
+}
+
CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
const Twine &Name,
Instruction *InsertBefore) {
@@ -3809,6 +4185,12 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
}
}
+TruncInst::TruncInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, Trunc, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
+}
+
TruncInst::TruncInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, Trunc, S, Name, InsertBefore) {
@@ -3821,6 +4203,12 @@ TruncInst::TruncInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
}
+ZExtInst::ZExtInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, ZExt, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
+}
+
ZExtInst::ZExtInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, ZExt, S, Name, InsertBefore) {
@@ -3832,6 +4220,13 @@ ZExtInst::ZExtInst(
) : CastInst(Ty, ZExt, S, Name, InsertAtEnd) {
assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt");
}
+
+SExtInst::SExtInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, SExt, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
+}
+
SExtInst::SExtInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, SExt, S, Name, InsertBefore) {
@@ -3844,6 +4239,12 @@ SExtInst::SExtInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt");
}
+FPTruncInst::FPTruncInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
+}
+
FPTruncInst::FPTruncInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, FPTrunc, S, Name, InsertBefore) {
@@ -3856,6 +4257,12 @@ FPTruncInst::FPTruncInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc");
}
+FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, FPExt, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
+}
+
FPExtInst::FPExtInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, FPExt, S, Name, InsertBefore) {
@@ -3868,6 +4275,12 @@ FPExtInst::FPExtInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt");
}
+UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
+}
+
UIToFPInst::UIToFPInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, UIToFP, S, Name, InsertBefore) {
@@ -3880,6 +4293,12 @@ UIToFPInst::UIToFPInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP");
}
+SIToFPInst::SIToFPInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
+}
+
SIToFPInst::SIToFPInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, SIToFP, S, Name, InsertBefore) {
@@ -3892,6 +4311,12 @@ SIToFPInst::SIToFPInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP");
}
+FPToUIInst::FPToUIInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
+}
+
FPToUIInst::FPToUIInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, FPToUI, S, Name, InsertBefore) {
@@ -3904,6 +4329,12 @@ FPToUIInst::FPToUIInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI");
}
+FPToSIInst::FPToSIInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
+}
+
FPToSIInst::FPToSIInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, FPToSI, S, Name, InsertBefore) {
@@ -3916,6 +4347,12 @@ FPToSIInst::FPToSIInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI");
}
+PtrToIntInst::PtrToIntInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
+}
+
PtrToIntInst::PtrToIntInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, PtrToInt, S, Name, InsertBefore) {
@@ -3928,6 +4365,12 @@ PtrToIntInst::PtrToIntInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt");
}
+IntToPtrInst::IntToPtrInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
+}
+
IntToPtrInst::IntToPtrInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, IntToPtr, S, Name, InsertBefore) {
@@ -3940,6 +4383,12 @@ IntToPtrInst::IntToPtrInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr");
}
+BitCastInst::BitCastInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, BitCast, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
+}
+
BitCastInst::BitCastInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, BitCast, S, Name, InsertBefore) {
@@ -3952,6 +4401,12 @@ BitCastInst::BitCastInst(
assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
}
+AddrSpaceCastInst::AddrSpaceCastInst(Value *S, Type *Ty, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
+ assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
+}
+
AddrSpaceCastInst::AddrSpaceCastInst(
Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
@@ -3968,6 +4423,19 @@ AddrSpaceCastInst::AddrSpaceCastInst(
// CmpInst Classes
//===----------------------------------------------------------------------===//
+CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
+ Value *RHS, const Twine &Name,
+ BasicBlock::iterator InsertBefore, Instruction *FlagsSource)
+ : Instruction(ty, op, OperandTraits<CmpInst>::op_begin(this),
+ OperandTraits<CmpInst>::operands(this), InsertBefore) {
+ Op<0>() = LHS;
+ Op<1>() = RHS;
+ setPredicate((Predicate)predicate);
+ setName(Name);
+ if (FlagsSource)
+ copyIRFlags(FlagsSource);
+}
+
CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
Value *RHS, const Twine &Name, Instruction *InsertBefore,
Instruction *FlagsSource)
@@ -4471,6 +4939,17 @@ void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) {
Op<1>() = Default;
}
+/// SwitchInst ctor - Create a new switch instruction, specifying a value to
+/// switch on and a default destination. The number of additional cases can
+/// be specified here to make memory allocation more efficient. This
+/// constructor can also autoinsert before another instruction.
+SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
+ nullptr, 0, InsertBefore) {
+ init(Value, Default, 2 + NumCases * 2);
+}
+
/// SwitchInst ctor - Create a new switch instruction, specifying a value to
/// switch on and a default destination. The number of additional cases can
/// be specified here to make memory allocation more efficient. This
@@ -4693,6 +5172,13 @@ void IndirectBrInst::growOperands() {
growHungoffUses(ReservedSpace);
}
+IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
+ BasicBlock::iterator InsertBefore)
+ : Instruction(Type::getVoidTy(Address->getContext()),
+ Instruction::IndirectBr, nullptr, 0, InsertBefore) {
+ init(Address, NumCases);
+}
+
IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
Instruction *InsertBefore)
: Instruction(Type::getVoidTy(Address->getContext()),
@@ -4750,6 +5236,12 @@ void IndirectBrInst::removeDestination(unsigned idx) {
// FreezeInst Implementation
//===----------------------------------------------------------------------===//
+FreezeInst::FreezeInst(Value *S, const Twine &Name,
+ BasicBlock::iterator InsertBefore)
+ : UnaryInstruction(S->getType(), Freeze, S, InsertBefore) {
+ setName(Name);
+}
+
FreezeInst::FreezeInst(Value *S,
const Twine &Name, Instruction *InsertBefore)
: UnaryInstruction(S->getType(), Freeze, S, InsertBefore) {
More information about the llvm-commits
mailing list