diff --git a/clang/lib/CodeGen/CGBuilder.h b/clang/lib/CodeGen/CGBuilder.h index 6dd9da7c4cade..ed07476f4047f 100644 --- a/clang/lib/CodeGen/CGBuilder.h +++ b/clang/lib/CodeGen/CGBuilder.h @@ -35,7 +35,6 @@ class CGBuilderInserter final : public llvm::IRBuilderDefaultInserter { /// This forwards to CodeGenFunction::InsertHelper. void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, - llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const override; private: diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index b6718a46e8c50..8771142417772 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -120,7 +120,7 @@ llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, Alloca = Builder.CreateAlloca(Ty, ArraySize, Name); else Alloca = new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(), - ArraySize, Name, AllocaInsertPt); + ArraySize, Name, &*AllocaInsertPt); if (Allocas) { Allocas->Add(Alloca); } diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index cea0d84c64bc4..200c40da8bc43 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -2637,7 +2637,6 @@ CodeGenFunction::SanitizerScope::~SanitizerScope() { void CodeGenFunction::InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, - llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const { LoopStack.InsertHelper(I); if (IsSanitizerScope) @@ -2645,11 +2644,11 @@ void CodeGenFunction::InsertHelper(llvm::Instruction *I, } void CGBuilderInserter::InsertHelper( - llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, + llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock::iterator InsertPt) const { - llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt); + llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt); if (CGF) - CGF->InsertHelper(I, Name, BB, InsertPt); + CGF->InsertHelper(I, Name, InsertPt); } // Emits an error if we don't have a valid set of target features for the diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 8525f66082a4e..cdb5ae6663405 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -343,7 +343,6 @@ class CodeGenFunction : public CodeGenTypeCache { /// CGBuilder insert helper. This function is called after an /// instruction is created using Builder. void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, - llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const; /// CurFuncDecl - Holds the Decl for the current outermost diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index 4d785eb6ae832..c10ea33a4ee13 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -63,10 +63,9 @@ class IRBuilderDefaultInserter { virtual ~IRBuilderDefaultInserter(); virtual void InsertHelper(Instruction *I, const Twine &Name, - BasicBlock *BB, BasicBlock::iterator InsertPt) const { - if (BB) - I->insertInto(BB, InsertPt); + if (InsertPt.isValid()) + I->insertInto(InsertPt.getNodeParent(), InsertPt); I->setName(Name); } }; @@ -83,9 +82,8 @@ class IRBuilderCallbackInserter : public IRBuilderDefaultInserter { : Callback(std::move(Callback)) {} void InsertHelper(Instruction *I, const Twine &Name, - BasicBlock *BB, BasicBlock::iterator InsertPt) const override { - IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt); + IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt); Callback(I); } }; @@ -143,7 +141,7 @@ class IRBuilderBase { /// Insert and return the specified instruction. template InstTy *Insert(InstTy *I, const Twine &Name = "") const { - Inserter.InsertHelper(I, Name, BB, InsertPt); + Inserter.InsertHelper(I, Name, InsertPt); AddMetadataToInst(I); return I; } diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index ad649b53761a3..afae564bf022d 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -107,12 +107,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, - const Twine &Name, BasicBlock *InsertAtEnd); + UnaryOperator(UnaryOps iType, Value *S, Type *Ty, const Twine &Name, + InsertPosition InsertBefore); // Note: Instruction needs to be a friend here to call cloneImpl. friend class Instruction; @@ -120,13 +116,6 @@ 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 /// into a BasicBlock right before the specified instruction. The specified @@ -134,15 +123,7 @@ class UnaryOperator : public UnaryInstruction { /// static UnaryOperator *Create(UnaryOps Op, Value *S, const Twine &Name = Twine(), - Instruction *InsertBefore = nullptr); - - /// Construct a unary instruction, given the opcode and an operand. - /// Also automatically insert this instruction to the end of the - /// BasicBlock specified. - /// - static UnaryOperator *Create(UnaryOps Op, Value *S, - const Twine &Name, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); /// These methods just forward to Create, and are useful when you /// statically know what type of instruction you're going to create. These @@ -171,33 +152,18 @@ class UnaryOperator : public UnaryInstruction { } #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, const Twine &Name = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { UnaryOperator *UO = Create(Opc, V, Name, InsertBefore); UO->copyIRFlags(CopyO); 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) { + InsertPosition InsertBefore = nullptr) { return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name, InsertBefore); } @@ -224,11 +190,7 @@ class BinaryOperator : public Instruction { 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, - const Twine &Name, BasicBlock *InsertAtEnd); + const Twine &Name, InsertPosition InsertBefore); // Note: Instruction needs to be a friend here to call cloneImpl. friend class Instruction; @@ -243,14 +205,6 @@ 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 @@ -258,14 +212,7 @@ class BinaryOperator : public Instruction { /// static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name = Twine(), - Instruction *InsertBefore = nullptr); - - /// Construct a binary instruction, given the opcode and the two - /// operands. Also automatically insert this instruction to the end of the - /// BasicBlock specified. - /// - static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, - const Twine &Name, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); /// These methods just forward to Create, and are useful when you /// statically know what type of instruction you're going to create. These @@ -295,18 +242,10 @@ class BinaryOperator : public Instruction { } #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, const Twine &Name = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore); BO->copyIRFlags(CopyO); return BO; @@ -315,7 +254,7 @@ class BinaryOperator : public Instruction { static BinaryOperator *CreateWithFMF(BinaryOps Opc, Value *V1, Value *V2, FastMathFlags FMF, const Twine &Name = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore); BO->setFastMathFlags(FMF); return BO; @@ -493,22 +432,12 @@ 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 = "", - BasicBlock *InsertAtEnd = nullptr); - static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name, - BasicBlock::iterator InsertBefore); + InsertPosition InsertBefore = nullptr); static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "", - Instruction *InsertBefore = nullptr); - static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name, - BasicBlock *InsertAtEnd); - static BinaryOperator *CreateNot(Value *Op, const Twine &Name, - BasicBlock::iterator InsertBefore); + InsertPosition InsertBefore = nullptr); static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "", - Instruction *InsertBefore = nullptr); - static BinaryOperator *CreateNot(Value *Op, const Twine &Name, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); BinaryOps getOpcode() const { return static_cast(Instruction::getOpcode()); @@ -601,38 +530,13 @@ BinaryOperator *BinaryOperator::CreateDisjoint(BinaryOps Opc, Value *V1, 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) + CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr = "", + InsertPosition InsertBefore = nullptr) : 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) - : UnaryInstruction(Ty, iType, S, InsertBefore) { - setName(NameStr); - } - /// Constructor with insert-at-end-of-block semantics for subclasses - CastInst(Type *Ty, unsigned iType, Value *S, - const Twine &NameStr, BasicBlock *InsertAtEnd) - : UnaryInstruction(Ty, iType, S, InsertAtEnd) { - setName(NameStr); - } 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 @@ -640,120 +544,43 @@ class CastInst : public UnaryInstruction { /// insert the new CastInst before InsertBefore (if it is non-null). /// 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 - Instruction *InsertBefore = nullptr ///< 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. This constructor has insert-at-end-of-block semantics - /// to automatically insert the new CastInst at the end of InsertAtEnd (if - /// its non-null). - /// Construct any of the CastInst subclasses - static CastInst *Create( - Instruction::CastOps, ///< The opcode for the cast instruction - Value *S, ///< The value to be casted (operand 0) - Type *Ty, ///< The type to which operand is casted - const Twine &Name, ///< The name for the instruction - BasicBlock *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// 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) - Type *Ty, ///< The type to which cast should be made - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< Place to insert the instruction - ); - - /// 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 operand is casted - const Twine &Name, ///< The name for the instruction - 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) - Type *Ty, ///< The type to which cast should be made - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< Place to insert the 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// 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 operand is casted - const Twine &Name, ///< The name for the instruction - 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 operand is casted - const Twine &Name, ///< The name for the instruction - BasicBlock *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = nullptr ///< 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) - 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) - Type *Ty, ///< The type to which cast should be made - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< 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) - Type *Ty, ///< The type to which operand is casted - const Twine &Name, ///< The name for the instruction - 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 + 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 + InsertPosition InsertBefore = nullptr ///< 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) - Type *Ty, ///< The type to which cast should be made - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< Place to insert the instruction + 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction. @@ -763,98 +590,35 @@ class CastInst : public UnaryInstruction { /// 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, - /// 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 - 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) - 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 - Instruction *InsertBefore = nullptr ///< Place to insert the instruction + 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// Create a ZExt, BitCast, or Trunc for int -> int casts. static CastInst *CreateIntegerCast( - Value *S, ///< The integer value to be casted (operand 0) - Type *Ty, ///< The integer type to which operand is casted - bool isSigned, ///< Whether to regard S as signed or not - const Twine &Name, ///< The name for the instruction - BasicBlock *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = nullptr ///< 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 - 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 - Type *Ty, ///< The floating point type to cast to - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< 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 - Type *Ty, ///< The floating point type to cast to - const Twine &Name, ///< The name for the instruction - BasicBlock *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// 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) - Type *Ty, ///< The type to which cast should be made - const Twine &Name = "", ///< Name for the instruction - Instruction *InsertBefore = nullptr ///< Place to insert the instruction - ); - - /// 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 operand is casted - const Twine &Name, ///< The name for the instruction - BasicBlock *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = nullptr ///< Place to insert the instruction ); /// Check whether a bitcast between these types is valid @@ -1044,30 +808,15 @@ class CmpInst : public Instruction { protected: CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, Value *LHS, - Value *RHS, const Twine &Name, BasicBlock::iterator InsertBefore, + Value *RHS, const Twine &Name = "", + InsertPosition InsertBefore = nullptr, Instruction *FlagsSource = nullptr); - CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, - Value *LHS, Value *RHS, const Twine &Name = "", - Instruction *InsertBefore = nullptr, - Instruction *FlagsSource = nullptr); - - CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, - Value *LHS, Value *RHS, const Twine &Name, - BasicBlock *InsertAtEnd); - public: // allocate space for exactly two operands 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 Pred, 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. @@ -1075,14 +824,7 @@ class CmpInst : public Instruction { /// Create a CmpInst static CmpInst *Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2, const Twine &Name = "", - Instruction *InsertBefore = nullptr); - - /// Construct a compare instruction, given the opcode, the predicate and the - /// two operands. Also automatically insert this instruction to the end of - /// the BasicBlock specified. - /// Create a CmpInst - static CmpInst *Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2, - const Twine &Name, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); /// Construct a compare instruction, given the opcode, the predicate, /// the two operands and the instruction to copy the flags from. Optionally @@ -1094,7 +836,7 @@ class CmpInst : public Instruction { Value *S2, const Instruction *FlagsSource, const Twine &Name = "", - Instruction *InsertBefore = nullptr); + InsertPosition InsertBefore = nullptr); /// Get the opcode casted to the right type OtherOps getOpcode() const { @@ -1542,16 +1284,7 @@ class CallBase : public Instruction { /// 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. - /// - /// 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, - Instruction *InsertPt = nullptr); + InsertPosition 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. @@ -1559,34 +1292,16 @@ class CallBase : public Instruction { /// 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. - /// - /// 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, - Instruction *InsertPt = nullptr); - - /// Create a clone of \p CB with operand bundle \p OB added. - static CallBase *addOperandBundle(CallBase *CB, uint32_t ID, - OperandBundleDef OB, - Instruction *InsertPt = nullptr); + InsertPosition InsertPt = nullptr); /// Create a clone of \p CB with operand bundle \p OB added. static CallBase *addOperandBundle(CallBase *CB, uint32_t ID, OperandBundleDef OB, - BasicBlock::iterator InsertPt); - - /// Create a clone of \p CB with operand bundle \p ID removed. - static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID, - Instruction *InsertPt = nullptr); + InsertPosition InsertPt = nullptr); /// Create a clone of \p CB with operand bundle \p ID removed. static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID, - BasicBlock::iterator InsertPt); + InsertPosition InsertPt = nullptr); /// Return the convergence control token for this call, if it exists. Value *getConvergenceControlToken() const { @@ -2705,14 +2420,7 @@ class FuncletPadInst : public Instruction { 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); - explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad, - ArrayRef Args, unsigned Values, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); void init(Value *ParentPad, ArrayRef Args, const Twine &NameStr); diff --git a/llvm/include/llvm/IR/Instruction.h b/llvm/include/llvm/IR/Instruction.h index 0b636fc7ceaa3..2e72f6742a659 100644 --- a/llvm/include/llvm/IR/Instruction.h +++ b/llvm/include/llvm/IR/Instruction.h @@ -44,6 +44,23 @@ template <> struct ilist_alloc_traits { iterator_range::iterator> getDbgRecordRange(DbgMarker *); +class InsertPosition { + using InstListType = SymbolTableList, + ilist_parent>; + InstListType::iterator InsertAt; + +public: + InsertPosition(std::nullptr_t) : InsertAt() {} + // LLVM_DEPRECATED("Use BasicBlock::iterators for insertion instead", + // "BasicBlock::iterator") + InsertPosition(Instruction *InsertBefore); + InsertPosition(BasicBlock *InsertAtEnd); + InsertPosition(InstListType::iterator InsertAt) : InsertAt(InsertAt) {} + operator InstListType::iterator() const { return InsertAt; } + bool isValid() const { return InsertAt.isValid(); } + BasicBlock *getBasicBlock() { return InsertAt.getNodeParent(); } +}; + class Instruction : public User, public ilist_node_with_parent, @@ -1018,11 +1035,7 @@ class Instruction : public User, } 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, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); private: /// Create a copy of this instruction. diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h index d0a051560fc9a..ab58edd1bf78c 100644 --- a/llvm/include/llvm/IR/Instructions.h +++ b/llvm/include/llvm/IR/Instructions.h @@ -75,25 +75,13 @@ class AllocaInst : public UnaryInstruction { 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); + const Twine &Name, InsertPosition InsertBefore); 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); + InsertPosition InsertBefore); 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, - const Twine &Name, BasicBlock *InsertAtEnd); + const Twine &Name = "", InsertPosition InsertBefore = nullptr); /// Return true if there is an allocation size parameter to the allocation /// instruction that is not 1. @@ -200,32 +188,15 @@ class LoadInst : public UnaryInstruction { 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); + InsertPosition InsertBefore); LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile, - Align Align, BasicBlock::iterator InsertBefore); + InsertPosition 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); + Align Align, InsertPosition InsertBefore = nullptr); LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile, Align Align, AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System, - Instruction *InsertBefore = nullptr); - LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile, - Align Align, AtomicOrdering Order, SyncScope::ID SSID, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); /// Return true if this is a load from a volatile memory location. bool isVolatile() const { return getSubclassData(); } @@ -332,27 +303,14 @@ class StoreInst : public Instruction { StoreInst *cloneImpl() const; public: - StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore); - StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd); - StoreInst(Value *Val, Value *Ptr, BasicBlock::iterator InsertBefore); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd); + StoreInst(Value *Val, Value *Ptr, InsertPosition InsertBefore); StoreInst(Value *Val, Value *Ptr, bool isVolatile, - BasicBlock::iterator InsertBefore); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, - Instruction *InsertBefore = nullptr); + InsertPosition InsertBefore); StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, - BasicBlock *InsertAtEnd); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, - BasicBlock::iterator InsertBefore); + InsertPosition InsertBefore = nullptr); StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System, - Instruction *InsertBefore = nullptr); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, - AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align, - AtomicOrdering Order, SyncScope::ID SSID, - BasicBlock::iterator InsertBefore); + InsertPosition InsertBefore = nullptr); // allocate space for exactly two operands void *operator new(size_t S) { return User::operator new(S, 2); } @@ -472,13 +430,9 @@ 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); - FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); // allocate space for exactly zero operands void *operator new(size_t S) { return User::operator new(S, 0); } @@ -557,15 +511,7 @@ class AtomicCmpXchgInst : public Instruction { 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, - Instruction *InsertBefore = nullptr); - AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment, - AtomicOrdering SuccessOrdering, - AtomicOrdering FailureOrdering, SyncScope::ID SSID, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); // allocate space for exactly three operands void *operator new(size_t S) { return User::operator new(S, 3); } @@ -822,13 +768,7 @@ class AtomicRMWInst : public Instruction { 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); - AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment, - AtomicOrdering Ordering, SyncScope::ID SSID, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); // allocate space for exactly two operands void *operator new(size_t S) { return User::operator new(S, 2); } @@ -983,14 +923,7 @@ class GetElementPtrInst : public Instruction { /// 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); - inline GetElementPtrInst(Type *PointeeType, Value *Ptr, - ArrayRef IdxList, unsigned Values, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); void init(Value *Ptr, ArrayRef IdxList, const Twine &NameStr); @@ -1001,92 +934,36 @@ 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { 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, - BasicBlock *InsertAtEnd) { - unsigned Values = 1 + unsigned(IdxList.size()); - assert(PointeeType && "Must specify element type"); - return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values, - NameStr, InsertAtEnd); - } - - static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr, - ArrayRef IdxList, GEPNoWrapFlags NW, - const Twine &NameStr, - BasicBlock::iterator InsertBefore) { - GetElementPtrInst *GEP = - Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore); - GEP->setNoWrapFlags(NW); - return GEP; - } - static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr, ArrayRef IdxList, GEPNoWrapFlags NW, const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { GetElementPtrInst *GEP = Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore); GEP->setNoWrapFlags(NW); return GEP; } - static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr, - ArrayRef IdxList, GEPNoWrapFlags NW, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - GetElementPtrInst *GEP = - Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd); - GEP->setNoWrapFlags(NW); - return GEP; - } - /// 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) { - return Create(PointeeType, Ptr, IdxList, GEPNoWrapFlags::inBounds(), - NameStr, InsertBefore); - } - static GetElementPtrInst * CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef IdxList, const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return Create(PointeeType, Ptr, IdxList, GEPNoWrapFlags::inBounds(), NameStr, InsertBefore); } - static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr, - ArrayRef IdxList, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return Create(PointeeType, Ptr, IdxList, GEPNoWrapFlags::inBounds(), - NameStr, InsertAtEnd); - } - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -1241,19 +1118,7 @@ struct OperandTraits : 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, - Instruction *InsertBefore) + InsertPosition InsertBefore) : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr, OperandTraits::op_end(this) - Values, Values, InsertBefore), @@ -1262,18 +1127,6 @@ GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr, init(Ptr, IdxList, NameStr); } -GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr, - ArrayRef IdxList, unsigned Values, - const Twine &NameStr, - BasicBlock *InsertAtEnd) - : Instruction(getGEPReturnType(Ptr, IdxList), GetElementPtr, - OperandTraits::op_end(this) - Values, - Values, InsertAtEnd), - SourceElementType(PointeeType), - ResultElementType(getIndexedType(PointeeType, IdxList)) { - init(Ptr, IdxList, NameStr); -} - DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value) //===----------------------------------------------------------------------===// @@ -1304,46 +1157,15 @@ 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 - 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-at-end semantics. - ICmpInst( - BasicBlock *InsertAtEnd, ///< Block to insert into. - 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, - InsertAtEnd) { + /// Constructor with insertion semantics. + ICmpInst(InsertPosition 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 @@ -1491,54 +1313,26 @@ 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 - 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-at-end semantics. - FCmpInst( - BasicBlock *InsertAtEnd, ///< Block to insert into. - 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, - InsertAtEnd) { + /// Constructor with insertion semantics. + FCmpInst(InsertPosition 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 no-insertion semantics - FCmpInst( - 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 - Instruction *FlagsSource = nullptr - ) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS, - RHS, NameStr, nullptr, FlagsSource) { + FCmpInst(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 + Instruction *FlagsSource = nullptr) + : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS, + RHS, NameStr, nullptr, FlagsSource) { AssertOK(); } @@ -1606,36 +1400,14 @@ class CallInst : public CallBase { /// 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, - ArrayRef Bundles, const Twine &NameStr, - Instruction *InsertBefore); + InsertPosition InsertBefore); inline CallInst(FunctionType *Ty, Value *Func, ArrayRef Args, - const Twine &NameStr, Instruction *InsertBefore) + const Twine &NameStr, InsertPosition 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, - 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); - - CallInst(FunctionType *ty, Value *F, const Twine &NameStr, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore); void init(FunctionType *FTy, Value *Func, ArrayRef Args, ArrayRef Bundles, const Twine &NameStr); @@ -1655,46 +1427,22 @@ 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) { + InsertPosition 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) { + InsertPosition InsertBefore = nullptr) { return new (ComputeNumOperands(Args.size())) 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { const int NumOperands = ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)); const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo); @@ -1703,99 +1451,35 @@ class CallInst : public CallBase { CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore); } - static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd); - } - - static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return new (ComputeNumOperands(Args.size())) - CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertAtEnd); - } - - static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - 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, 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) { + InsertPosition 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles, 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) { + InsertPosition InsertBefore = nullptr) { return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr, InsertBefore); } - static CallInst *Create(FunctionCallee Func, const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), NameStr, - InsertAtEnd); - } - - static CallInst *Create(FunctionCallee Func, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr, - InsertAtEnd); - } - - static CallInst *Create(FunctionCallee Func, ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles, - NameStr, InsertAtEnd); - } - /// Create a clone of \p CI with a different set of operand bundles and - /// insert it before \p InsertPt. + /// insert it before \p InsertBefore. /// /// 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); + InsertPosition InsertPt = nullptr); // Note that 'musttail' implies 'tail'. enum TailCallKind : unsigned { @@ -1858,29 +1542,7 @@ class CallInst : public CallBase { CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef Args, ArrayRef Bundles, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : CallBase(Ty->getReturnType(), Instruction::Call, - OperandTraits::op_end(this) - - (Args.size() + CountBundleInputs(Bundles) + 1), - unsigned(Args.size() + CountBundleInputs(Bundles) + 1), - InsertAtEnd) { - 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) + InsertPosition InsertBefore) : CallBase(Ty->getReturnType(), Instruction::Call, OperandTraits::op_end(this) - (Args.size() + CountBundleInputs(Bundles) + 1), @@ -1896,30 +1558,15 @@ 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) + InsertPosition 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, - &Op<0>(), 3, InsertBefore) { - init(C, S1, S2); - setName(NameStr); - } - - SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : Instruction(S1->getType(), Instruction::Select, - &Op<0>(), 3, InsertAtEnd) { - init(C, S1, S2); - setName(NameStr); - } - void init(Value *C, Value *S1, Value *S2) { assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select"); Op<0>() = C; @@ -1934,19 +1581,9 @@ 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, + InsertPosition InsertBefore = nullptr, Instruction *MDFrom = nullptr) { SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore); if (MDFrom) @@ -1954,12 +1591,6 @@ class SelectInst : public Instruction { return Sel; } - static SelectInst *Create(Value *C, Value *S1, Value *S2, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd); - } - const Value *getCondition() const { return Op<0>(); } const Value *getTrueValue() const { return Op<1>(); } const Value *getFalseValue() const { return Op<2>(); } @@ -2016,21 +1647,9 @@ 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) { - setName(NameStr); - } - - VAArgInst(Value *List, Type *Ty, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) { + InsertPosition InsertBefore = nullptr) + : UnaryInstruction(Ty, VAArg, List, InsertBefore) { setName(NameStr); } @@ -2055,12 +1674,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, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); protected: // Note: Instruction needs to be a friend here to call cloneImpl. @@ -2070,23 +1685,11 @@ class ExtractElementInst : public Instruction { 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) { + const Twine &NameStr = "", + InsertPosition InsertBefore = nullptr) { return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore); } - static ExtractElementInst *Create(Value *Vec, Value *Idx, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd); - } - /// Return true if an extractelement instruction can be /// formed with the specified operands. static bool isValidOperands(const Value *Vec, const Value *Idx); @@ -2127,13 +1730,9 @@ 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); - InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); protected: // Note: Instruction needs to be a friend here to call cloneImpl. @@ -2142,24 +1741,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) { + InsertPosition InsertBefore = nullptr) { return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore); } - static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd); - } - /// Return true if an insertelement instruction can be /// formed with the specified operands. static bool isValidOperands(const Value *Vec, const Value *NewElt, @@ -2217,32 +1804,16 @@ 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); + InsertPosition InsertBefore = nullptr); 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); + InsertPosition InsertBefore = nullptr); 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); + InsertPosition InsertBefore = nullptr); ShuffleVectorInst(Value *V1, Value *V2, ArrayRef Mask, const Twine &NameStr = "", - Instruction *InsertBefor = nullptr); - ShuffleVectorInst(Value *V1, Value *V2, ArrayRef Mask, - const Twine &NameStr, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); void *operator new(size_t S) { return User::operator new(S, 2); } void operator delete(void *Ptr) { return User::operator delete(Ptr); } @@ -2726,15 +2297,7 @@ class ExtractValueInst : public UnaryInstruction { /// 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, - Instruction *InsertBefore); - inline ExtractValueInst(Value *Agg, - ArrayRef Idxs, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); void init(ArrayRef Idxs, const Twine &NameStr); @@ -2746,27 +2309,12 @@ class ExtractValueInst : public UnaryInstruction { 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return new ExtractValueInst(Agg, Idxs, NameStr, InsertBefore); } - static ExtractValueInst *Create(Value *Agg, - ArrayRef Idxs, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd); - } - /// Returns the type of the element that would be extracted /// with an extractvalue instruction with the specified parameters. /// @@ -2814,30 +2362,12 @@ class ExtractValueInst : public UnaryInstruction { ExtractValueInst::ExtractValueInst(Value *Agg, ArrayRef Idxs, const Twine &NameStr, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)), ExtractValue, Agg, InsertBefore) { init(Idxs, NameStr); } -ExtractValueInst::ExtractValueInst(Value *Agg, - ArrayRef Idxs, - const Twine &NameStr, - Instruction *InsertBefore) - : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)), - ExtractValue, Agg, InsertBefore) { - init(Idxs, NameStr); -} - -ExtractValueInst::ExtractValueInst(Value *Agg, - ArrayRef Idxs, - const Twine &NameStr, - BasicBlock *InsertAtEnd) - : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)), - ExtractValue, Agg, InsertAtEnd) { - init(Idxs, NameStr); -} - //===----------------------------------------------------------------------===// // InsertValueInst Class //===----------------------------------------------------------------------===// @@ -2855,25 +2385,13 @@ class InsertValueInst : public Instruction { /// 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, - Instruction *InsertBefore); - inline InsertValueInst(Value *Agg, Value *Val, - ArrayRef Idxs, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); /// 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); - InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); void init(Value *Agg, Value *Val, ArrayRef Idxs, const Twine &NameStr); @@ -2889,26 +2407,13 @@ 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore); } - static InsertValueInst *Create(Value *Agg, Value *Val, - ArrayRef Idxs, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd); - } - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -2966,35 +2471,12 @@ 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, - const Twine &NameStr, - Instruction *InsertBefore) - : Instruction(Agg->getType(), InsertValue, - OperandTraits::op_begin(this), - 2, InsertBefore) { - init(Agg, Val, Idxs, NameStr); -} - -InsertValueInst::InsertValueInst(Value *Agg, - Value *Val, - ArrayRef Idxs, - const Twine &NameStr, - BasicBlock *InsertAtEnd) - : Instruction(Agg->getType(), InsertValue, - OperandTraits::op_begin(this), - 2, InsertAtEnd) { +InsertValueInst::InsertValueInst(Value *Agg, Value *Val, + ArrayRef Idxs, const Twine &NameStr, + InsertPosition InsertBefore) + : Instruction(Agg->getType(), InsertValue, + OperandTraits::op_begin(this), 2, + InsertBefore) { init(Agg, Val, Idxs, NameStr); } @@ -3015,29 +2497,11 @@ 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) - : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore), - ReservedSpace(NumReservedValues) { - assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!"); - setName(NameStr); - allocHungoffUses(ReservedSpace); - } - - PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd), - ReservedSpace(NumReservedValues) { + InsertPosition InsertBefore = nullptr) + : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore), + ReservedSpace(NumReservedValues) { assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!"); setName(NameStr); allocHungoffUses(ReservedSpace); @@ -3059,23 +2523,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) { + InsertPosition InsertBefore = nullptr) { return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore); } - static PHINode *Create(Type *Ty, unsigned NumReservedValues, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -3290,12 +2743,7 @@ class LandingPadInst : public Instruction { 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, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); // Allocate space for exactly zero operands. void *operator new(size_t S) { return User::operator new(S); } @@ -3314,14 +2762,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); - static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses, - const Twine &NameStr, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -3400,12 +2843,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); - explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); protected: // Note: Instruction needs to be a friend here to call cloneImpl. @@ -3414,23 +2853,13 @@ 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) { + static ReturnInst *Create(LLVMContext &C, Value *retVal = nullptr, + InsertPosition InsertBefore = nullptr) { return new(!!retVal) ReturnInst(C, retVal, InsertBefore); } - static ReturnInst* Create(LLVMContext &C, Value *retVal, - BasicBlock *InsertAtEnd) { - return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd); - } - - static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) { - return new(0) ReturnInst(C, InsertAtEnd); + static ReturnInst *Create(LLVMContext &C, BasicBlock *InsertAtEnd) { + return new (0) ReturnInst(C, nullptr, InsertAtEnd); } /// Provide fast operand accessors @@ -3489,15 +2918,10 @@ class BranchInst : public Instruction { // 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); + explicit BranchInst(BasicBlock *IfTrue, + InsertPosition InsertBefore = nullptr); 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); - BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd); - BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); void AssertOK(); @@ -3536,34 +2960,16 @@ class BranchInst : public Instruction { }; static BranchInst *Create(BasicBlock *IfTrue, - BasicBlock::iterator InsertBefore) { + InsertPosition InsertBefore = nullptr) { 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) { + Value *Cond, + InsertPosition InsertBefore = nullptr) { return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore); } - static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) { - return new(1) BranchInst(IfTrue, InsertAtEnd); - } - - static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse, - Value *Cond, BasicBlock *InsertAtEnd) { - return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd); - } - /// Transparently provide more efficient getOperand methods. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -3647,21 +3053,7 @@ class SwitchInst : public Instruction { /// 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 - /// auto-insert before another instruction. - SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, - Instruction *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 also - /// auto-inserts at the end of the specified BasicBlock. - SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore); // allocate space for exactly zero operands void *operator new(size_t S) { return User::operator new(S); } @@ -3831,21 +3223,10 @@ class SwitchInst : public Instruction { static SwitchInst *Create(Value *Value, BasicBlock *Default, unsigned NumCases, - BasicBlock::iterator InsertBefore) { + InsertPosition InsertBefore = nullptr) { return new SwitchInst(Value, Default, NumCases, InsertBefore); } - static SwitchInst *Create(Value *Value, BasicBlock *Default, - unsigned NumCases, - Instruction *InsertBefore = nullptr) { - return new SwitchInst(Value, Default, NumCases, InsertBefore); - } - - static SwitchInst *Create(Value *Value, BasicBlock *Default, - unsigned NumCases, BasicBlock *InsertAtEnd) { - return new SwitchInst(Value, Default, NumCases, InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -4060,19 +3441,7 @@ class IndirectBrInst : public Instruction { /// 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 - /// autoinsert before another instruction. - IndirectBrInst(Value *Address, unsigned NumDests, Instruction *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 also - /// autoinserts at the end of the specified BasicBlock. - IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd); + InsertPosition InsertBefore); // allocate space for exactly zero operands void *operator new(size_t S) { return User::operator new(S); } @@ -4117,20 +3486,10 @@ class IndirectBrInst : public Instruction { }; static IndirectBrInst *Create(Value *Address, unsigned NumDests, - BasicBlock::iterator InsertBefore) { + InsertPosition InsertBefore = nullptr) { return new IndirectBrInst(Address, NumDests, InsertBefore); } - static IndirectBrInst *Create(Value *Address, unsigned NumDests, - Instruction *InsertBefore = nullptr) { - return new IndirectBrInst(Address, NumDests, InsertBefore); - } - - static IndirectBrInst *Create(Value *Address, unsigned NumDests, - BasicBlock *InsertAtEnd) { - return new IndirectBrInst(Address, NumDests, InsertAtEnd); - } - /// Provide fast operand accessors. DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -4208,24 +3567,13 @@ 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 inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef Args, ArrayRef Bundles, int NumOperands, - const Twine &NameStr, Instruction *InsertBefore); - - inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - ArrayRef Bundles, int NumOperands, - const Twine &NameStr, BasicBlock *InsertAtEnd); + const Twine &NameStr, InsertPosition InsertBefore); void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef Args, @@ -4248,42 +3596,18 @@ class InvokeInst : public CallBase { 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, - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { 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, - 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, const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { int NumOperands = ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)); unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo); @@ -4293,87 +3617,31 @@ class InvokeInst : public CallBase { NameStr, InsertBefore); } - static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - int NumOperands = ComputeNumOperands(Args.size()); - return new (NumOperands) - InvokeInst(Ty, Func, IfNormal, IfException, Args, std::nullopt, - NumOperands, NameStr, InsertAtEnd); - } - - static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - 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, 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, - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return Create(Func.getFunctionType(), Func.getCallee(), IfNormal, 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, const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return Create(Func.getFunctionType(), Func.getCallee(), IfNormal, IfException, Args, Bundles, NameStr, InsertBefore); } - static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), IfNormal, - IfException, Args, NameStr, InsertAtEnd); - } - - static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal, - BasicBlock *IfException, ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), IfNormal, - IfException, Args, Bundles, NameStr, InsertAtEnd); - } - /// Create a clone of \p II with a different set of operand bundles and - /// insert it before \p InsertPt. + /// insert it before \p InsertBefore. /// /// 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); + InsertPosition InsertPt = nullptr); // get*Dest - Return the destination basic blocks... BasicBlock *getNormalDest() const { @@ -4431,33 +3699,13 @@ 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) + const Twine &NameStr, InsertPosition 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, - const Twine &NameStr, Instruction *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, - const Twine &NameStr, BasicBlock *InsertAtEnd) - : CallBase(Ty->getReturnType(), Instruction::Invoke, - OperandTraits::op_end(this) - NumOperands, NumOperands, - InsertAtEnd) { - init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr); -} - //===----------------------------------------------------------------------===// // CallBrInst Class //===----------------------------------------------------------------------===// @@ -4472,27 +3720,14 @@ 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 inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef IndirectDests, - ArrayRef Args, - ArrayRef Bundles, int NumOperands, - const Twine &NameStr, Instruction *InsertBefore); - - inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, - ArrayRef IndirectDests, - ArrayRef Args, - ArrayRef Bundles, int NumOperands, - const Twine &NameStr, BasicBlock *InsertAtEnd); + ArrayRef Args, ArrayRef Bundles, + int NumOperands, const Twine &NameStr, + InsertPosition InsertBefore); void init(FunctionType *FTy, Value *Func, BasicBlock *DefaultDest, ArrayRef IndirectDests, ArrayRef Args, @@ -4517,43 +3752,18 @@ class CallBrInst : public CallBase { 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, - ArrayRef Args, const Twine &NameStr, - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { 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, 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, ArrayRef Bundles = std::nullopt, - const Twine &NameStr = "", Instruction *InsertBefore = nullptr) { + const Twine &NameStr = "", InsertPosition InsertBefore = nullptr) { int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(), CountBundleInputs(Bundles)); unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo); @@ -4563,97 +3773,32 @@ class CallBrInst : public CallBase { NumOperands, NameStr, InsertBefore); } - static CallBrInst *Create(FunctionType *Ty, Value *Func, - BasicBlock *DefaultDest, - ArrayRef IndirectDests, - ArrayRef Args, const Twine &NameStr, - BasicBlock *InsertAtEnd) { - int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size()); - return new (NumOperands) - CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, std::nullopt, - NumOperands, NameStr, InsertAtEnd); - } - - static CallBrInst *Create(FunctionType *Ty, Value *Func, - BasicBlock *DefaultDest, - ArrayRef IndirectDests, - ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - 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, InsertAtEnd); - } - static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest, ArrayRef IndirectDests, ArrayRef Args, const Twine &NameStr, - BasicBlock::iterator InsertBefore) { + InsertPosition InsertBefore = nullptr) { 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, - Instruction *InsertBefore = nullptr) { - return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest, - 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, ArrayRef Bundles = std::nullopt, const Twine &NameStr = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest, IndirectDests, Args, Bundles, NameStr, InsertBefore); } - static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest, - ArrayRef IndirectDests, - ArrayRef Args, const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest, - IndirectDests, Args, NameStr, InsertAtEnd); - } - - static CallBrInst *Create(FunctionCallee Func, - BasicBlock *DefaultDest, - ArrayRef IndirectDests, - ArrayRef Args, - ArrayRef Bundles, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest, - IndirectDests, Args, Bundles, NameStr, InsertAtEnd); - } - /// Create a clone of \p CBI with a different set of operand bundles and - /// insert it before \p InsertPt. + /// insert it before \p InsertBefore. /// /// 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); + InsertPosition InsertBefore = nullptr); /// Return the number of callbr indirect dest labels. /// @@ -4726,35 +3871,13 @@ CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef IndirectDests, ArrayRef Args, ArrayRef Bundles, int NumOperands, - const Twine &NameStr, BasicBlock::iterator InsertBefore) + const Twine &NameStr, InsertPosition 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, - ArrayRef Bundles, int NumOperands, - const Twine &NameStr, Instruction *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, - ArrayRef Bundles, int NumOperands, - const Twine &NameStr, BasicBlock *InsertAtEnd) - : CallBase(Ty->getReturnType(), Instruction::CallBr, - OperandTraits::op_end(this) - NumOperands, NumOperands, - InsertAtEnd) { - init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr); -} - //===----------------------------------------------------------------------===// // ResumeInst Class //===----------------------------------------------------------------------===// @@ -4765,9 +3888,7 @@ CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, 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); + explicit ResumeInst(Value *Exn, InsertPosition InsertBefore = nullptr); protected: // Note: Instruction needs to be a friend here to call cloneImpl. @@ -4776,18 +3897,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) { + static ResumeInst *Create(Value *Exn, InsertPosition InsertBefore = nullptr) { return new(1) ResumeInst(Exn, InsertBefore); } - static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) { - return new(1) ResumeInst(Exn, InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -4842,23 +3955,7 @@ class CatchSwitchInst : public Instruction { /// 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. - /// This constructor can also autoinsert before another instruction. - CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, - unsigned NumHandlers, const Twine &NameStr, - Instruction *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. - /// This constructor also autoinserts at the end of the specified BasicBlock. - CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, - unsigned NumHandlers, const Twine &NameStr, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore); // allocate space for exactly zero operands void *operator new(size_t S) { return User::operator new(S); } @@ -4875,28 +3972,14 @@ 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr, InsertBefore); } - static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest, - unsigned NumHandlers, const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr, - InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -5021,45 +4104,20 @@ class CleanupPadInst : public FuncletPadInst { private: explicit CleanupPadInst(Value *ParentPad, ArrayRef Args, unsigned Values, const Twine &NameStr, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values, NameStr, InsertBefore) {} - explicit CleanupPadInst(Value *ParentPad, ArrayRef Args, - unsigned Values, const Twine &NameStr, - Instruction *InsertBefore) - : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values, - NameStr, InsertBefore) {} - explicit CleanupPadInst(Value *ParentPad, ArrayRef Args, - unsigned Values, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values, - 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 = "", - Instruction *InsertBefore = nullptr) { + InsertPosition InsertBefore = nullptr) { unsigned Values = 1 + Args.size(); return new (Values) CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore); } - static CleanupPadInst *Create(Value *ParentPad, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - unsigned Values = 1 + Args.size(); - return new (Values) - CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd); - } - /// Methods for support type inquiry through isa, cast, and dyn_cast: static bool classof(const Instruction *I) { return I->getOpcode() == Instruction::CleanupPad; @@ -5076,44 +4134,19 @@ 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) + InsertPosition InsertBefore) : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values, NameStr, InsertBefore) {} - explicit CatchPadInst(Value *CatchSwitch, ArrayRef Args, - unsigned Values, const Twine &NameStr, - BasicBlock *InsertAtEnd) - : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values, - 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) { + InsertPosition InsertBefore = nullptr) { unsigned Values = 1 + Args.size(); return new (Values) CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore); } - static CatchPadInst *Create(Value *CatchSwitch, ArrayRef Args, - const Twine &NameStr, BasicBlock *InsertAtEnd) { - unsigned Values = 1 + Args.size(); - return new (Values) - CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd); - } - /// Convenience accessors CatchSwitchInst *getCatchSwitch() const { return cast(Op<-1>()); @@ -5138,10 +4171,7 @@ 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); + CatchReturnInst(Value *CatchPad, BasicBlock *BB, InsertPosition InsertBefore); void init(Value *CatchPad, BasicBlock *BB); @@ -5153,26 +4183,12 @@ class CatchReturnInst : public Instruction { public: static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB, - BasicBlock::iterator InsertBefore) { + InsertPosition InsertBefore = nullptr) { assert(CatchPad); assert(BB); return new (2) CatchReturnInst(CatchPad, BB, InsertBefore); } - static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB, - Instruction *InsertBefore = nullptr) { - assert(CatchPad); - assert(BB); - return new (2) CatchReturnInst(CatchPad, BB, InsertBefore); - } - - static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB, - BasicBlock *InsertAtEnd) { - assert(CatchPad); - assert(BB); - return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -5232,11 +4248,7 @@ 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, - BasicBlock *InsertAtEnd); + InsertPosition InsertBefore = nullptr); void init(Value *CleanupPad, BasicBlock *UnwindBB); @@ -5247,19 +4259,9 @@ 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) { + InsertPosition InsertBefore = nullptr) { assert(CleanupPad); unsigned Values = 1; if (UnwindBB) @@ -5268,16 +4270,6 @@ class CleanupReturnInst : public Instruction { CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore); } - static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB, - BasicBlock *InsertAtEnd) { - assert(CleanupPad); - unsigned Values = 1; - if (UnwindBB) - ++Values; - return new (Values) - CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd); - } - /// Provide fast operand accessors DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); @@ -5354,9 +4346,8 @@ 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); + explicit UnreachableInst(LLVMContext &C, + InsertPosition InsertBefore = nullptr); // allocate space for exactly zero operands void *operator new(size_t S) { return User::operator new(S, 0); } @@ -5399,27 +4390,11 @@ class TruncInst : public CastInst { enum { AnyWrap = 0, NoUnsignedWrap = (1 << 0), NoSignedWrap = (1 << 1) }; /// 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 - Type *Ty, ///< The (smaller) type to truncate to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5479,27 +4454,11 @@ class ZExtInst : public CastInst { 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 - Type *Ty, ///< The type to zero extend to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end 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 *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5526,27 +4485,11 @@ class SExtInst : public CastInst { 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 - Type *Ty, ///< The type to sign extend to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + 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 + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5571,29 +4514,12 @@ class FPTruncInst : public CastInst { /// Clone an identical FPTruncInst 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 - Type *Ty, ///< The type to truncate to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// 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 *InsertAtEnd ///< The block to insert the instruction into +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 + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5620,27 +4546,11 @@ class FPExtInst : public CastInst { 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 - Type *Ty, ///< The type to extend to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + FPExtInst(Value *S, ///< The value to be extended + Type *Ty, ///< The type to extend to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5667,27 +4577,11 @@ class UIToFPInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + UIToFPInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5714,27 +4608,11 @@ class SIToFPInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + SIToFPInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5761,27 +4639,11 @@ class FPToUIInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< Where to insert the new instruction + FPToUIInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5808,27 +4670,11 @@ class FPToSIInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + FPToSIInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -5851,27 +4697,11 @@ class IntToPtrInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + IntToPtrInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Clone an identical IntToPtrInst. @@ -5906,27 +4736,11 @@ class PtrToIntInst : public CastInst { 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 - Type *Ty, ///< The type to convert to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + PtrToIntInst(Value *S, ///< The value to be converted + Type *Ty, ///< The type to convert to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); /// Gets the pointer operand. @@ -5965,27 +4779,11 @@ class BitCastInst : public CastInst { 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 - Type *Ty, ///< The type to casted to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + BitCastInst(Value *S, ///< The value to be casted + Type *Ty, ///< The type to casted to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); // Methods for support type inquiry through isa, cast, and dyn_cast: @@ -6014,26 +4812,11 @@ class AddrSpaceCastInst : public CastInst { 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 - Type *Ty, ///< The type to casted to - const Twine &NameStr = "", ///< A name for the new instruction - Instruction *InsertBefore = nullptr ///< Where to insert the new instruction - ); - - /// Constructor with insert-at-end-of-block 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 *InsertAtEnd ///< The block to insert the instruction into + Value *S, ///< The value to be casted + Type *Ty, ///< The type to casted to + const Twine &NameStr = "", ///< A name for the new instruction + InsertPosition InsertBefore = + nullptr ///< Where to insert the new instruction ); // Methods for support type inquiry through isa, cast, and dyn_cast: @@ -6162,12 +4945,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); - FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd); + explicit FreezeInst(Value *S, const Twine &NameStr = "", + InsertPosition InsertBefore = nullptr); // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const Instruction *I) { diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp index de0de13ef38ce..9dd16fee6b901 100644 --- a/llvm/lib/IR/Instruction.cpp +++ b/llvm/lib/IR/Instruction.cpp @@ -25,35 +25,23 @@ #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) { - // 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); -} +InsertPosition::InsertPosition(Instruction *InsertBefore) + : InsertAt(InsertBefore ? InsertBefore->getIterator() + : InstListType::iterator()) {} +InsertPosition::InsertPosition(BasicBlock *InsertAtEnd) + : InsertAt(InsertAtEnd ? InsertAtEnd->end() : InstListType::iterator()) {} Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, - Instruction *InsertBefore) + InsertPosition InsertBefore) : User(ty, Value::InstructionVal + it, Ops, NumOps) { - - // If requested, insert this instruction into a basic block... - if (InsertBefore) { - BasicBlock *BB = InsertBefore->getParent(); + // When called with an iterator, there must be a block to insert into. + if (InstListType::iterator InsertIt = InsertBefore; InsertIt.isValid()) { + BasicBlock *BB = InsertIt.getNodeParent(); assert(BB && "Instruction to insert before is not in a basic block!"); - insertInto(BB, InsertBefore->getIterator()); + insertInto(BB, InsertBefore); } } -Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, - BasicBlock *InsertAtEnd) - : User(ty, Value::InstructionVal + it, Ops, NumOps) { - // If requested, append this instruction into the basic block. - if (InsertAtEnd) - insertInto(InsertAtEnd, InsertAtEnd->end()); -} - Instruction::~Instruction() { assert(!getParent() && "Instruction still linked in the program!"); diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index de369bd62a617..2e1fd2a96ffff 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -233,23 +233,11 @@ bool PHINode::hasConstantOrUndefValue() const { LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues, const Twine &NameStr, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - init(NumReservedValues, NameStr); -} - -LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues, - const Twine &NameStr, BasicBlock *InsertAtEnd) - : Instruction(RetTy, Instruction::LandingPad, nullptr, 0, InsertAtEnd) { - init(NumReservedValues, NameStr); -} - LandingPadInst::LandingPadInst(const LandingPadInst &LP) : Instruction(LP.getType(), Instruction::LandingPad, nullptr, LP.getNumOperands()), @@ -265,16 +253,10 @@ LandingPadInst::LandingPadInst(const LandingPadInst &LP) LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertBefore); } -LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses, - const Twine &NameStr, - BasicBlock *InsertAtEnd) { - return new LandingPadInst(RetTy, NumReservedClauses, NameStr, InsertAtEnd); -} - void LandingPadInst::init(unsigned NumReservedValues, const Twine &NameStr) { ReservedSpace = NumReservedValues; setNumHungOffUseOperands(0); @@ -305,21 +287,7 @@ void LandingPadInst::addClause(Constant *Val) { //===----------------------------------------------------------------------===// CallBase *CallBase::Create(CallBase *CB, ArrayRef Bundles, - BasicBlock::iterator InsertPt) { - switch (CB->getOpcode()) { - case Instruction::Call: - return CallInst::Create(cast(CB), Bundles, InsertPt); - case Instruction::Invoke: - return InvokeInst::Create(cast(CB), Bundles, InsertPt); - case Instruction::CallBr: - return CallBrInst::Create(cast(CB), Bundles, InsertPt); - default: - llvm_unreachable("Unknown CallBase sub-class!"); - } -} - -CallBase *CallBase::Create(CallBase *CB, ArrayRef Bundles, - Instruction *InsertPt) { + InsertPosition InsertPt) { switch (CB->getOpcode()) { case Instruction::Call: return CallInst::Create(cast(CB), Bundles, InsertPt); @@ -333,7 +301,7 @@ CallBase *CallBase::Create(CallBase *CB, ArrayRef Bundles, } CallBase *CallBase::Create(CallBase *CI, OperandBundleDef OpB, - Instruction *InsertPt) { + InsertPosition InsertPt) { SmallVector OpDefs; for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) { auto ChildOB = CI->getOperandBundleAt(i); @@ -344,7 +312,6 @@ CallBase *CallBase::Create(CallBase *CI, OperandBundleDef OpB, return CallBase::Create(CI, OpDefs, InsertPt); } - Function *CallBase::getCaller() { return getParent()->getParent(); } unsigned CallBase::getNumSubclassExtraOperandsDynamic() const { @@ -582,19 +549,7 @@ CallBase::BundleOpInfo &CallBase::getBundleOpInfoForOperand(unsigned OpIdx) { CallBase *CallBase::addOperandBundle(CallBase *CB, uint32_t ID, OperandBundleDef OB, - BasicBlock::iterator InsertPt) { - if (CB->getOperandBundle(ID)) - return CB; - - SmallVector Bundles; - CB->getOperandBundlesAsDefs(Bundles); - Bundles.push_back(OB); - return Create(CB, Bundles, InsertPt); -} - -CallBase *CallBase::addOperandBundle(CallBase *CB, uint32_t ID, - OperandBundleDef OB, - Instruction *InsertPt) { + InsertPosition InsertPt) { if (CB->getOperandBundle(ID)) return CB; @@ -605,24 +560,7 @@ CallBase *CallBase::addOperandBundle(CallBase *CB, uint32_t ID, } CallBase *CallBase::removeOperandBundle(CallBase *CB, uint32_t ID, - BasicBlock::iterator InsertPt) { - SmallVector Bundles; - bool CreateNew = false; - - for (unsigned I = 0, E = CB->getNumOperandBundles(); I != E; ++I) { - auto Bundle = CB->getOperandBundleAt(I); - if (Bundle.getTagID() == ID) { - CreateNew = true; - continue; - } - Bundles.emplace_back(Bundle); - } - - return CreateNew ? Create(CB, Bundles, InsertPt) : CB; -} - -CallBase *CallBase::removeOperandBundle(CallBase *CB, uint32_t ID, - Instruction *InsertPt) { + InsertPosition InsertPt) { SmallVector Bundles; bool CreateNew = false; @@ -769,26 +707,12 @@ void CallInst::init(FunctionType *FTy, Value *Func, const Twine &NameStr) { } CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : CallBase(Ty->getReturnType(), Instruction::Call, OperandTraits::op_end(this) - 1, 1, InsertBefore) { init(Ty, Func, Name); } -CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name, - Instruction *InsertBefore) - : CallBase(Ty->getReturnType(), Instruction::Call, - OperandTraits::op_end(this) - 1, 1, InsertBefore) { - init(Ty, Func, Name); -} - -CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name, - BasicBlock *InsertAtEnd) - : CallBase(Ty->getReturnType(), Instruction::Call, - OperandTraits::op_end(this) - 1, 1, InsertAtEnd) { - init(Ty, Func, Name); -} - CallInst::CallInst(const CallInst &CI) : CallBase(CI.Attrs, CI.FTy, CI.getType(), Instruction::Call, OperandTraits::op_end(this) - CI.getNumOperands(), @@ -803,21 +727,7 @@ CallInst::CallInst(const CallInst &CI) } 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) { + InsertPosition InsertPt) { std::vector Args(CI->arg_begin(), CI->arg_end()); auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledOperand(), @@ -896,21 +806,7 @@ InvokeInst::InvokeInst(const InvokeInst &II) } InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef OpB, - BasicBlock::iterator InsertPt) { - std::vector Args(II->arg_begin(), II->arg_end()); - - auto *NewII = InvokeInst::Create( - II->getFunctionType(), II->getCalledOperand(), II->getNormalDest(), - II->getUnwindDest(), Args, OpB, II->getName(), InsertPt); - NewII->setCallingConv(II->getCallingConv()); - NewII->SubclassOptionalData = II->SubclassOptionalData; - NewII->setAttributes(II->getAttributes()); - NewII->setDebugLoc(II->getDebugLoc()); - return NewII; -} - -InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef OpB, - Instruction *InsertPt) { + InsertPosition InsertPt) { std::vector Args(II->arg_begin(), II->arg_end()); auto *NewII = InvokeInst::Create( @@ -995,22 +891,7 @@ CallBrInst::CallBrInst(const CallBrInst &CBI) } CallBrInst *CallBrInst::Create(CallBrInst *CBI, ArrayRef OpB, - BasicBlock::iterator InsertPt) { - std::vector Args(CBI->arg_begin(), CBI->arg_end()); - - auto *NewCBI = CallBrInst::Create( - CBI->getFunctionType(), CBI->getCalledOperand(), CBI->getDefaultDest(), - CBI->getIndirectDests(), Args, OpB, CBI->getName(), InsertPt); - NewCBI->setCallingConv(CBI->getCallingConv()); - NewCBI->SubclassOptionalData = CBI->SubclassOptionalData; - NewCBI->setAttributes(CBI->getAttributes()); - NewCBI->setDebugLoc(CBI->getDebugLoc()); - NewCBI->NumIndirectDests = CBI->NumIndirectDests; - return NewCBI; -} - -CallBrInst *CallBrInst::Create(CallBrInst *CBI, ArrayRef OpB, - Instruction *InsertPt) { + InsertPosition InsertPt) { std::vector Args(CBI->arg_begin(), CBI->arg_end()); auto *NewCBI = CallBrInst::Create( @@ -1038,7 +919,7 @@ ReturnInst::ReturnInst(const ReturnInst &RI) } ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(C), Instruction::Ret, OperandTraits::op_end(this) - !!retVal, !!retVal, InsertBefore) { @@ -1046,27 +927,6 @@ ReturnInst::ReturnInst(LLVMContext &C, Value *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) { - if (retVal) - Op<0>() = retVal; -} - -ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(C), Instruction::Ret, - OperandTraits::op_end(this) - !!retVal, !!retVal, - InsertAtEnd) { - if (retVal) - Op<0>() = retVal; -} - -ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(Context), Instruction::Ret, - OperandTraits::op_end(this), 0, InsertAtEnd) {} - //===----------------------------------------------------------------------===// // ResumeInst Implementation //===----------------------------------------------------------------------===// @@ -1077,24 +937,12 @@ ResumeInst::ResumeInst(const ResumeInst &RI) Op<0>() = RI.Op<0>(); } -ResumeInst::ResumeInst(Value *Exn, BasicBlock::iterator InsertBefore) +ResumeInst::ResumeInst(Value *Exn, InsertPosition 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) { - Op<0>() = Exn; -} - -ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume, - OperandTraits::op_begin(this), 1, InsertAtEnd) { - Op<0>() = Exn; -} - //===----------------------------------------------------------------------===// // CleanupReturnInst Implementation //===----------------------------------------------------------------------===// @@ -1122,16 +970,7 @@ void CleanupReturnInst::init(Value *CleanupPad, BasicBlock *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) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(CleanupPad->getContext()), Instruction::CleanupRet, OperandTraits::op_end(this) - Values, @@ -1139,15 +978,6 @@ CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, init(CleanupPad, UnwindBB); } -CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, - unsigned Values, BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(CleanupPad->getContext()), - Instruction::CleanupRet, - OperandTraits::op_end(this) - Values, - Values, InsertAtEnd) { - init(CleanupPad, UnwindBB); -} - //===----------------------------------------------------------------------===// // CatchReturnInst Implementation //===----------------------------------------------------------------------===// @@ -1164,29 +994,13 @@ CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI) } CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB, - BasicBlock::iterator InsertBefore) + InsertPosition 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, - OperandTraits::op_begin(this), 2, - InsertBefore) { - init(CatchPad, BB); -} - -CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet, - OperandTraits::op_begin(this), 2, - InsertAtEnd) { - init(CatchPad, BB); -} - //===----------------------------------------------------------------------===// // CatchSwitchInst Implementation //===----------------------------------------------------------------------===// @@ -1194,19 +1008,7 @@ CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB, CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReservedValues, const Twine &NameStr, - BasicBlock::iterator InsertBefore) - : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0, - InsertBefore) { - if (UnwindDest) - ++NumReservedValues; - init(ParentPad, UnwindDest, NumReservedValues + 1); - setName(NameStr); -} - -CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, - unsigned NumReservedValues, - const Twine &NameStr, - Instruction *InsertBefore) + InsertPosition InsertBefore) : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0, InsertBefore) { if (UnwindDest) @@ -1215,17 +1017,6 @@ CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, setName(NameStr); } -CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest, - unsigned NumReservedValues, - const Twine &NameStr, BasicBlock *InsertAtEnd) - : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0, - InsertAtEnd) { - if (UnwindDest) - ++NumReservedValues; - init(ParentPad, UnwindDest, NumReservedValues + 1); - setName(NameStr); -} - CatchSwitchInst::CatchSwitchInst(const CatchSwitchInst &CSI) : Instruction(CSI.getType(), Instruction::CatchSwitch, nullptr, CSI.getNumOperands()) { @@ -1305,46 +1096,21 @@ FuncletPadInst::FuncletPadInst(const FuncletPadInst &FPI) 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) + InsertPosition 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, BasicBlock *InsertAtEnd) - : Instruction(ParentPad->getType(), Op, - OperandTraits::op_end(this) - Values, Values, - InsertAtEnd) { - init(ParentPad, Args, NameStr); -} - //===----------------------------------------------------------------------===// // UnreachableInst Implementation //===----------------------------------------------------------------------===// UnreachableInst::UnreachableInst(LLVMContext &Context, - BasicBlock::iterator InsertBefore) - : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr, - 0, InsertBefore) {} -UnreachableInst::UnreachableInst(LLVMContext &Context, - Instruction *InsertBefore) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr, 0, InsertBefore) {} -UnreachableInst::UnreachableInst(LLVMContext &Context, BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr, - 0, InsertAtEnd) {} //===----------------------------------------------------------------------===// // BranchInst Implementation @@ -1356,15 +1122,7 @@ 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) +BranchInst::BranchInst(BasicBlock *IfTrue, InsertPosition InsertBefore) : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, OperandTraits::op_end(this) - 1, 1, InsertBefore) { @@ -1373,7 +1131,7 @@ BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore) } BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, OperandTraits::op_end(this) - 3, 3, InsertBefore) { @@ -1386,40 +1144,6 @@ BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, #endif } -BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - Instruction *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 *InsertAtEnd) - : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, - OperandTraits::op_end(this) - 1, 1, InsertAtEnd) { - assert(IfTrue && "Branch destination may not be null!"); - Op<-1>() = IfTrue; -} - -BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br, - OperandTraits::op_end(this) - 3, 3, InsertAtEnd) { - // 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(const BranchInst &BI) : Instruction(Type::getVoidTy(BI.getContext()), Instruction::Br, OperandTraits::op_end(this) - BI.getNumOperands(), @@ -1460,56 +1184,29 @@ static Value *getAISize(LLVMContext &Context, Value *Amt) { return Amt; } -static Align computeAllocaDefaultAlign(Type *Ty, BasicBlock *BB) { - assert(BB && "Insertion BB cannot be null when alignment not provided!"); +static Align computeAllocaDefaultAlign(Type *Ty, InsertPosition Pos) { + assert(Pos.isValid() && + "Insertion position cannot be null when alignment not provided!"); + BasicBlock *BB = Pos.getBasicBlock(); assert(BB->getParent() && "BB must be in a Function when alignment not provided!"); const DataLayout &DL = BB->getModule()->getDataLayout(); 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) + InsertPosition 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) {} - -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) + const Twine &Name, InsertPosition InsertBefore) : AllocaInst(Ty, AddrSpace, ArraySize, computeAllocaDefaultAlign(Ty, InsertBefore), Name, InsertBefore) {} -AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, - const Twine &Name, BasicBlock *InsertAtEnd) - : AllocaInst(Ty, AddrSpace, ArraySize, - computeAllocaDefaultAlign(Ty, InsertAtEnd), Name, - InsertAtEnd) {} - AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca, getAISize(Ty->getContext(), ArraySize), InsertBefore), AllocatedType(Ty) { @@ -1518,28 +1215,6 @@ AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, setName(Name); } -AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, - Align Align, const Twine &Name, - Instruction *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, BasicBlock *InsertAtEnd) - : UnaryInstruction(PointerType::get(Ty, AddrSpace), Alloca, - getAISize(Ty->getContext(), ArraySize), InsertAtEnd), - AllocatedType(Ty) { - setAlignment(Align); - assert(!Ty->isVoidTy() && "Cannot allocate void!"); - setName(Name); -} - - bool AllocaInst::isArrayAllocation() const { if (ConstantInt *CI = dyn_cast(getOperand(0))) return !CI->isOne(); @@ -1567,68 +1242,33 @@ void LoadInst::AssertOK() { "Ptr must have pointer type."); } -static Align computeLoadStoreDefaultAlign(Type *Ty, BasicBlock *BB) { - assert(BB && "Insertion BB cannot be null when alignment not provided!"); +static Align computeLoadStoreDefaultAlign(Type *Ty, InsertPosition Pos) { + assert(Pos.isValid() && + "Insertion position cannot be null when alignment not provided!"); + BasicBlock *BB = Pos.getBasicBlock(); assert(BB->getParent() && "BB must be in a Function when alignment not provided!"); const DataLayout &DL = BB->getModule()->getDataLayout(); 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) + InsertPosition InsertBef) : LoadInst(Ty, Ptr, Name, /*isVolatile=*/false, InsertBef) {} -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) + InsertPosition InsertBef) : LoadInst(Ty, Ptr, Name, isVolatile, computeLoadStoreDefaultAlign(Ty, InsertBef), InsertBef) {} LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, - BasicBlock *InsertAE) - : 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) + Align Align, InsertPosition 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, BasicBlock *InsertAE) - : 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) + InsertPosition InsertBef) : UnaryInstruction(Ty, Load, Ptr, InsertBef) { setVolatile(isVolatile); setAlignment(Align); @@ -1637,28 +1277,6 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, setName(Name); } -LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile, - Align Align, AtomicOrdering Order, SyncScope::ID SSID, - Instruction *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, - BasicBlock *InsertAE) - : UnaryInstruction(Ty, Load, Ptr, InsertAE) { - setVolatile(isVolatile); - setAlignment(Align); - setAtomic(Order, SSID); - AssertOK(); - setName(Name); -} - //===----------------------------------------------------------------------===// // StoreInst Implementation //===----------------------------------------------------------------------===// @@ -1669,51 +1287,23 @@ void StoreInst::AssertOK() { "Ptr must have pointer type!"); } -StoreInst::StoreInst(Value *val, Value *addr, Instruction *InsertBefore) - : StoreInst(val, addr, /*isVolatile=*/false, InsertBefore) {} - -StoreInst::StoreInst(Value *val, Value *addr, BasicBlock *InsertAtEnd) - : StoreInst(val, addr, /*isVolatile=*/false, InsertAtEnd) {} - -StoreInst::StoreInst(Value *val, Value *addr, BasicBlock::iterator InsertBefore) +StoreInst::StoreInst(Value *val, Value *addr, InsertPosition InsertBefore) : StoreInst(val, addr, /*isVolatile=*/false, InsertBefore) {} StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, - Instruction *InsertBefore) + InsertPosition InsertBefore) : StoreInst(val, addr, isVolatile, computeLoadStoreDefaultAlign(val->getType(), InsertBefore), InsertBefore) {} -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, - BasicBlock *InsertAtEnd) - : StoreInst(val, addr, isVolatile, - computeLoadStoreDefaultAlign(val->getType(), InsertAtEnd), - InsertAtEnd) {} - -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, - BasicBlock::iterator InsertBefore) - : StoreInst(val, addr, isVolatile, - computeLoadStoreDefaultAlign(val->getType(), &*InsertBefore), - InsertBefore) {} - -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, - Instruction *InsertBefore) - : StoreInst(val, addr, isVolatile, Align, AtomicOrdering::NotAtomic, - SyncScope::System, InsertBefore) {} - -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, - BasicBlock *InsertAtEnd) - : StoreInst(val, addr, isVolatile, Align, AtomicOrdering::NotAtomic, - SyncScope::System, InsertAtEnd) {} - StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : StoreInst(val, addr, isVolatile, Align, AtomicOrdering::NotAtomic, SyncScope::System, InsertBefore) {} StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, AtomicOrdering Order, SyncScope::ID SSID, - Instruction *InsertBefore) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(val->getContext()), Store, OperandTraits::op_begin(this), OperandTraits::operands(this), InsertBefore) { @@ -1725,35 +1315,6 @@ StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, AssertOK(); } -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, - AtomicOrdering Order, SyncScope::ID SSID, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(val->getContext()), Store, - OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertAtEnd) { - Op<0>() = val; - Op<1>() = addr; - setVolatile(isVolatile); - setAlignment(Align); - setAtomic(Order, SSID); - AssertOK(); -} - -StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, Align Align, - AtomicOrdering Order, SyncScope::ID SSID, - BasicBlock::iterator InsertBefore) - : Instruction(Type::getVoidTy(val->getContext()), Store, - OperandTraits::op_begin(this), - OperandTraits::operands(this)) { - Op<0>() = val; - Op<1>() = addr; - setVolatile(isVolatile); - setAlignment(Align); - setAtomic(Order, SSID); - insertBefore(*InsertBefore->getParent(), InsertBefore); - AssertOK(); -} - //===----------------------------------------------------------------------===// // AtomicCmpXchgInst Implementation //===----------------------------------------------------------------------===// @@ -1783,20 +1344,7 @@ AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, 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, - AtomicOrdering FailureOrdering, - SyncScope::ID SSID, - Instruction *InsertBefore) + InsertPosition InsertBefore) : Instruction( StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())), AtomicCmpXchg, OperandTraits::op_begin(this), @@ -1804,19 +1352,6 @@ AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Init(Ptr, Cmp, NewVal, Alignment, SuccessOrdering, FailureOrdering, SSID); } -AtomicCmpXchgInst::AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, - Align Alignment, - AtomicOrdering SuccessOrdering, - AtomicOrdering FailureOrdering, - SyncScope::ID SSID, - BasicBlock *InsertAtEnd) - : Instruction( - StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())), - AtomicCmpXchg, OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertAtEnd) { - Init(Ptr, Cmp, NewVal, Alignment, SuccessOrdering, FailureOrdering, SSID); -} - //===----------------------------------------------------------------------===// // AtomicRMWInst Implementation //===----------------------------------------------------------------------===// @@ -1832,42 +1367,22 @@ void AtomicRMWInst::Init(BinOp Operation, Value *Ptr, Value *Val, Op<1>() = Val; setOperation(Operation); setOrdering(Ordering); - setSyncScopeID(SSID); - setAlignment(Alignment); - - assert(getOperand(0) && getOperand(1) && - "All operands must be non-null!"); - assert(getOperand(0)->getType()->isPointerTy() && - "Ptr must have pointer type!"); - assert(Ordering != AtomicOrdering::NotAtomic && - "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); -} + setSyncScopeID(SSID); + setAlignment(Alignment); -AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, - Align Alignment, AtomicOrdering Ordering, - SyncScope::ID SSID, Instruction *InsertBefore) - : Instruction(Val->getType(), AtomicRMW, - OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertBefore) { - Init(Operation, Ptr, Val, Alignment, Ordering, SSID); + assert(getOperand(0) && getOperand(1) && "All operands must be non-null!"); + assert(getOperand(0)->getType()->isPointerTy() && + "Ptr must have pointer type!"); + assert(Ordering != AtomicOrdering::NotAtomic && + "AtomicRMW instructions must be atomic!"); } AtomicRMWInst::AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment, AtomicOrdering Ordering, - SyncScope::ID SSID, BasicBlock *InsertAtEnd) + SyncScope::ID SSID, InsertPosition InsertBefore) : Instruction(Val->getType(), AtomicRMW, OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertAtEnd) { + OperandTraits::operands(this), InsertBefore) { Init(Operation, Ptr, Val, Alignment, Ordering, SSID); } @@ -1919,28 +1434,12 @@ StringRef AtomicRMWInst::getOperationName(BinOp Op) { //===----------------------------------------------------------------------===// FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, - SyncScope::ID SSID, BasicBlock::iterator InsertBefore) + SyncScope::ID SSID, InsertPosition InsertBefore) : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) { setOrdering(Ordering); setSyncScopeID(SSID); } -FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, - SyncScope::ID SSID, - Instruction *InsertBefore) - : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) { - setOrdering(Ordering); - setSyncScopeID(SSID); -} - -FenceInst::FenceInst(LLVMContext &C, AtomicOrdering Ordering, - SyncScope::ID SSID, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) { - setOrdering(Ordering); - setSyncScopeID(SSID); -} - //===----------------------------------------------------------------------===// // GetElementPtrInst Implementation //===----------------------------------------------------------------------===// @@ -2093,7 +1592,7 @@ bool GetElementPtrInst::collectOffset( ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, const Twine &Name, - BasicBlock::iterator InsertBef) + InsertPosition InsertBef) : Instruction( cast(Val->getType())->getElementType(), ExtractElement, OperandTraits::op_begin(this), 2, InsertBef) { @@ -2104,35 +1603,6 @@ ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, setName(Name); } -ExtractElementInst::ExtractElementInst(Value *Val, Value *Index, - const Twine &Name, - Instruction *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, - BasicBlock *InsertAE) - : Instruction(cast(Val->getType())->getElementType(), - ExtractElement, - OperandTraits::op_begin(this), - 2, InsertAE) { - assert(isValidOperands(Val, Index) && - "Invalid extractelement instruction operands!"); - - Op<0>() = Val; - Op<1>() = Index; - setName(Name); -} - bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) { if (!Val->getType()->isVectorTy() || !Index->getType()->isIntegerTy()) return false; @@ -2145,7 +1615,7 @@ bool ExtractElementInst::isValidOperands(const Value *Val, const Value *Index) { InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, const Twine &Name, - BasicBlock::iterator InsertBef) + InsertPosition InsertBef) : Instruction(Vec->getType(), InsertElement, OperandTraits::op_begin(this), 3, InsertBef) { @@ -2157,35 +1627,6 @@ InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, setName(Name); } -InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index, - const Twine &Name, - Instruction *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, - BasicBlock *InsertAE) - : Instruction(Vec->getType(), InsertElement, - OperandTraits::op_begin(this), - 3, InsertAE) { - assert(isValidOperands(Vec, Elt, Index) && - "Invalid insertelement instruction operands!"); - - Op<0>() = Vec; - Op<1>() = Elt; - Op<2>() = Index; - setName(Name); -} - bool InsertElementInst::isValidOperands(const Value *Vec, const Value *Elt, const Value *Index) { if (!Vec->getType()->isVectorTy()) @@ -2209,59 +1650,19 @@ static Value *createPlaceholderForShuffleVector(Value *V) { } 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, - InsertBefore) {} - -ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *Mask, const Twine &Name, - BasicBlock *InsertAtEnd) - : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name, - InsertAtEnd) {} - -ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef Mask, - const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name, InsertBefore) {} ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef Mask, const Twine &Name, - Instruction *InsertBefore) + InsertPosition InsertBefore) : ShuffleVectorInst(V1, createPlaceholderForShuffleVector(V1), Mask, Name, InsertBefore) {} -ShuffleVectorInst::ShuffleVectorInst(Value *V1, ArrayRef Mask, - const Twine &Name, BasicBlock *InsertAtEnd) - : 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) + InsertPosition InsertBefore) : Instruction( VectorType::get(cast(V1->getType())->getElementType(), cast(Mask->getType())->getElementCount()), @@ -2278,27 +1679,9 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, setName(Name); } -ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, Value *Mask, - const Twine &Name, BasicBlock *InsertAtEnd) - : Instruction( - VectorType::get(cast(V1->getType())->getElementType(), - cast(Mask->getType())->getElementCount()), - ShuffleVector, OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertAtEnd) { - 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, ArrayRef Mask, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition InsertBefore) : Instruction( VectorType::get(cast(V1->getType())->getElementType(), Mask.size(), isa(V1->getType())), @@ -2312,38 +1695,6 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef Mask, setName(Name); } -ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef Mask, - const Twine &Name, - Instruction *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, BasicBlock *InsertAtEnd) - : Instruction( - VectorType::get(cast(V1->getType())->getElementType(), - Mask.size(), isa(V1->getType())), - ShuffleVector, OperandTraits::op_begin(this), - OperandTraits::operands(this), InsertAtEnd) { - assert(isValidOperands(V1, V2, Mask) && - "Invalid shuffle vector instruction operands!"); - - Op<0>() = V1; - Op<1>() = V2; - setShuffleMask(Mask); - setName(Name); -} - void ShuffleVectorInst::commute() { int NumOpElts = cast(Op<0>()->getType())->getNumElements(); int NumMaskElts = ShuffleMask.size(); @@ -3165,51 +2516,18 @@ Type *ExtractValueInst::getIndexedType(Type *Agg, //===----------------------------------------------------------------------===// UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, Type *Ty, - const Twine &Name, - BasicBlock::iterator InsertBefore) + const Twine &Name, InsertPosition 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) - : UnaryInstruction(Ty, iType, S, InsertBefore) { - Op<0>() = S; - setName(Name); - AssertOK(); -} - -UnaryOperator::UnaryOperator(UnaryOps iType, Value *S, - Type *Ty, const Twine &Name, - BasicBlock *InsertAtEnd) - : UnaryInstruction(Ty, iType, S, InsertAtEnd) { - Op<0>() = S; - setName(Name); - 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) { + InsertPosition InsertBefore) { return new UnaryOperator(Op, S, S->getType(), Name, InsertBefore); } -UnaryOperator *UnaryOperator::Create(UnaryOps Op, Value *S, - const Twine &Name, - BasicBlock *InsertAtEnd) { - UnaryOperator *Res = Create(Op, S, Name); - Res->insertInto(InsertAtEnd, InsertAtEnd->end()); - return Res; -} - void UnaryOperator::AssertOK() { Value *LHS = getOperand(0); (void)LHS; // Silence warnings. @@ -3232,8 +2550,7 @@ void UnaryOperator::AssertOK() { //===----------------------------------------------------------------------===// BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, - const Twine &Name, - BasicBlock::iterator InsertBefore) + const Twine &Name, InsertPosition InsertBefore) : Instruction(Ty, iType, OperandTraits::op_begin(this), OperandTraits::operands(this), InsertBefore) { Op<0>() = S1; @@ -3242,32 +2559,6 @@ BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, AssertOK(); } -BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2, - Type *Ty, const Twine &Name, - Instruction *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, - BasicBlock *InsertAtEnd) - : Instruction(Ty, iType, - OperandTraits::op_begin(this), - OperandTraits::operands(this), - InsertAtEnd) { - Op<0>() = S1; - Op<1>() = S2; - setName(Name); - AssertOK(); -} - void BinaryOperator::AssertOK() { Value *LHS = getOperand(0), *RHS = getOperand(1); (void)LHS; (void)RHS; // Silence warnings. @@ -3338,76 +2629,32 @@ void BinaryOperator::AssertOK() { BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name, - BasicBlock::iterator InsertBefore) { - assert(S1->getType() == S2->getType() && - "Cannot create binary operator with two operands of differing type!"); - return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore); -} - -BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, - const Twine &Name, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { assert(S1->getType() == S2->getType() && "Cannot create binary operator with two operands of differing type!"); return new BinaryOperator(Op, S1, S2, S1->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, - const Twine &Name, - BasicBlock *InsertAtEnd) { - BinaryOperator *Res = Create(Op, S1, S2, Name); - Res->insertInto(InsertAtEnd, InsertAtEnd->end()); - return Res; -} - BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const Twine &Name, - BasicBlock::iterator InsertBefore) { + InsertPosition 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, - BasicBlock *InsertAtEnd) { - Value *Zero = ConstantInt::get(Op->getType(), 0); - return new BinaryOperator(Instruction::Sub, - Zero, Op, - Op->getType(), Name, InsertAtEnd); -} - BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { Value *Zero = ConstantInt::get(Op->getType(), 0); return BinaryOperator::CreateNSWSub(Zero, Op, Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateNSWNeg(Value *Op, const Twine &Name, - BasicBlock *InsertAtEnd) { - Value *Zero = ConstantInt::get(Op->getType(), 0); - return BinaryOperator::CreateNSWSub(Zero, Op, Name, InsertAtEnd); -} - -BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, - BasicBlock::iterator InsertBefore) { - Constant *C = Constant::getAllOnesValue(Op->getType()); - return new BinaryOperator(Instruction::Xor, Op, C, - Op->getType(), Name, InsertBefore); -} - BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { Constant *C = Constant::getAllOnesValue(Op->getType()); return new BinaryOperator(Instruction::Xor, Op, C, Op->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name, - BasicBlock *InsertAtEnd) { - Constant *AllOnes = Constant::getAllOnesValue(Op->getType()); - return new BinaryOperator(Instruction::Xor, Op, AllOnes, - Op->getType(), Name, InsertAtEnd); -} - // Exchange the two operands to this instruction. This instruction is safe to // use on any binary instruction and does not modify the semantics of the // instruction. If the instruction is order-dependent (SetLT f.e.), the opcode @@ -3714,30 +2961,7 @@ 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) { + const Twine &Name, InsertPosition InsertBefore) { assert(castIsValid(op, S, Ty) && "Invalid cast!"); // Construct and return the appropriate CastInst subclass switch (op) { @@ -3751,143 +2975,40 @@ CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty, 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, BasicBlock *InsertAtEnd) { - assert(castIsValid(op, S, Ty) && "Invalid cast!"); - // Construct and return the appropriate CastInst subclass - switch (op) { - case Trunc: return new TruncInst (S, Ty, Name, InsertAtEnd); - case ZExt: return new ZExtInst (S, Ty, Name, InsertAtEnd); - case SExt: return new SExtInst (S, Ty, Name, InsertAtEnd); - case FPTrunc: return new FPTruncInst (S, Ty, Name, InsertAtEnd); - case FPExt: return new FPExtInst (S, Ty, Name, InsertAtEnd); - case UIToFP: return new UIToFPInst (S, Ty, Name, InsertAtEnd); - case SIToFP: return new SIToFPInst (S, Ty, Name, InsertAtEnd); - case FPToUI: return new FPToUIInst (S, Ty, Name, InsertAtEnd); - case FPToSI: return new FPToSIInst (S, Ty, Name, InsertAtEnd); - case PtrToInt: return new PtrToIntInst (S, Ty, Name, InsertAtEnd); - case IntToPtr: return new IntToPtrInst (S, Ty, Name, InsertAtEnd); - case BitCast: return new BitCastInst (S, Ty, Name, InsertAtEnd); - case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd); - default: llvm_unreachable("Invalid opcode provided"); - } -} - -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) { - 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, - BasicBlock *InsertAtEnd) { - if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) - return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); - 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) { - if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) - return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); - return Create(Instruction::SExt, 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::CreateSExtOrBitCast(Value *S, Type *Ty, - const Twine &Name, - BasicBlock *InsertAtEnd) { +CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name, + InsertPosition InsertBefore) { if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) - return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); - return Create(Instruction::SExt, S, Ty, Name, InsertAtEnd); + return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); + return Create(Instruction::ZExt, S, Ty, Name, InsertBefore); } -CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) { +CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name, + InsertPosition InsertBefore) { if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); - return Create(Instruction::Trunc, S, Ty, Name, InsertBefore); + return Create(Instruction::SExt, S, Ty, Name, InsertBefore); } -CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, - const Twine &Name, - Instruction *InsertBefore) { +CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty, const Twine &Name, + InsertPosition 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, - BasicBlock *InsertAtEnd) { - if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) - return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); - return Create(Instruction::Trunc, S, Ty, Name, InsertAtEnd); -} - -CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, - const Twine &Name, - BasicBlock *InsertAtEnd) { - 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, InsertAtEnd); - - return CreatePointerBitCastOrAddrSpaceCast(S, Ty, Name, InsertAtEnd); -} - -/// Create a BitCast or a PtrToInt cast instruction -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) { + InsertPosition InsertBefore) { assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && "Invalid cast"); @@ -3904,31 +3025,7 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty, const Twine &Name, } CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( - Value *S, Type *Ty, - const Twine &Name, - BasicBlock *InsertAtEnd) { - assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); - assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); - - if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) - return Create(Instruction::AddrSpaceCast, S, Ty, Name, InsertAtEnd); - - return Create(Instruction::BitCast, S, Ty, Name, InsertAtEnd); -} - -CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( - 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) { + Value *S, Type *Ty, const Twine &Name, InsertPosition InsertBefore) { assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); @@ -3940,18 +3037,7 @@ CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast( CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) { - if (S->getType()->isPointerTy() && Ty->isIntegerTy()) - return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); - if (S->getType()->isIntegerTy() && Ty->isPointerTy()) - return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore); - - return Create(Instruction::BitCast, S, Ty, Name, InsertBefore); -} - -CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty, - const Twine &Name, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { if (S->getType()->isPointerTy() && Ty->isIntegerTy()) return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore); if (S->getType()->isIntegerTy() && Ty->isPointerTy()) @@ -3962,21 +3048,7 @@ CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty, 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) { + InsertPosition InsertBefore) { assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && "Invalid integer cast"); unsigned SrcBits = C->getType()->getScalarSizeInBits(); @@ -3988,35 +3060,8 @@ CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, return Create(opcode, C, Ty, Name, InsertBefore); } -CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty, - bool isSigned, const Twine &Name, - BasicBlock *InsertAtEnd) { - assert(C->getType()->isIntOrIntVectorTy() && Ty->isIntOrIntVectorTy() && - "Invalid 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, 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) { + InsertPosition InsertBefore) { assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && "Invalid cast"); unsigned SrcBits = C->getType()->getScalarSizeInBits(); @@ -4028,19 +3073,6 @@ CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, return Create(opcode, C, Ty, Name, InsertBefore); } -CastInst *CastInst::CreateFPCast(Value *C, Type *Ty, - const Twine &Name, - BasicBlock *InsertAtEnd) { - 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, InsertAtEnd); -} - bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) { if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType()) return false; @@ -4306,246 +3338,90 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { } TruncInst::TruncInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); -} - -TruncInst::TruncInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, Trunc, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc"); -} - ZExtInst::ZExtInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal ZExt"); -} - -ZExtInst::ZExtInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : 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) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); -} - -SExtInst::SExtInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, SExt, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal SExt"); -} - FPTruncInst::FPTruncInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); -} - -FPTruncInst::FPTruncInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, FPTrunc, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPTrunc"); -} - FPExtInst::FPExtInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); -} - -FPExtInst::FPExtInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, FPExt, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPExt"); -} - UIToFPInst::UIToFPInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); -} - -UIToFPInst::UIToFPInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, UIToFP, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal UIToFP"); -} - SIToFPInst::SIToFPInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); -} - -SIToFPInst::SIToFPInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, SIToFP, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal SIToFP"); -} - FPToUIInst::FPToUIInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); -} - -FPToUIInst::FPToUIInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, FPToUI, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToUI"); -} - FPToSIInst::FPToSIInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); -} - -FPToSIInst::FPToSIInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, FPToSI, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal FPToSI"); -} - PtrToIntInst::PtrToIntInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); -} - -PtrToIntInst::PtrToIntInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, PtrToInt, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal PtrToInt"); -} - IntToPtrInst::IntToPtrInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); -} - -IntToPtrInst::IntToPtrInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, IntToPtr, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal IntToPtr"); -} - BitCastInst::BitCastInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); -} - -BitCastInst::BitCastInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast"); -} - AddrSpaceCastInst::AddrSpaceCastInst(Value *S, Type *Ty, const Twine &Name, - BasicBlock::iterator InsertBefore) + InsertPosition 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) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); -} - -AddrSpaceCastInst::AddrSpaceCastInst( - Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd -) : CastInst(Ty, AddrSpaceCast, S, Name, InsertAtEnd) { - assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast"); -} - //===----------------------------------------------------------------------===// // CmpInst Classes //===----------------------------------------------------------------------===// CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS, - Value *RHS, const Twine &Name, - BasicBlock::iterator InsertBefore, Instruction *FlagsSource) + Value *RHS, const Twine &Name, InsertPosition InsertBefore, + Instruction *FlagsSource) : Instruction(ty, op, OperandTraits::op_begin(this), OperandTraits::operands(this), InsertBefore) { Op<0>() = LHS; @@ -4556,50 +3432,10 @@ CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS, copyIRFlags(FlagsSource); } -CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS, - Value *RHS, const Twine &Name, Instruction *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, BasicBlock *InsertAtEnd) - : Instruction(ty, op, - OperandTraits::op_begin(this), - OperandTraits::operands(this), - InsertAtEnd) { - Op<0>() = LHS; - Op<1>() = RHS; - setPredicate((Predicate)predicate); - setName(Name); -} - -CmpInst * -CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, - const Twine &Name, BasicBlock::iterator InsertBefore) { - if (Op == Instruction::ICmp) { - return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate), - S1, S2, Name); - } - - return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate), - S1, S2, Name); -} - -CmpInst * -CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, - const Twine &Name, Instruction *InsertBefore) { +CmpInst *CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, + const Twine &Name, InsertPosition InsertBefore) { if (Op == Instruction::ICmp) { - if (InsertBefore) + if (InsertBefore.isValid()) return new ICmpInst(InsertBefore, CmpInst::Predicate(predicate), S1, S2, Name); else @@ -4607,7 +3443,7 @@ CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, S1, S2, Name); } - if (InsertBefore) + if (InsertBefore.isValid()) return new FCmpInst(InsertBefore, CmpInst::Predicate(predicate), S1, S2, Name); else @@ -4615,22 +3451,11 @@ CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, S1, S2, Name); } -CmpInst * -CmpInst::Create(OtherOps Op, Predicate predicate, Value *S1, Value *S2, - const Twine &Name, BasicBlock *InsertAtEnd) { - if (Op == Instruction::ICmp) { - return new ICmpInst(InsertAtEnd, CmpInst::Predicate(predicate), - S1, S2, Name); - } - return new FCmpInst(InsertAtEnd, CmpInst::Predicate(predicate), - S1, S2, Name); -} - CmpInst *CmpInst::CreateWithCopiedFlags(OtherOps Op, Predicate Pred, Value *S1, Value *S2, const Instruction *FlagsSource, const Twine &Name, - Instruction *InsertBefore) { + InsertPosition InsertBefore) { CmpInst *Inst = Create(Op, Pred, S1, S2, Name, InsertBefore); Inst->copyIRFlags(FlagsSource); return Inst; @@ -5086,34 +3911,12 @@ void SwitchInst::init(Value *Value, BasicBlock *Default, unsigned NumReserved) { /// 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 -/// constructor can also autoinsert before another instruction. -SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, - Instruction *InsertBefore) + InsertPosition 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 -/// constructor also autoinserts at the end of the specified BasicBlock. -SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch, - nullptr, 0, InsertAtEnd) { - init(Value, Default, 2+NumCases*2); -} - SwitchInst::SwitchInst(const SwitchInst &SI) : Instruction(SI.getType(), Instruction::Switch, nullptr, 0) { init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands()); @@ -5319,26 +4122,12 @@ void IndirectBrInst::growOperands() { } 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) + InsertPosition InsertBefore) : Instruction(Type::getVoidTy(Address->getContext()), Instruction::IndirectBr, nullptr, 0, InsertBefore) { init(Address, NumCases); } -IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases, - BasicBlock *InsertAtEnd) - : Instruction(Type::getVoidTy(Address->getContext()), - Instruction::IndirectBr, nullptr, 0, InsertAtEnd) { - init(Address, NumCases); -} - IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI) : Instruction(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr, nullptr, IBI.getNumOperands()) { @@ -5382,24 +4171,11 @@ 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) +FreezeInst::FreezeInst(Value *S, const Twine &Name, InsertPosition InsertBefore) : UnaryInstruction(S->getType(), Freeze, S, InsertBefore) { setName(Name); } -FreezeInst::FreezeInst(Value *S, - const Twine &Name, BasicBlock *InsertAtEnd) - : UnaryInstruction(S->getType(), Freeze, S, InsertAtEnd) { - setName(Name); -} - //===----------------------------------------------------------------------===// // cloneImpl() implementations //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp index 1c19a9eb8e1be..2adbdca4b5286 100644 --- a/llvm/lib/Transforms/Scalar/SROA.cpp +++ b/llvm/lib/Transforms/Scalar/SROA.cpp @@ -501,9 +501,9 @@ class IRBuilderPrefixedInserter final : public IRBuilderDefaultInserter { public: void SetNamePrefix(const Twine &P) { Prefix = P.str(); } - void InsertHelper(Instruction *I, const Twine &Name, BasicBlock *BB, + void InsertHelper(Instruction *I, const Twine &Name, BasicBlock::iterator InsertPt) const override { - IRBuilderDefaultInserter::InsertHelper(I, getNameWithPrefix(Name), BB, + IRBuilderDefaultInserter::InsertHelper(I, getNameWithPrefix(Name), InsertPt); } }; diff --git a/polly/include/polly/CodeGen/IRBuilder.h b/polly/include/polly/CodeGen/IRBuilder.h index 825bdd9b469c7..ffca887fbc09a 100644 --- a/polly/include/polly/CodeGen/IRBuilder.h +++ b/polly/include/polly/CodeGen/IRBuilder.h @@ -123,9 +123,8 @@ class IRInserter final : public llvm::IRBuilderDefaultInserter { IRInserter(ScopAnnotator &A) : Annotator(&A) {} void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, - llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const override { - llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt); + llvm::IRBuilderDefaultInserter::InsertHelper(I, Name, InsertPt); if (Annotator) Annotator->annotate(I); }