From 7d3a9347530ea506cc9638536212ffdb4dd01e95 Mon Sep 17 00:00:00 2001 From: medievalghoul <61852278+medievalghoul@users.noreply.github.com> Date: Sun, 28 Jul 2024 20:42:04 -0400 Subject: [PATCH 1/2] [SandboxIR][NFC] Fixes for functions --- llvm/include/llvm/SandboxIR/SandboxIR.h | 11 +++++++-- llvm/lib/SandboxIR/SandboxIR.cpp | 27 ++++++++++++++++++++-- llvm/unittests/SandboxIR/SandboxIRTest.cpp | 13 +++++------ 3 files changed, 40 insertions(+), 11 deletions(-) diff --git a/llvm/include/llvm/SandboxIR/SandboxIR.h b/llvm/include/llvm/SandboxIR/SandboxIR.h index 667aeba1bda1f..3b5a17ccc9522 100644 --- a/llvm/include/llvm/SandboxIR/SandboxIR.h +++ b/llvm/include/llvm/SandboxIR/SandboxIR.h @@ -772,10 +772,17 @@ class LoadInst final : public Instruction { unsigned getNumOfIRInstrs() const final { return 1u; } static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align, Instruction *InsertBefore, Context &Ctx, - bool IsVolatile = false, const Twine &Name = ""); + 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, - bool IsVolatile = false, const Twine &Name = ""); + const Twine &Name = ""); + static LoadInst *create(Type *Ty, Value *Ptr, MaybeAlign Align, + BasicBlock *InsertAtEnd, bool IsVolatile, + Context &Ctx, const Twine &Name = ""); + /// For isa/dyn_cast. static bool classof(const Value *From); Value *getPointerOperand() const; diff --git a/llvm/lib/SandboxIR/SandboxIR.cpp b/llvm/lib/SandboxIR/SandboxIR.cpp index d2b4fb207ba3a..cf926de8a75bd 100644 --- a/llvm/lib/SandboxIR/SandboxIR.cpp +++ b/llvm/lib/SandboxIR/SandboxIR.cpp @@ -612,7 +612,19 @@ void BranchInst::dump() const { LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align, Instruction *InsertBefore, Context &Ctx, - bool IsVolatile, const Twine &Name) { + const Twine &Name) { + llvm::Instruction *BeforeIR = InsertBefore->getTopmostLLVMInstruction(); + auto &Builder = Ctx.getLLVMIRBuilder(); + Builder.SetInsertPoint(BeforeIR); + auto *NewLI = Builder.CreateAlignedLoad(Ty, Ptr->Val, Align, + /*IsVolatile=*/false, Name); + auto *NewSBI = Ctx.createLoadInst(NewLI); + return NewSBI; +} + +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); @@ -624,7 +636,18 @@ LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align, LoadInst *LoadInst::create(Type *Ty, Value *Ptr, MaybeAlign Align, BasicBlock *InsertAtEnd, Context &Ctx, - bool IsVolatile, const Twine &Name) { + const Twine &Name) { + auto &Builder = Ctx.getLLVMIRBuilder(); + Builder.SetInsertPoint(cast(InsertAtEnd->Val)); + auto *NewLI = Builder.CreateAlignedLoad(Ty, Ptr->Val, Align, + /*IsVolatile=*/false, Name); + auto *NewSBI = Ctx.createLoadInst(NewLI); + return NewSBI; +} + +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(InsertAtEnd->Val)); auto *NewLI = diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp index 122508d15194f..4ef867c2af418 100644 --- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp +++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp @@ -750,13 +750,13 @@ define void @foo(ptr %arg0, ptr %arg1) { auto *BB = &*F->begin(); auto It = BB->begin(); auto *Ld = cast(&*It++); - auto *Vld = cast(&*It++); + auto *VLd = cast(&*It++); auto *Ret = cast(&*It++); // Check isVolatile() EXPECT_FALSE(Ld->isVolatile()); // Check isVolatile() - EXPECT_TRUE(Vld->isVolatile()); + EXPECT_TRUE(VLd->isVolatile()); // Check getPointerOperand() EXPECT_EQ(Ld->getPointerOperand(), Arg0); // Check getAlign() @@ -764,8 +764,7 @@ define void @foo(ptr %arg0, ptr %arg1) { // Check create(InsertBefore) sandboxir::LoadInst *NewLd = sandboxir::LoadInst::create(Ld->getType(), Arg1, Align(8), - /*InsertBefore=*/Ret, Ctx, - /*IsVolatile=*/false, "NewLd"); + /*InsertBefore=*/Ret, Ctx, "NewLd"); // Checking if create() was volatile EXPECT_FALSE(NewLd->isVolatile()); EXPECT_EQ(NewLd->getType(), Ld->getType()); @@ -774,9 +773,9 @@ define void @foo(ptr %arg0, ptr %arg1) { EXPECT_EQ(NewLd->getName(), "NewLd"); sandboxir::LoadInst *NewVLd = - sandboxir::LoadInst::create(Vld->getType(), Arg1, Align(8), - /*InsertBefore=*/Ret, Ctx, - /*IsVolatile=*/true, "NewVLd"); + sandboxir::LoadInst::create(VLd->getType(), Arg1, Align(8), + /*InsertBefore=*/Ret, + /*IsVolatile=*/true, Ctx, "NewVLd"); // Checking if create() was volatile EXPECT_TRUE(NewVLd->isVolatile()); From 334e8867382f319661426f4f0360f657859fda6c Mon Sep 17 00:00:00 2001 From: medievalghoul <61852278+medievalghoul@users.noreply.github.com> Date: Sun, 28 Jul 2024 21:49:39 -0400 Subject: [PATCH 2/2] [SandboxIR] Added new StoreInst::create() functions with isVolatile arg --- llvm/include/llvm/SandboxIR/SandboxIR.h | 10 ++++++++++ llvm/lib/SandboxIR/SandboxIR.cpp | 23 ++++++++++++++++++++++ llvm/unittests/SandboxIR/SandboxIRTest.cpp | 17 +++++++++++++++- 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/llvm/include/llvm/SandboxIR/SandboxIR.h b/llvm/include/llvm/SandboxIR/SandboxIR.h index 3b5a17ccc9522..c2caedea7e72c 100644 --- a/llvm/include/llvm/SandboxIR/SandboxIR.h +++ b/llvm/include/llvm/SandboxIR/SandboxIR.h @@ -811,14 +811,24 @@ class StoreInst final : public Instruction { } public: + /// Return true if this is a load from a volatile memory location. + bool isVolatile() const { return cast(Val)->isVolatile(); } + unsigned getUseOperandNo(const Use &Use) const final { return getUseOperandNoDefault(Use); } unsigned getNumOfIRInstrs() const final { return 1u; } 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); 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); + /// For isa/dyn_cast. static bool classof(const Value *From); Value *getValueOperand() const; diff --git a/llvm/lib/SandboxIR/SandboxIR.cpp b/llvm/lib/SandboxIR/SandboxIR.cpp index cf926de8a75bd..9f0bcc501ab92 100644 --- a/llvm/lib/SandboxIR/SandboxIR.cpp +++ b/llvm/lib/SandboxIR/SandboxIR.cpp @@ -685,6 +685,18 @@ StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align, auto *NewSBI = Ctx.createStoreInst(NewSI); return NewSBI; } + +StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align, + Instruction *InsertBefore, 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) { auto *InsertAtEndIR = cast(InsertAtEnd->Val); @@ -696,6 +708,17 @@ StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align, return NewSBI; } +StoreInst *StoreInst::create(Value *V, Value *Ptr, MaybeAlign Align, + BasicBlock *InsertAtEnd, bool IsVolatile, + Context &Ctx) { + auto *InsertAtEndIR = cast(InsertAtEnd->Val); + auto &Builder = Ctx.getLLVMIRBuilder(); + Builder.SetInsertPoint(InsertAtEndIR); + auto *NewSI = Builder.CreateAlignedStore(V->Val, Ptr->Val, Align, IsVolatile); + auto *NewSBI = Ctx.createStoreInst(NewSI); + return NewSBI; +} + bool StoreInst::classof(const Value *From) { return From->getSubclassID() == ClassID::Store; } diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp index 4ef867c2af418..347e1daa17b40 100644 --- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp +++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp @@ -784,8 +784,9 @@ define void @foo(ptr %arg0, ptr %arg1) { TEST_F(SandboxIRTest, StoreInst) { parseIR(C, R"IR( -define void @foo(i8 %val, ptr %ptr) { +define void @foo(i8 %val, ptr %ptr, ptr %vptr) { store i8 %val, ptr %ptr, align 64 + store volatile i8 %val, ptr %vptr, align 64 ret void } )IR"); @@ -797,9 +798,13 @@ define void @foo(i8 %val, ptr %ptr) { auto *BB = &*F->begin(); auto It = BB->begin(); auto *St = cast(&*It++); + auto *VSt = cast(&*It++); auto *Ret = cast(&*It++); // Check that the StoreInst has been created correctly. + // Check isVolatile() + EXPECT_TRUE(VSt->isVolatile()); + EXPECT_FALSE(St->isVolatile()); // Check getPointerOperand() EXPECT_EQ(St->getValueOperand(), Val); EXPECT_EQ(St->getPointerOperand(), Ptr); @@ -809,10 +814,20 @@ define void @foo(i8 %val, ptr %ptr) { sandboxir::StoreInst *NewSt = sandboxir::StoreInst::create(Val, Ptr, Align(8), /*InsertBefore=*/Ret, Ctx); + // Checking if create() was volatile + EXPECT_FALSE(NewSt->isVolatile()); EXPECT_EQ(NewSt->getType(), St->getType()); EXPECT_EQ(NewSt->getValueOperand(), Val); EXPECT_EQ(NewSt->getPointerOperand(), Ptr); EXPECT_EQ(NewSt->getAlign(), 8); + + // Check create(InsertBefore) + sandboxir::StoreInst *NewVSt = + sandboxir::StoreInst::create(Val, Ptr, Align(8), + /*InsertBefore=*/Ret, + /*IsVolatile=*/true, Ctx); + // Checking if create() was volatile + EXPECT_TRUE(NewVSt->isVolatile()); } TEST_F(SandboxIRTest, ReturnInst) {