[llvm] 9a312d4 - [SandboxIR] Implement GlobalAlias (#109019)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Sep 17 13:45:41 PDT 2024
Author: vporpo
Date: 2024-09-17T13:45:36-07:00
New Revision: 9a312d47f39bcfcadc16021f1db88b04997dbdc6
URL: https://github.com/llvm/llvm-project/commit/9a312d47f39bcfcadc16021f1db88b04997dbdc6
DIFF: https://github.com/llvm/llvm-project/commit/9a312d47f39bcfcadc16021f1db88b04997dbdc6.diff
LOG: [SandboxIR] Implement GlobalAlias (#109019)
This patch implements sandboxir::GlobalAlias, mirroring
llvm::GlobalAlias.
Added:
Modified:
llvm/include/llvm/SandboxIR/SandboxIR.h
llvm/lib/SandboxIR/SandboxIR.cpp
llvm/unittests/SandboxIR/SandboxIRTest.cpp
llvm/unittests/SandboxIR/TrackerTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/SandboxIR/SandboxIR.h b/llvm/include/llvm/SandboxIR/SandboxIR.h
index 22b46bd8d7da14..b276c06033596d 100644
--- a/llvm/include/llvm/SandboxIR/SandboxIR.h
+++ b/llvm/include/llvm/SandboxIR/SandboxIR.h
@@ -130,6 +130,7 @@ class GlobalValue;
class GlobalObject;
class GlobalIFunc;
class GlobalVariable;
+class GlobalAlias;
class Context;
class Function;
class Instruction;
@@ -336,6 +337,7 @@ class Value {
friend class GlobalObject; // For `Val`.
friend class GlobalIFunc; // For `Val`.
friend class GlobalVariable; // For `Val`.
+ friend class GlobalAlias; // For `Val`.
/// All values point to the context.
Context &Ctx;
@@ -1528,6 +1530,38 @@ class GlobalVariable final
#endif
};
+class GlobalAlias final
+ : public GlobalWithNodeAPI<GlobalAlias, llvm::GlobalAlias, GlobalValue,
+ llvm::GlobalValue> {
+ GlobalAlias(llvm::GlobalAlias *C, Context &Ctx)
+ : GlobalWithNodeAPI(ClassID::GlobalAlias, C, Ctx) {}
+ friend class Context; // For constructor.
+
+public:
+ /// For isa/dyn_cast.
+ static bool classof(const sandboxir::Value *From) {
+ return From->getSubclassID() == ClassID::GlobalAlias;
+ }
+
+ // TODO: Missing create() due to unimplemented sandboxir::Module.
+
+ // TODO: Missing copyAttributresFrom().
+ // TODO: Missing removeFromParent(), eraseFromParent().
+
+ void setAliasee(Constant *Aliasee);
+ Constant *getAliasee() const;
+
+ const GlobalObject *getAliaseeObject() const;
+ GlobalObject *getAliaseeObject() {
+ return const_cast<GlobalObject *>(
+ static_cast<const GlobalAlias *>(this)->getAliaseeObject());
+ }
+
+ static bool isValidLinkage(LinkageTypes L) {
+ return llvm::GlobalAlias::isValidLinkage(L);
+ }
+};
+
class BlockAddress final : public Constant {
BlockAddress(llvm::BlockAddress *C, Context &Ctx)
: Constant(ClassID::BlockAddress, C, Ctx) {}
diff --git a/llvm/lib/SandboxIR/SandboxIR.cpp b/llvm/lib/SandboxIR/SandboxIR.cpp
index c26ba1983db91e..d047a53b4752ee 100644
--- a/llvm/lib/SandboxIR/SandboxIR.cpp
+++ b/llvm/lib/SandboxIR/SandboxIR.cpp
@@ -2534,6 +2534,8 @@ template class GlobalWithNodeAPI<Function, llvm::Function, GlobalObject,
llvm::GlobalObject>;
template class GlobalWithNodeAPI<GlobalVariable, llvm::GlobalVariable,
GlobalObject, llvm::GlobalObject>;
+template class GlobalWithNodeAPI<GlobalAlias, llvm::GlobalAlias, GlobalValue,
+ llvm::GlobalValue>;
} // namespace llvm::sandboxir
void GlobalIFunc::setResolver(Constant *Resolver) {
@@ -2587,6 +2589,24 @@ void GlobalVariable::setExternallyInitialized(bool V) {
cast<llvm::GlobalVariable>(Val)->setExternallyInitialized(V);
}
+void GlobalAlias::setAliasee(Constant *Aliasee) {
+ Ctx.getTracker()
+ .emplaceIfTracking<
+ GenericSetter<&GlobalAlias::getAliasee, &GlobalAlias::setAliasee>>(
+ this);
+ cast<llvm::GlobalAlias>(Val)->setAliasee(cast<llvm::Constant>(Aliasee->Val));
+}
+
+Constant *GlobalAlias::getAliasee() const {
+ return cast<Constant>(
+ Ctx.getOrCreateConstant(cast<llvm::GlobalAlias>(Val)->getAliasee()));
+}
+
+const GlobalObject *GlobalAlias::getAliaseeObject() const {
+ return cast<GlobalObject>(Ctx.getOrCreateConstant(
+ cast<llvm::GlobalAlias>(Val)->getAliaseeObject()));
+}
+
void GlobalValue::setUnnamedAddr(UnnamedAddr V) {
Ctx.getTracker()
.emplaceIfTracking<GenericSetter<&GlobalValue::getUnnamedAddr,
@@ -2803,6 +2823,10 @@ Value *Context::getOrCreateValueInternal(llvm::Value *LLVMV, llvm::User *U) {
It->second = std::unique_ptr<GlobalVariable>(
new GlobalVariable(cast<llvm::GlobalVariable>(C), *this));
break;
+ case llvm::Value::GlobalAliasVal:
+ It->second = std::unique_ptr<GlobalAlias>(
+ new GlobalAlias(cast<llvm::GlobalAlias>(C), *this));
+ break;
default:
It->second = std::unique_ptr<Constant>(new Constant(C, *this));
break;
diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
index 5ded063ef6f735..b998091f6d7a97 100644
--- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp
+++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
@@ -1051,6 +1051,72 @@ define void @foo() {
EXPECT_EQ(GV0->getCodeModel(), LLVMGV0->getCodeModel());
}
+TEST_F(SandboxIRTest, GlobalAlias) {
+ parseIR(C, R"IR(
+ at alias0 = dso_local alias void(), ptr @foo
+ at alias1 = dso_local alias void(), ptr @foo
+declare void @bar();
+define void @foo() {
+ call void @alias0()
+ call void @alias1()
+ call void @bar()
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ auto *LLVMBB = &*LLVMF.begin();
+ auto LLVMIt = LLVMBB->begin();
+ auto *LLVMCall0 = cast<llvm::CallInst>(&*LLVMIt++);
+ auto *LLVMAlias0 = cast<llvm::GlobalAlias>(LLVMCall0->getCalledOperand());
+ sandboxir::Context Ctx(C);
+
+ auto &F = *Ctx.createFunction(&LLVMF);
+ auto *BB = &*F.begin();
+ auto It = BB->begin();
+ auto *Call0 = cast<sandboxir::CallInst>(&*It++);
+ auto *Call1 = cast<sandboxir::CallInst>(&*It++);
+ auto *CallBar = cast<sandboxir::CallInst>(&*It++);
+ auto *CalleeBar = cast<sandboxir::Constant>(CallBar->getCalledOperand());
+ // Check classof(), creation.
+ auto *Alias0 = cast<sandboxir::GlobalAlias>(Call0->getCalledOperand());
+ auto *Alias1 = cast<sandboxir::GlobalAlias>(Call1->getCalledOperand());
+ // Check getIterator().
+ {
+ auto It0 = Alias0->getIterator();
+ auto It1 = Alias1->getIterator();
+ EXPECT_EQ(&*It0, Alias0);
+ EXPECT_EQ(&*It1, Alias1);
+ EXPECT_EQ(std::next(It0), It1);
+ EXPECT_EQ(std::prev(It1), It0);
+ EXPECT_EQ(&*std::next(It0), Alias1);
+ EXPECT_EQ(&*std::prev(It1), Alias0);
+ }
+ // Check getReverseIterator().
+ {
+ auto RevIt0 = Alias0->getReverseIterator();
+ auto RevIt1 = Alias1->getReverseIterator();
+ EXPECT_EQ(&*RevIt0, Alias0);
+ EXPECT_EQ(&*RevIt1, Alias1);
+ EXPECT_EQ(std::prev(RevIt0), RevIt1);
+ EXPECT_EQ(std::next(RevIt1), RevIt0);
+ EXPECT_EQ(&*std::prev(RevIt0), Alias1);
+ EXPECT_EQ(&*std::next(RevIt1), Alias0);
+ }
+ // Check getAliasee().
+ EXPECT_EQ(Alias0->getAliasee(), Ctx.getValue(LLVMAlias0->getAliasee()));
+ // Check setAliasee().
+ auto *OrigAliasee = Alias0->getAliasee();
+ auto *NewAliasee = CalleeBar;
+ EXPECT_NE(NewAliasee, OrigAliasee);
+ Alias0->setAliasee(NewAliasee);
+ EXPECT_EQ(Alias0->getAliasee(), NewAliasee);
+ Alias0->setAliasee(OrigAliasee);
+ EXPECT_EQ(Alias0->getAliasee(), OrigAliasee);
+ // Check getAliaseeObject().
+ EXPECT_EQ(Alias0->getAliaseeObject(),
+ Ctx.getValue(LLVMAlias0->getAliaseeObject()));
+}
+
TEST_F(SandboxIRTest, BlockAddress) {
parseIR(C, R"IR(
define void @foo(ptr %ptr) {
diff --git a/llvm/unittests/SandboxIR/TrackerTest.cpp b/llvm/unittests/SandboxIR/TrackerTest.cpp
index f46e16e626baf0..da5416395ec42f 100644
--- a/llvm/unittests/SandboxIR/TrackerTest.cpp
+++ b/llvm/unittests/SandboxIR/TrackerTest.cpp
@@ -1638,6 +1638,37 @@ define void @foo() {
EXPECT_EQ(GV0->isExternallyInitialized(), OrigIsExtInit);
}
+TEST_F(TrackerTest, GlobalAliasSetters) {
+ parseIR(C, R"IR(
+ at alias = dso_local alias void(), ptr @foo
+declare void @bar();
+define void @foo() {
+ call void @alias()
+ call void @bar()
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+
+ auto &F = *Ctx.createFunction(&LLVMF);
+ auto *BB = &*F.begin();
+ auto It = BB->begin();
+ auto *Call0 = cast<sandboxir::CallInst>(&*It++);
+ auto *Call1 = cast<sandboxir::CallInst>(&*It++);
+ auto *Callee1 = cast<sandboxir::Constant>(Call1->getCalledOperand());
+ auto *Alias = cast<sandboxir::GlobalAlias>(Call0->getCalledOperand());
+ // Check setAliasee().
+ auto *OrigAliasee = Alias->getAliasee();
+ auto *NewAliasee = Callee1;
+ EXPECT_NE(NewAliasee, OrigAliasee);
+ Ctx.save();
+ Alias->setAliasee(NewAliasee);
+ EXPECT_EQ(Alias->getAliasee(), NewAliasee);
+ Ctx.revert();
+ EXPECT_EQ(Alias->getAliasee(), OrigAliasee);
+}
+
TEST_F(TrackerTest, SetVolatile) {
parseIR(C, R"IR(
define void @foo(ptr %arg0, i8 %val) {
More information about the llvm-commits
mailing list