diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index 6eba902fa0416..4ee51cd192ed7 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(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(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 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 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 Args, unsigned Values, + const Twine &NameStr, + BasicBlock::iterator InsertBefore); explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, ArrayRef 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 c0e159a342d5b..75f399ec2fcd5 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 1db4ff2f09bca..bc357074e5cb2 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; 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 IdxList, unsigned Values, + const Twine &NameStr, + BasicBlock::iterator InsertBefore); inline GetElementPtrInst(Type *PointeeType, Value *Ptr, ArrayRef 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 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 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 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 IdxList, const Twine &NameStr = "", @@ -1152,6 +1200,18 @@ struct OperandTraits : public VariadicOperandTraits { }; +GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr, + ArrayRef IdxList, unsigned Values, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr, + OperandTraits::op_end(this) - Values, + Values, InsertBefore), + SourceElementType(PointeeType), + ResultElementType(getIndexedType(PointeeType, IdxList)) { + init(Ptr, IdxList, NameStr); +} + GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr, ArrayRef 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 Args, + ArrayRef Bundles, const Twine &NameStr, + BasicBlock::iterator InsertBefore); + + inline CallInst(FunctionType *Ty, Value *Func, ArrayRef 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 Args, @@ -1493,6 +1590,9 @@ class CallInst : public CallBase { ArrayRef 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 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 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 Args, + ArrayRef 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 Args, ArrayRef 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 Args, + ArrayRef Bundles, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) { + return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles, + NameStr, InsertBefore); + } + static CallInst *Create(FunctionCallee Func, ArrayRef Args, ArrayRef Bundles = std::nullopt, const Twine &NameStr = "", @@ -1577,6 +1715,13 @@ class CallInst : public CallBase { NameStr, InsertBefore); } + static CallInst *Create(FunctionCallee Func, ArrayRef Args, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) { + return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr, + InsertBefore); + } + static CallInst *Create(FunctionCallee Func, ArrayRef 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 Bundles, + BasicBlock::iterator InsertPt); static CallInst *Create(CallInst *CI, ArrayRef Bundles, Instruction *InsertPt = nullptr); @@ -1682,6 +1829,17 @@ CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef Args, init(Ty, Func, Args, Bundles, NameStr); } +CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef Args, + ArrayRef Bundles, const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : CallBase(Ty->getReturnType(), Instruction::Call, + OperandTraits::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 Args, ArrayRef Bundles, const Twine &NameStr, Instruction *InsertBefore) @@ -1700,6 +1858,14 @@ CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef 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 Mask, const Twine &NameStr, + BasicBlock::iterator InsertBefore); ShuffleVectorInst(Value *V1, ArrayRef Mask, const Twine &NameStr = "", Instruction *InsertBefore = nullptr); ShuffleVectorInst(Value *V1, ArrayRef 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 Mask, + const Twine &NameStr, BasicBlock::iterator InsertBefor); ShuffleVectorInst(Value *V1, Value *V2, ArrayRef 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 Idxs, + const Twine &NameStr, + BasicBlock::iterator InsertBefore); inline ExtractValueInst(Value *Agg, ArrayRef Idxs, const Twine &NameStr, @@ -2488,6 +2697,13 @@ class ExtractValueInst : public UnaryInstruction { ExtractValueInst *cloneImpl() const; public: + static ExtractValueInst *Create(Value *Agg, ArrayRef Idxs, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) { + return new + ExtractValueInst(Agg, Idxs, NameStr, InsertBefore); + } + static ExtractValueInst *Create(Value *Agg, ArrayRef Idxs, const Twine &NameStr = "", @@ -2548,6 +2764,14 @@ class ExtractValueInst : public UnaryInstruction { } }; +ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef Idxs, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)), + ExtractValue, Agg, InsertBefore) { + init(Idxs, NameStr); +} + ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef 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 Idxs, + const Twine &NameStr, + BasicBlock::iterator InsertBefore); inline InsertValueInst(Value *Agg, Value *Val, ArrayRef Idxs, const Twine &NameStr, @@ -2590,8 +2817,10 @@ class InsertValueInst : public Instruction { ArrayRef 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 Idxs, const Twine &NameStr, + BasicBlock::iterator InsertBefore) { + return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore); + } + static InsertValueInst *Create(Value *Agg, Value *Val, ArrayRef Idxs, const Twine &NameStr = "", @@ -2683,6 +2918,16 @@ struct OperandTraits : public FixedNumOperandTraits { }; +InsertValueInst::InsertValueInst(Value *Agg, + Value *Val, + ArrayRef Idxs, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : Instruction(Agg->getType(), InsertValue, OperandTraits::op_begin(this), + 2, InsertBefore) { + init(Agg, Val, Idxs, NameStr); +} + InsertValueInst::InsertValueInst(Value *Agg, Value *Val, ArrayRef 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; using ConstCaseIt = CaseIteratorImpl; + 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 Args, + ArrayRef 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 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 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 Args, + ArrayRef 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 Args, ArrayRef Bundles = std::nullopt, @@ -3922,6 +4267,14 @@ class InvokeInst : public CallBase { NameStr, InsertAtEnd); } + static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal, + BasicBlock *IfException, ArrayRef 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 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 Args, + ArrayRef 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 Args, ArrayRef 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 Bundles, + BasicBlock::iterator InsertPt); static InvokeInst *Create(InvokeInst *II, ArrayRef Bundles, Instruction *InsertPt = nullptr); @@ -4013,6 +4377,16 @@ class InvokeInst : public CallBase { } }; +InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, + BasicBlock *IfException, ArrayRef Args, + ArrayRef Bundles, int NumOperands, + const Twine &NameStr, BasicBlock::iterator InsertBefore) + : CallBase(Ty->getReturnType(), Instruction::Invoke, + OperandTraits::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 Args, ArrayRef 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 IndirectDests, + ArrayRef Args, ArrayRef 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 IndirectDests, + ArrayRef 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 IndirectDests, @@ -4092,6 +4484,20 @@ class CallBrInst : public CallBase { NumOperands, NameStr, InsertBefore); } + static CallBrInst * + Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, + ArrayRef IndirectDests, ArrayRef Args, + ArrayRef 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 IndirectDests, ArrayRef Args, @@ -4132,6 +4538,14 @@ class CallBrInst : public CallBase { NumOperands, NameStr, InsertAtEnd); } + static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest, + ArrayRef IndirectDests, + ArrayRef 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 IndirectDests, ArrayRef Args, const Twine &NameStr, @@ -4140,6 +4554,16 @@ class CallBrInst : public CallBase { IndirectDests, Args, NameStr, InsertBefore); } + static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest, + ArrayRef IndirectDests, + ArrayRef Args, + ArrayRef 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 IndirectDests, ArrayRef 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 Bundles, + BasicBlock::iterator InsertPt); static CallBrInst *Create(CallBrInst *CBI, ArrayRef Bundles, Instruction *InsertPt = nullptr); @@ -4245,6 +4671,17 @@ class CallBrInst : public CallBase { } }; +CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, + ArrayRef IndirectDests, + ArrayRef Args, + ArrayRef Bundles, int NumOperands, + const Twine &NameStr, BasicBlock::iterator InsertBefore) + : CallBase(Ty->getReturnType(), Instruction::CallBr, + OperandTraits::op_end(this) - NumOperands, NumOperands, + InsertBefore) { + init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr); +} + CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef IndirectDests, ArrayRef 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 Args, + unsigned Values, const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values, + NameStr, InsertBefore) {} explicit CleanupPadInst(Value *ParentPad, ArrayRef 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 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 Args = std::nullopt, const Twine &NameStr = "", @@ -4553,6 +5023,11 @@ class CleanupPadInst : public FuncletPadInst { //===----------------------------------------------------------------------===// class CatchPadInst : public FuncletPadInst { private: + explicit CatchPadInst(Value *CatchSwitch, ArrayRef Args, + unsigned Values, const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values, + NameStr, InsertBefore) {} explicit CatchPadInst(Value *CatchSwitch, ArrayRef 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 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 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 345b050b7077a..c54f8d7aca4a9 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 fc5c9b201487e..25778570ebf34 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 OpB, + BasicBlock::iterator InsertPt) { + std::vector 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 OpB, Instruction *InsertPt) { std::vector 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::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::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::op_begin(this), 1, InsertBefore) { + Op<0>() = Exn; +} + ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore) : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume, OperandTraits::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::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::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 Args, unsigned Values, + const Twine &NameStr, + BasicBlock::iterator InsertBefore) + : Instruction(ParentPad->getType(), Op, + OperandTraits::op_end(this) - Values, Values, + InsertBefore) { + init(ParentPad, Args, NameStr); +} + FuncletPadInst::FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, ArrayRef 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::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::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::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::op_begin(this), + OperandTraits::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::op_begin(this), + OperandTraits::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(Val->getType())->getElementType(), ExtractElement, + OperandTraits::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::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 Mask, + const Twine &Name, + BasicBlock::iterator InsertBefore) + : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name, + InsertBefore) {} + ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef Mask, const Twine &Name, Instruction *InsertBefore) @@ -1938,6 +2151,25 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef 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(V1->getType())->getElementType(), + cast(Mask->getType())->getElementCount()), + ShuffleVector, OperandTraits::op_begin(this), + OperandTraits::operands(this), InsertBefore) { + assert(isValidOperands(V1, V2, Mask) && + "Invalid shuffle vector instruction operands!"); + + Op<0>() = V1; + Op<1>() = V2; + SmallVector MaskArr; + getShuffleMask(cast(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 Mask, + const Twine &Name, + BasicBlock::iterator InsertBefore) + : Instruction( + VectorType::get(cast(V1->getType())->getElementType(), + Mask.size(), isa(V1->getType())), + ShuffleVector, OperandTraits::op_begin(this), + OperandTraits::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 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::op_begin(this), + OperandTraits::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(Ty)->getElementCount() == + cast(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::op_begin(this), + OperandTraits::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) {