[llvm] e1434a8 - [SandboxIR] Switch more Instruction::create() functions to InsertPosition (#111075)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Oct 3 17:47:40 PDT 2024
Author: vporpo
Date: 2024-10-03T17:47:36-07:00
New Revision: e1434a8764207d6750c0d0569acb4feb94baf99c
URL: https://github.com/llvm/llvm-project/commit/e1434a8764207d6750c0d0569acb4feb94baf99c
DIFF: https://github.com/llvm/llvm-project/commit/e1434a8764207d6750c0d0569acb4feb94baf99c.diff
LOG: [SandboxIR] Switch more Instruction::create() functions to InsertPosition (#111075)
Added:
Modified:
llvm/include/llvm/SandboxIR/Instruction.h
llvm/lib/SandboxIR/Instruction.cpp
llvm/unittests/SandboxIR/SandboxIRTest.cpp
llvm/unittests/SandboxIR/TrackerTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/SandboxIR/Instruction.h b/llvm/include/llvm/SandboxIR/Instruction.h
index 796af29f7793ff..e4b1d7ee471578 100644
--- a/llvm/include/llvm/SandboxIR/Instruction.h
+++ b/llvm/include/llvm/SandboxIR/Instruction.h
@@ -502,10 +502,8 @@ class ExtractElementInst final
// create*()
public:
- static Value *create(Value *Vec, Value *Idx, Instruction *InsertBefore,
- Context &Ctx, const Twine &Name = "");
- static Value *create(Value *Vec, Value *Idx, BasicBlock *InsertAtEnd,
- Context &Ctx, const Twine &Name = "");
+ static Value *create(Value *Vec, Value *Idx, InsertPosition Pos, Context &Ctx,
+ const Twine &Name = "");
static bool classof(const Value *From) {
return From->getSubclassID() == ClassID::ExtractElement;
}
@@ -529,17 +527,10 @@ class ShuffleVectorInst final
friend class Context; // For accessing the constructor in create*()
public:
- static Value *create(Value *V1, Value *V2, Value *Mask,
- Instruction *InsertBefore, Context &Ctx,
- const Twine &Name = "");
- static Value *create(Value *V1, Value *V2, Value *Mask,
- BasicBlock *InsertAtEnd, Context &Ctx,
- const Twine &Name = "");
- static Value *create(Value *V1, Value *V2, ArrayRef<int> Mask,
- Instruction *InsertBefore, Context &Ctx,
- const Twine &Name = "");
+ static Value *create(Value *V1, Value *V2, Value *Mask, InsertPosition Pos,
+ Context &Ctx, const Twine &Name = "");
static Value *create(Value *V1, Value *V2, ArrayRef<int> Mask,
- BasicBlock *InsertAtEnd, Context &Ctx,
+ InsertPosition Pos, Context &Ctx,
const Twine &Name = "");
static bool classof(const Value *From) {
return From->getSubclassID() == ClassID::ShuffleVector;
@@ -974,7 +965,7 @@ class InsertValueInst
public:
static Value *create(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
- BBIterator WhereIt, BasicBlock *WhereBB, Context &Ctx,
+ InsertPosition Pos, Context &Ctx,
const Twine &Name = "");
static bool classof(const Value *From) {
@@ -1032,15 +1023,10 @@ class BranchInst : public SingleLLVMInstructionImpl<llvm::BranchInst> {
friend Context; // for BranchInst()
public:
- static BranchInst *create(BasicBlock *IfTrue, Instruction *InsertBefore,
- Context &Ctx);
- static BranchInst *create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd,
- Context &Ctx);
- static BranchInst *create(BasicBlock *IfTrue, BasicBlock *IfFalse,
- Value *Cond, Instruction *InsertBefore,
+ static BranchInst *create(BasicBlock *IfTrue, InsertPosition Pos,
Context &Ctx);
static BranchInst *create(BasicBlock *IfTrue, BasicBlock *IfFalse,
- Value *Cond, BasicBlock *InsertAtEnd, Context &Ctx);
+ Value *Cond, InsertPosition Pos, Context &Ctx);
/// For isa/dyn_cast.
static bool classof(const Value *From);
bool isUnconditional() const {
@@ -1122,9 +1108,8 @@ class ExtractValueInst : public UnaryInstruction {
friend Context; // for ExtractValueInst()
public:
- static Value *create(Value *Agg, ArrayRef<unsigned> Idxs, BBIterator WhereIt,
- BasicBlock *WhereBB, Context &Ctx,
- const Twine &Name = "");
+ static Value *create(Value *Agg, ArrayRef<unsigned> Idxs, InsertPosition Pos,
+ Context &Ctx, const Twine &Name = "");
static bool classof(const Value *From) {
return From->getSubclassID() == ClassID::ExtractValue;
@@ -1177,9 +1162,8 @@ class VAArgInst : public UnaryInstruction {
friend Context; // For constructor;
public:
- static VAArgInst *create(Value *List, Type *Ty, BBIterator WhereIt,
- BasicBlock *WhereBB, Context &Ctx,
- const Twine &Name = "");
+ static VAArgInst *create(Value *List, Type *Ty, InsertPosition Pos,
+ Context &Ctx, const Twine &Name = "");
Value *getPointerOperand();
const Value *getPointerOperand() const {
return const_cast<VAArgInst *>(this)->getPointerOperand();
@@ -1198,8 +1182,8 @@ class FreezeInst : public UnaryInstruction {
friend Context; // For constructor;
public:
- static FreezeInst *create(Value *V, BBIterator WhereIt, BasicBlock *WhereBB,
- Context &Ctx, const Twine &Name = "");
+ static FreezeInst *create(Value *V, InsertPosition Pos, Context &Ctx,
+ const Twine &Name = "");
static bool classof(const Value *From) {
return From->getSubclassID() == ClassID::Freeze;
}
@@ -1218,17 +1202,13 @@ class LoadInst final : public UnaryInstruction {
void setVolatile(bool V);
static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, Context &Ctx,
+ InsertPosition Pos, bool IsVolatile, Context &Ctx,
const Twine &Name = "");
static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, bool IsVolatile,
- Context &Ctx, const Twine &Name = "");
- static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, Context &Ctx,
- const Twine &Name = "");
- static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, bool IsVolatile,
- Context &Ctx, const Twine &Name = "");
+ InsertPosition Pos, Context &Ctx,
+ const Twine &Name = "") {
+ return create(Ty, Ptr, Align, Pos, /*IsVolatile=*/false, Ctx, Name);
+ }
/// For isa/dyn_cast.
static bool classof(const Value *From);
@@ -1251,15 +1231,12 @@ class StoreInst final : public SingleLLVMInstructionImpl<llvm::StoreInst> {
void setVolatile(bool V);
static StoreInst *create(Value *V, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, Context &Ctx);
- static StoreInst *create(Value *V, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, bool IsVolatile,
- Context &Ctx);
+ InsertPosition Pos, bool IsVolatile, Context &Ctx);
static StoreInst *create(Value *V, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, Context &Ctx);
- static StoreInst *create(Value *V, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, bool IsVolatile,
- Context &Ctx);
+ InsertPosition Pos, Context &Ctx) {
+ return create(V, Ptr, Align, Pos, /*IsVolatile=*/false, Ctx);
+ }
+
/// For isa/dyn_cast.
static bool classof(const Value *From);
Value *getValueOperand() const;
diff --git a/llvm/lib/SandboxIR/Instruction.cpp b/llvm/lib/SandboxIR/Instruction.cpp
index 0437ea3d6009f5..4208ff819fc415 100644
--- a/llvm/lib/SandboxIR/Instruction.cpp
+++ b/llvm/lib/SandboxIR/Instruction.cpp
@@ -286,14 +286,9 @@ void Instruction::dumpOS(raw_ostream &OS) const {
}
#endif // NDEBUG
-VAArgInst *VAArgInst::create(Value *List, Type *Ty, BBIterator WhereIt,
- BasicBlock *WhereBB, Context &Ctx,
- const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- if (WhereIt != WhereBB->end())
- Builder.SetInsertPoint((*WhereIt).getTopmostLLVMInstruction());
- else
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(WhereBB->Val));
+VAArgInst *VAArgInst::create(Value *List, Type *Ty, InsertPosition Pos,
+ Context &Ctx, const Twine &Name) {
+ auto &Builder = setInsertPos(Pos);
auto *LLVMI =
cast<llvm::VAArgInst>(Builder.CreateVAArg(List->Val, Ty->LLVMTy, Name));
return Ctx.createVAArgInst(LLVMI);
@@ -303,14 +298,9 @@ Value *VAArgInst::getPointerOperand() {
return Ctx.getValue(cast<llvm::VAArgInst>(Val)->getPointerOperand());
}
-FreezeInst *FreezeInst::create(Value *V, BBIterator WhereIt,
- BasicBlock *WhereBB, Context &Ctx,
+FreezeInst *FreezeInst::create(Value *V, InsertPosition Pos, Context &Ctx,
const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- if (WhereIt != WhereBB->end())
- Builder.SetInsertPoint((*WhereIt).getTopmostLLVMInstruction());
- else
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(WhereBB->Val));
+ auto &Builder = setInsertPos(Pos);
auto *LLVMI = cast<llvm::FreezeInst>(Builder.CreateFreeze(V->Val, Name));
return Ctx.createFreezeInst(LLVMI);
}
@@ -358,42 +348,17 @@ bool SelectInst::classof(const Value *From) {
return From->getSubclassID() == ClassID::Select;
}
-BranchInst *BranchInst::create(BasicBlock *IfTrue, Instruction *InsertBefore,
- Context &Ctx) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- llvm::Instruction *LLVMBefore = InsertBefore->getTopmostLLVMInstruction();
- Builder.SetInsertPoint(cast<llvm::Instruction>(LLVMBefore));
- llvm::BranchInst *NewBr =
- Builder.CreateBr(cast<llvm::BasicBlock>(IfTrue->Val));
- return Ctx.createBranchInst(NewBr);
-}
-
-BranchInst *BranchInst::create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd,
+BranchInst *BranchInst::create(BasicBlock *IfTrue, InsertPosition Pos,
Context &Ctx) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
+ auto &Builder = setInsertPos(Pos);
llvm::BranchInst *NewBr =
Builder.CreateBr(cast<llvm::BasicBlock>(IfTrue->Val));
return Ctx.createBranchInst(NewBr);
}
BranchInst *BranchInst::create(BasicBlock *IfTrue, BasicBlock *IfFalse,
- Value *Cond, Instruction *InsertBefore,
- Context &Ctx) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- llvm::Instruction *LLVMBefore = InsertBefore->getTopmostLLVMInstruction();
- Builder.SetInsertPoint(LLVMBefore);
- llvm::BranchInst *NewBr =
- Builder.CreateCondBr(Cond->Val, cast<llvm::BasicBlock>(IfTrue->Val),
- cast<llvm::BasicBlock>(IfFalse->Val));
- return Ctx.createBranchInst(NewBr);
-}
-
-BranchInst *BranchInst::create(BasicBlock *IfTrue, BasicBlock *IfFalse,
- Value *Cond, BasicBlock *InsertAtEnd,
- Context &Ctx) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
+ Value *Cond, InsertPosition Pos, Context &Ctx) {
+ auto &Builder = setInsertPos(Pos);
llvm::BranchInst *NewBr =
Builder.CreateCondBr(Cond->Val, cast<llvm::BasicBlock>(IfTrue->Val),
cast<llvm::BasicBlock>(IfFalse->Val));
@@ -437,34 +402,9 @@ void LoadInst::setVolatile(bool V) {
}
LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, Context &Ctx,
+ InsertPosition Pos, bool IsVolatile, Context &Ctx,
const Twine &Name) {
- return create(Ty, Ptr, Align, InsertBefore, /*IsVolatile=*/false, Ctx, Name);
-}
-
-LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, bool IsVolatile,
- Context &Ctx, const Twine &Name) {
- llvm::Instruction *BeforeIR = InsertBefore->getTopmostLLVMInstruction();
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(BeforeIR);
- auto *NewLI =
- Builder.CreateAlignedLoad(Ty->LLVMTy, Ptr->Val, Align, IsVolatile, Name);
- auto *NewSBI = Ctx.createLoadInst(NewLI);
- return NewSBI;
-}
-
-LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, Context &Ctx,
- const Twine &Name) {
- return create(Ty, Ptr, Align, InsertAtEnd, /*IsVolatile=*/false, Ctx, Name);
-}
-
-LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, bool IsVolatile,
- Context &Ctx, const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
+ auto &Builder = setInsertPos(Pos);
auto *NewLI =
Builder.CreateAlignedLoad(Ty->LLVMTy, Ptr->Val, Align, IsVolatile, Name);
auto *NewSBI = Ctx.createLoadInst(NewLI);
@@ -487,32 +427,9 @@ void StoreInst::setVolatile(bool V) {
}
StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, Context &Ctx) {
- return create(V, Ptr, Align, InsertBefore, /*IsVolatile=*/false, Ctx);
-}
-
-StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align,
- Instruction *InsertBefore, bool IsVolatile,
+ InsertPosition Pos, bool IsVolatile,
Context &Ctx) {
- llvm::Instruction *BeforeIR = InsertBefore->getTopmostLLVMInstruction();
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(BeforeIR);
- auto *NewSI = Builder.CreateAlignedStore(V->Val, Ptr->Val, Align, IsVolatile);
- auto *NewSBI = Ctx.createStoreInst(NewSI);
- return NewSBI;
-}
-
-StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, Context &Ctx) {
- return create(V, Ptr, Align, InsertAtEnd, /*IsVolatile=*/false, Ctx);
-}
-
-StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align,
- BasicBlock *InsertAtEnd, bool IsVolatile,
- Context &Ctx) {
- auto *InsertAtEndIR = cast<llvm::BasicBlock>(InsertAtEnd->Val);
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(InsertAtEndIR);
+ auto &Builder = setInsertPos(Pos);
auto *NewSI = Builder.CreateAlignedStore(V->Val, Ptr->Val, Align, IsVolatile);
auto *NewSBI = Ctx.createStoreInst(NewSI);
return NewSBI;
@@ -1779,11 +1696,9 @@ Value *InsertElementInst::create(Value *Vec, Value *NewElt, Value *Idx,
return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
}
-Value *ExtractElementInst::create(Value *Vec, Value *Idx,
- Instruction *InsertBefore, Context &Ctx,
- const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(InsertBefore->getTopmostLLVMInstruction());
+Value *ExtractElementInst::create(Value *Vec, Value *Idx, InsertPosition Pos,
+ Context &Ctx, const Twine &Name) {
+ auto &Builder = setInsertPos(Pos);
llvm::Value *NewV = Builder.CreateExtractElement(Vec->Val, Idx->Val, Name);
if (auto *NewExtract = dyn_cast<llvm::ExtractElementInst>(NewV))
return Ctx.createExtractElementInst(NewExtract);
@@ -1791,36 +1706,10 @@ Value *ExtractElementInst::create(Value *Vec, Value *Idx,
return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
}
-Value *ExtractElementInst::create(Value *Vec, Value *Idx,
- BasicBlock *InsertAtEnd, Context &Ctx,
- const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
- llvm::Value *NewV = Builder.CreateExtractElement(Vec->Val, Idx->Val, Name);
- if (auto *NewExtract = dyn_cast<llvm::ExtractElementInst>(NewV))
- return Ctx.createExtractElementInst(NewExtract);
- assert(isa<llvm::Constant>(NewV) && "Expected constant");
- return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
-}
-
-Value *ShuffleVectorInst::create(Value *V1, Value *V2, Value *Mask,
- Instruction *InsertBefore, Context &Ctx,
- const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(InsertBefore->getTopmostLLVMInstruction());
- llvm::Value *NewV =
- Builder.CreateShuffleVector(V1->Val, V2->Val, Mask->Val, Name);
- if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
- return Ctx.createShuffleVectorInst(NewShuffle);
- assert(isa<llvm::Constant>(NewV) && "Expected constant");
- return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
-}
-
Value *ShuffleVectorInst::create(Value *V1, Value *V2, Value *Mask,
- BasicBlock *InsertAtEnd, Context &Ctx,
+ InsertPosition Pos, Context &Ctx,
const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
+ auto &Builder = setInsertPos(Pos);
llvm::Value *NewV =
Builder.CreateShuffleVector(V1->Val, V2->Val, Mask->Val, Name);
if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
@@ -1830,22 +1719,9 @@ Value *ShuffleVectorInst::create(Value *V1, Value *V2, Value *Mask,
}
Value *ShuffleVectorInst::create(Value *V1, Value *V2, ArrayRef<int> Mask,
- Instruction *InsertBefore, Context &Ctx,
- const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(InsertBefore->getTopmostLLVMInstruction());
- llvm::Value *NewV = Builder.CreateShuffleVector(V1->Val, V2->Val, Mask, Name);
- if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
- return Ctx.createShuffleVectorInst(NewShuffle);
- assert(isa<llvm::Constant>(NewV) && "Expected constant");
- return Ctx.getOrCreateConstant(cast<llvm::Constant>(NewV));
-}
-
-Value *ShuffleVectorInst::create(Value *V1, Value *V2, ArrayRef<int> Mask,
- BasicBlock *InsertAtEnd, Context &Ctx,
+ InsertPosition Pos, Context &Ctx,
const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(InsertAtEnd->Val));
+ auto &Builder = setInsertPos(Pos);
llvm::Value *NewV = Builder.CreateShuffleVector(V1->Val, V2->Val, Mask, Name);
if (auto *NewShuffle = dyn_cast<llvm::ShuffleVectorInst>(NewV))
return Ctx.createShuffleVectorInst(NewShuffle);
@@ -1887,13 +1763,9 @@ VectorType *ExtractElementInst::getVectorOperandType() const {
}
Value *ExtractValueInst::create(Value *Agg, ArrayRef<unsigned> Idxs,
- BBIterator WhereIt, BasicBlock *WhereBB,
- Context &Ctx, const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- if (WhereIt != WhereBB->end())
- Builder.SetInsertPoint((*WhereIt).getTopmostLLVMInstruction());
- else
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(WhereBB->Val));
+ InsertPosition Pos, Context &Ctx,
+ const Twine &Name) {
+ auto &Builder = setInsertPos(Pos);
llvm::Value *NewV = Builder.CreateExtractValue(Agg->Val, Idxs, Name);
if (auto *NewExtractValueInst = dyn_cast<llvm::ExtractValueInst>(NewV))
return Ctx.createExtractValueInst(NewExtractValueInst);
@@ -1907,13 +1779,9 @@ Type *ExtractValueInst::getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs) {
}
Value *InsertValueInst::create(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
- BBIterator WhereIt, BasicBlock *WhereBB,
- Context &Ctx, const Twine &Name) {
- auto &Builder = Ctx.getLLVMIRBuilder();
- if (WhereIt != WhereBB->end())
- Builder.SetInsertPoint((*WhereIt).getTopmostLLVMInstruction());
- else
- Builder.SetInsertPoint(cast<llvm::BasicBlock>(WhereBB->Val));
+ InsertPosition Pos, Context &Ctx,
+ const Twine &Name) {
+ auto &Builder = setInsertPos(Pos);
llvm::Value *NewV = Builder.CreateInsertValue(Agg->Val, Val->Val, Idxs, Name);
if (auto *NewInsertValueInst = dyn_cast<llvm::InsertValueInst>(NewV))
return Ctx.createInsertValueInst(NewInsertValueInst);
diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
index 93ea33feee6e3e..ff127d8ccff8f8 100644
--- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp
+++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
@@ -1960,7 +1960,7 @@ define void @foo(ptr %va) {
// Check create().
auto *NewVATy = sandboxir::Type::getInt8Ty(Ctx);
auto *NewVA = sandboxir::VAArgInst::create(Arg, NewVATy, Ret->getIterator(),
- Ret->getParent(), Ctx, "NewVA");
+ Ctx, "NewVA");
EXPECT_EQ(NewVA->getNextNode(), Ret);
EXPECT_EQ(NewVA->getType(), NewVATy);
#ifndef NDEBUG
@@ -1989,8 +1989,8 @@ define void @foo(i8 %arg) {
EXPECT_EQ(Freeze->getOperand(0), Arg);
// Check create().
- auto *NewFreeze = sandboxir::FreezeInst::create(
- Arg, Ret->getIterator(), Ret->getParent(), Ctx, "NewFreeze");
+ auto *NewFreeze =
+ sandboxir::FreezeInst::create(Arg, Ret->getIterator(), Ctx, "NewFreeze");
EXPECT_EQ(NewFreeze->getNextNode(), Ret);
#ifndef NDEBUG
EXPECT_EQ(NewFreeze->getName(), "NewFreeze");
@@ -2147,7 +2147,7 @@ define void @foo(<2 x i8> %vec, i32 %idx) {
auto *NewI1 =
cast<sandboxir::ExtractElementInst>(sandboxir::ExtractElementInst::create(
- ArgVec, ArgIdx, Ret, Ctx, "NewExtrBeforeRet"));
+ ArgVec, ArgIdx, Ret->getIterator(), Ctx, "NewExtrBeforeRet"));
EXPECT_EQ(NewI1->getOperand(0), ArgVec);
EXPECT_EQ(NewI1->getOperand(1), ArgIdx);
EXPECT_EQ(NewI1->getNextNode(), Ret);
@@ -2243,13 +2243,14 @@ define void @foo(<2 x i8> %v1, <2 x i8> %v2) {
auto CreateShuffleWithMask = [&](auto &&...Indices) {
SmallVector<int, 4> Mask = {Indices...};
return cast<sandboxir::ShuffleVectorInst>(
- sandboxir::ShuffleVectorInst::create(ArgV1, ArgV2, Mask, Ret, Ctx));
+ sandboxir::ShuffleVectorInst::create(ArgV1, ArgV2, Mask,
+ Ret->getIterator(), Ctx));
};
// create (InsertBefore)
auto *NewI1 =
cast<sandboxir::ShuffleVectorInst>(sandboxir::ShuffleVectorInst::create(
- ArgV1, ArgV2, ArrayRef<int>({0, 2, 1, 3}), Ret, Ctx,
+ ArgV1, ArgV2, ArrayRef<int>({0, 2, 1, 3}), Ret->getIterator(), Ctx,
"NewShuffleBeforeRet"));
EXPECT_EQ(NewI1->getOperand(0), ArgV1);
EXPECT_EQ(NewI1->getOperand(1), ArgV2);
@@ -2658,8 +2659,8 @@ define void @foo({i32, float} %agg) {
// create before instruction
auto *NewExtBeforeRet =
cast<sandboxir::ExtractValueInst>(sandboxir::ExtractValueInst::create(
- ArgAgg, ArrayRef<unsigned>({0}), Ret->getIterator(), Ret->getParent(),
- Ctx, "NewExtBeforeRet"));
+ ArgAgg, ArrayRef<unsigned>({0}), Ret->getIterator(), Ctx,
+ "NewExtBeforeRet"));
EXPECT_EQ(NewExtBeforeRet->getNextNode(), Ret);
#ifndef NDEBUG
EXPECT_EQ(NewExtBeforeRet->getName(), "NewExtBeforeRet");
@@ -2668,7 +2669,7 @@ define void @foo({i32, float} %agg) {
// create at end of BB
auto *NewExtAtEnd =
cast<sandboxir::ExtractValueInst>(sandboxir::ExtractValueInst::create(
- ArgAgg, ArrayRef<unsigned>({0}), BB->end(), BB, Ctx, "NewExtAtEnd"));
+ ArgAgg, ArrayRef<unsigned>({0}), BB->end(), Ctx, "NewExtAtEnd"));
EXPECT_EQ(NewExtAtEnd->getPrevNode(), Ret);
#ifndef NDEBUG
EXPECT_EQ(NewExtAtEnd->getName(), "NewExtAtEnd");
@@ -2676,7 +2677,7 @@ define void @foo({i32, float} %agg) {
// Test the path that creates a folded constant.
auto *ShouldBeConstant = sandboxir::ExtractValueInst::create(
- Const1->getOperand(0), ArrayRef<unsigned>({0}), BB->end(), BB, Ctx);
+ Const1->getOperand(0), ArrayRef<unsigned>({0}), BB->end(), Ctx);
EXPECT_TRUE(isa<sandboxir::Constant>(ShouldBeConstant));
auto *Zero = sandboxir::ConstantInt::get(sandboxir::Type::getInt32Ty(Ctx), 0);
@@ -2765,8 +2766,8 @@ define void @foo({i32, float} %agg, i32 %i) {
// create before instruction
auto *NewInsBeforeRet =
cast<sandboxir::InsertValueInst>(sandboxir::InsertValueInst::create(
- ArgAgg, ArgInt, ArrayRef<unsigned>({0}), Ret->getIterator(),
- Ret->getParent(), Ctx, "NewInsBeforeRet"));
+ ArgAgg, ArgInt, ArrayRef<unsigned>({0}), Ret->getIterator(), Ctx,
+ "NewInsBeforeRet"));
EXPECT_EQ(NewInsBeforeRet->getNextNode(), Ret);
#ifndef NDEBUG
EXPECT_EQ(NewInsBeforeRet->getName(), "NewInsBeforeRet");
@@ -2775,8 +2776,7 @@ define void @foo({i32, float} %agg, i32 %i) {
// create at end of BB
auto *NewInsAtEnd =
cast<sandboxir::InsertValueInst>(sandboxir::InsertValueInst::create(
- ArgAgg, ArgInt, ArrayRef<unsigned>({0}), BB->end(), BB, Ctx,
- "NewInsAtEnd"));
+ ArgAgg, ArgInt, ArrayRef<unsigned>({0}), BB, Ctx, "NewInsAtEnd"));
EXPECT_EQ(NewInsAtEnd->getPrevNode(), Ret);
#ifndef NDEBUG
EXPECT_EQ(NewInsAtEnd->getName(), "NewInsAtEnd");
@@ -2785,7 +2785,7 @@ define void @foo({i32, float} %agg, i32 %i) {
// Test the path that creates a folded constant.
auto *Zero = sandboxir::ConstantInt::get(sandboxir::Type::getInt32Ty(Ctx), 0);
auto *ShouldBeConstant = sandboxir::InsertValueInst::create(
- Const1->getOperand(0), Zero, ArrayRef<unsigned>({0}), BB->end(), BB, Ctx);
+ Const1->getOperand(0), Zero, ArrayRef<unsigned>({0}), BB, Ctx);
auto *ExpectedConstant = Const2->getOperand(0);
EXPECT_TRUE(isa<sandboxir::Constant>(ShouldBeConstant));
EXPECT_EQ(ShouldBeConstant, ExpectedConstant);
@@ -2891,7 +2891,7 @@ define void @foo(i1 %cond0, i1 %cond2) {
{
// Check unconditional BranchInst::create() InsertBefore.
- auto *Br = sandboxir::BranchInst::create(BB1, /*InsertBefore=*/Ret1, Ctx);
+ auto *Br = sandboxir::BranchInst::create(BB1, Ret1->getIterator(), Ctx);
EXPECT_FALSE(Br->isConditional());
EXPECT_TRUE(Br->isUnconditional());
#ifndef NDEBUG
@@ -2920,7 +2920,7 @@ define void @foo(i1 %cond0, i1 %cond2) {
{
// Check conditional BranchInst::create() InsertBefore.
auto *Br = sandboxir::BranchInst::create(BB1, BB2, Cond0,
- /*InsertBefore=*/Ret1, Ctx);
+ Ret1->getIterator(), Ctx);
EXPECT_TRUE(Br->isConditional());
EXPECT_EQ(Br->getCondition(), Cond0);
unsigned SuccIdx = 0;
@@ -2973,9 +2973,8 @@ define void @foo(ptr %arg0, ptr %arg1) {
// Check getAlign()
EXPECT_EQ(Ld->getAlign(), 64);
// Check create(InsertBefore)
- sandboxir::LoadInst *NewLd =
- sandboxir::LoadInst::create(Ld->getType(), Arg1, Align(8),
- /*InsertBefore=*/Ret, Ctx, "NewLd");
+ sandboxir::LoadInst *NewLd = sandboxir::LoadInst::create(
+ Ld->getType(), Arg1, Align(8), Ret->getIterator(), Ctx, "NewLd");
EXPECT_FALSE(NewLd->isVolatile());
OrigVolatileValue = NewLd->isVolatile();
NewLd->setVolatile(true);
@@ -2987,10 +2986,9 @@ define void @foo(ptr %arg0, ptr %arg1) {
EXPECT_EQ(NewLd->getAlign(), 8);
EXPECT_EQ(NewLd->getName(), "NewLd");
// Check create(InsertBefore, IsVolatile=true)
- sandboxir::LoadInst *NewVLd =
- sandboxir::LoadInst::create(VLd->getType(), Arg1, Align(8),
- /*InsertBefore=*/Ret,
- /*IsVolatile=*/true, Ctx, "NewVLd");
+ sandboxir::LoadInst *NewVLd = sandboxir::LoadInst::create(
+ VLd->getType(), Arg1, Align(8), Ret->getIterator(),
+ /*IsVolatile=*/true, Ctx, "NewVLd");
EXPECT_TRUE(NewVLd->isVolatile());
OrigVolatileValue = NewVLd->isVolatile();
@@ -3054,8 +3052,7 @@ define void @foo(i8 %val, ptr %ptr) {
EXPECT_EQ(St->getAlign(), 64);
// Check create(InsertBefore)
sandboxir::StoreInst *NewSt =
- sandboxir::StoreInst::create(Val, Ptr, Align(8),
- /*InsertBefore=*/Ret, Ctx);
+ sandboxir::StoreInst::create(Val, Ptr, Align(8), Ret->getIterator(), Ctx);
EXPECT_FALSE(NewSt->isVolatile());
OrigVolatileValue = NewSt->isVolatile();
NewSt->setVolatile(true);
@@ -3069,8 +3066,7 @@ define void @foo(i8 %val, ptr %ptr) {
EXPECT_EQ(NewSt->getNextNode(), Ret);
// Check create(InsertBefore, IsVolatile=true)
sandboxir::StoreInst *NewVSt =
- sandboxir::StoreInst::create(Val, Ptr, Align(8),
- /*InsertBefore=*/Ret,
+ sandboxir::StoreInst::create(Val, Ptr, Align(8), Ret->getIterator(),
/*IsVolatile=*/true, Ctx);
EXPECT_TRUE(NewVSt->isVolatile());
OrigVolatileValue = NewVSt->isVolatile();
diff --git a/llvm/unittests/SandboxIR/TrackerTest.cpp b/llvm/unittests/SandboxIR/TrackerTest.cpp
index 9c7710a6a92976..6d060854949e1f 100644
--- a/llvm/unittests/SandboxIR/TrackerTest.cpp
+++ b/llvm/unittests/SandboxIR/TrackerTest.cpp
@@ -527,9 +527,9 @@ define void @foo(ptr %ptr) {
Ctx.save();
// Check create(InsertBefore) with tracking enabled.
- sandboxir::LoadInst *NewLd =
- sandboxir::LoadInst::create(Ld->getType(), Ptr, Align(8),
- /*InsertBefore=*/Ld, Ctx, "NewLd");
+ sandboxir::LoadInst *NewLd = sandboxir::LoadInst::create(
+ Ld->getType(), Ptr, Align(8),
+ /*InsertBefore=*/Ld->getIterator(), Ctx, "NewLd");
It = BB->begin();
EXPECT_EQ(&*It++, NewLd);
EXPECT_EQ(&*It++, Ld);
More information about the llvm-commits
mailing list