Skip to content

Commit 968460d

Browse files
vporpovporpo
committed
[SandboxIR] More boilerplate: Function, Argument, Constant, Instruction, OpaqueInst
A very basic implementation of sandboxir:: `Fuction` `Argument` `Constant` `Instruction` `OpaqueInst`
1 parent 658c03d commit 968460d

File tree

4 files changed

+273
-11
lines changed

4 files changed

+273
-11
lines changed

‎llvm/include/llvm/SandboxIR/SandboxIR.h

Lines changed: 151 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,7 @@
5858
#ifndef LLVM_TRANSFORMS_SANDBOXIR_SANDBOXIR_H
5959
#define LLVM_TRANSFORMS_SANDBOXIR_SANDBOXIR_H
6060

61+
#include "llvm/IR/Function.h"
6162
#include "llvm/IR/User.h"
6263
#include "llvm/IR/Value.h"
6364
#include "llvm/Support/raw_ostream.h"
@@ -129,6 +130,35 @@ class Value {
129130
void dumpCommonPrefix(raw_ostream &OS) const;
130131
void dumpCommonSuffix(raw_ostream &OS) const;
131132
void printAsOperandCommon(raw_ostream &OS) const;
133+
friend raw_ostream &operator<<(raw_ostream &OS, const sandboxir::Value &V) {
134+
V.dump(OS);
135+
return OS;
136+
}
137+
virtual void dump(raw_ostream &OS) const = 0;
138+
LLVM_DUMP_METHOD virtual void dump() const = 0;
139+
#endif
140+
};
141+
142+
/// Argument of a sandboxir::Function.
143+
class Argument : public sandboxir::Value {
144+
public:
145+
Argument(llvm::Argument *Arg, sandboxir::Context &Ctx)
146+
: sandboxir::Value(ClassID::Argument, Arg, Ctx) {}
147+
static bool classof(const sandboxir::Value *From) {
148+
return From->getSubclassID() == ClassID::Argument;
149+
}
150+
#ifndef NDEBUG
151+
void verify() const final {
152+
assert(isa<llvm::Argument>(Val) && "Expected Argument!");
153+
}
154+
friend raw_ostream &operator<<(raw_ostream &OS,
155+
const sandboxir::Argument &TArg) {
156+
TArg.dump(OS);
157+
return OS;
158+
}
159+
void printAsOperand(raw_ostream &OS) const;
160+
void dump(raw_ostream &OS) const final;
161+
LLVM_DUMP_METHOD void dump() const final;
132162
#endif
133163
};
134164

@@ -142,16 +172,137 @@ class User : public Value {
142172
assert(isa<llvm::User>(Val) && "Expected User!");
143173
}
144174
void dumpCommonHeader(raw_ostream &OS) const final;
175+
void dump(raw_ostream &OS) const override {
176+
// TODO: Remove this tmp implementation once we get the Instruction classes.
177+
}
178+
LLVM_DUMP_METHOD void dump() const override {
179+
// TODO: Remove this tmp implementation once we get the Instruction classes.
180+
}
181+
#endif
182+
};
183+
184+
class Constant : public sandboxir::User {
185+
public:
186+
Constant(llvm::Constant *C, sandboxir::Context &SBCtx)
187+
: sandboxir::User(ClassID::Constant, C, SBCtx) {}
188+
/// For isa/dyn_cast.
189+
static bool classof(const sandboxir::Value *From) {
190+
return From->getSubclassID() == ClassID::Constant ||
191+
From->getSubclassID() == ClassID::Function;
192+
}
193+
sandboxir::Context &getParent() const { return getContext(); }
194+
#ifndef NDEBUG
195+
void verify() const final {
196+
assert(isa<llvm::Constant>(Val) && "Expected Constant!");
197+
}
198+
friend raw_ostream &operator<<(raw_ostream &OS,
199+
const sandboxir::Constant &SBC) {
200+
SBC.dump(OS);
201+
return OS;
202+
}
203+
void dump(raw_ostream &OS) const override;
204+
LLVM_DUMP_METHOD void dump() const override;
205+
#endif
206+
};
207+
208+
/// A sandboxir::User with operands and opcode.
209+
class Instruction : public sandboxir::User {
210+
public:
211+
enum class Opcode {
212+
#define DEF_VALUE(ID, CLASS)
213+
#define DEF_USER(ID, CLASS)
214+
#define OP(OPC) OPC,
215+
#define OPCODES(...) __VA_ARGS__
216+
#define DEF_INSTR(ID, OPC, CLASS) OPC
217+
#include "llvm/SandboxIR/SandboxIRValues.def"
218+
};
219+
220+
Instruction(ClassID ID, Opcode Opc, llvm::Instruction *I,
221+
sandboxir::Context &SBCtx)
222+
: sandboxir::User(ID, I, SBCtx), Opc(Opc) {}
223+
224+
protected:
225+
Opcode Opc;
226+
227+
public:
228+
static const char *getOpcodeName(Opcode Opc);
229+
#ifndef NDEBUG
230+
friend raw_ostream &operator<<(raw_ostream &OS, Opcode Opc) {
231+
OS << getOpcodeName(Opc);
232+
return OS;
233+
}
234+
#endif
235+
/// For isa/dyn_cast.
236+
static bool classof(const sandboxir::Value *From);
237+
238+
#ifndef NDEBUG
239+
friend raw_ostream &operator<<(raw_ostream &OS,
240+
const sandboxir::Instruction &SBI) {
241+
SBI.dump(OS);
242+
return OS;
243+
}
244+
void dump(raw_ostream &OS) const override;
245+
LLVM_DUMP_METHOD void dump() const override;
246+
#endif
247+
};
248+
249+
/// An LLLVM Instruction that has no SandboxIR equivalent class gets mapped to
250+
/// an OpaqueInstr.
251+
class OpaqueInst : public sandboxir::Instruction {
252+
public:
253+
OpaqueInst(llvm::Instruction *I, sandboxir::Context &Ctx)
254+
: sandboxir::Instruction(ClassID::Opaque, Opcode::Opaque, I, Ctx) {}
255+
OpaqueInst(ClassID SubclassID, llvm::Instruction *I, sandboxir::Context &Ctx)
256+
: sandboxir::Instruction(SubclassID, Opcode::Opaque, I, Ctx) {}
257+
static bool classof(const sandboxir::Value *From) {
258+
return From->getSubclassID() == ClassID::Opaque;
259+
}
260+
#ifndef NDEBUG
261+
void verify() const final {
262+
// Nothing to do
263+
}
264+
friend raw_ostream &operator<<(raw_ostream &OS,
265+
const sandboxir::OpaqueInst &OI) {
266+
OI.dump(OS);
267+
return OS;
268+
}
269+
void dump(raw_ostream &OS) const override;
270+
LLVM_DUMP_METHOD void dump() const override;
145271
#endif
146272
};
147273

148274
class Context {
149275
protected:
150276
LLVMContext &LLVMCtx;
277+
/// Maps LLVM Value to the corresponding sandboxir::Value. Owns all
278+
/// SandboxIR objects.
279+
DenseMap<llvm::Value *, std::unique_ptr<sandboxir::Value>>
280+
LLVMValueToSBValueMap;
151281

152282
public:
153283
Context(LLVMContext &LLVMCtx) : LLVMCtx(LLVMCtx) {}
284+
sandboxir::Value *getValue(llvm::Value *V) const;
285+
};
286+
287+
class Function : public sandboxir::Value {
288+
public:
289+
Function(llvm::Function *F, sandboxir::Context &Ctx)
290+
: sandboxir::Value(ClassID::Function, F, Ctx) {}
291+
/// For isa/dyn_cast.
292+
static bool classof(const sandboxir::Value *From) {
293+
return From->getSubclassID() == ClassID::Function;
294+
}
295+
296+
#ifndef NDEBUG
297+
void verify() const final {
298+
assert(isa<llvm::Function>(Val) && "Expected Function!");
299+
}
300+
void dumpNameAndArgs(raw_ostream &OS) const;
301+
void dump(raw_ostream &OS) const final;
302+
LLVM_DUMP_METHOD void dump() const final;
303+
#endif
154304
};
305+
155306
} // namespace sandboxir
156307
} // namespace llvm
157308

‎llvm/include/llvm/SandboxIR/SandboxIRValues.def

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,13 @@
77
//===----------------------------------------------------------------------===//
88

99
// ClassID, Class
10-
DEF_USER(User, sandboxir::User)
10+
DEF_VALUE(Function, Function)
11+
DEF_VALUE(Argument, Argument)
12+
DEF_USER(User, User)
13+
DEF_USER(Constant, Constant)
14+
15+
// ClassID, Opcode(s), Class
16+
DEF_INSTR(Opaque, OP(Opaque), OpaqueInst)
1117

1218
#ifdef DEF_VALUE
1319
#undef DEF_VALUE

‎llvm/lib/SandboxIR/SandboxIR.cpp

Lines changed: 96 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -10,28 +10,27 @@
1010
#include "llvm/Support/Debug.h"
1111
#include <sstream>
1212

13-
using namespace llvm;
14-
using namespace sandboxir;
13+
using namespace llvm::sandboxir;
1514

16-
sandboxir::Value::Value(ClassID SubclassID, llvm::Value *Val, Context &Ctx)
15+
Value::Value(ClassID SubclassID, llvm::Value *Val, Context &Ctx)
1716
: SubclassID(SubclassID), Val(Val), Ctx(Ctx) {
1817
#ifndef NDEBUG
1918
UID = 0; // FIXME: Once SBContext is available.
2019
#endif
2120
}
2221

2322
#ifndef NDEBUG
24-
std::string sandboxir::Value::getName() const {
23+
std::string Value::getName() const {
2524
std::stringstream SS;
2625
SS << "SB" << UID << ".";
2726
return SS.str();
2827
}
2928

30-
void sandboxir::Value::dumpCommonHeader(raw_ostream &OS) const {
29+
void Value::dumpCommonHeader(raw_ostream &OS) const {
3130
OS << getName() << " " << getSubclassIDStr(SubclassID) << " ";
3231
}
3332

34-
void sandboxir::Value::dumpCommonFooter(raw_ostream &OS) const {
33+
void Value::dumpCommonFooter(raw_ostream &OS) const {
3534
OS.indent(2) << "Val: ";
3635
if (Val)
3736
OS << *Val;
@@ -40,27 +39,114 @@ void sandboxir::Value::dumpCommonFooter(raw_ostream &OS) const {
4039
OS << "\n";
4140
}
4241

43-
void sandboxir::Value::dumpCommonPrefix(raw_ostream &OS) const {
42+
void Value::dumpCommonPrefix(raw_ostream &OS) const {
4443
if (Val)
4544
OS << *Val;
4645
else
4746
OS << "NULL ";
4847
}
4948

50-
void sandboxir::Value::dumpCommonSuffix(raw_ostream &OS) const {
49+
void Value::dumpCommonSuffix(raw_ostream &OS) const {
5150
OS << " ; " << getName() << " (" << getSubclassIDStr(SubclassID) << ") "
5251
<< this;
5352
}
5453

55-
void sandboxir::Value::printAsOperandCommon(raw_ostream &OS) const {
54+
void Value::printAsOperandCommon(raw_ostream &OS) const {
5655
if (Val)
5756
Val->printAsOperand(OS);
5857
else
5958
OS << "NULL ";
6059
}
6160

62-
void sandboxir::User::dumpCommonHeader(raw_ostream &OS) const {
61+
void Argument::printAsOperand(raw_ostream &OS) const {
62+
printAsOperandCommon(OS);
63+
}
64+
void Argument::dump(raw_ostream &OS) const {
65+
dumpCommonPrefix(OS);
66+
dumpCommonSuffix(OS);
67+
}
68+
void Argument::dump() const {
69+
dump(dbgs());
70+
dbgs() << "\n";
71+
}
72+
73+
void User::dumpCommonHeader(raw_ostream &OS) const {
6374
Value::dumpCommonHeader(OS);
6475
// TODO: This is incomplete
6576
}
6677
#endif // NDEBUG
78+
79+
const char *Instruction::getOpcodeName(Opcode Opc) {
80+
switch (Opc) {
81+
#define DEF_VALUE(ID, CLASS)
82+
#define DEF_USER(ID, CLASS)
83+
#define OP(OPC) \
84+
case Opcode::OPC: \
85+
return #OPC;
86+
#define OPCODES(...) __VA_ARGS__
87+
#define DEF_INSTR(ID, OPC, CLASS) OPC
88+
#include "llvm/SandboxIR/SandboxIRValues.def"
89+
}
90+
}
91+
92+
#ifndef NDEBUG
93+
void Instruction::dump(raw_ostream &OS) const {
94+
OS << "Unimplemented! Please override dump().";
95+
}
96+
void Instruction::dump() const {
97+
dump(dbgs());
98+
dbgs() << "\n";
99+
}
100+
101+
void OpaqueInst::dump(raw_ostream &OS) const {
102+
dumpCommonPrefix(OS);
103+
dumpCommonSuffix(OS);
104+
}
105+
106+
void OpaqueInst::dump() const {
107+
dump(dbgs());
108+
dbgs() << "\n";
109+
}
110+
111+
void Constant::dump(raw_ostream &OS) const {
112+
dumpCommonPrefix(OS);
113+
dumpCommonSuffix(OS);
114+
}
115+
116+
void Constant::dump() const {
117+
dump(dbgs());
118+
dbgs() << "\n";
119+
}
120+
121+
void Function::dumpNameAndArgs(raw_ostream &OS) const {
122+
auto *F = cast<llvm::Function>(Val);
123+
OS << *getType() << " @" << F->getName() << "(";
124+
auto NumArgs = F->arg_size();
125+
for (auto [Idx, Arg] : enumerate(F->args())) {
126+
auto *SBArg = cast_or_null<Argument>(Ctx.getValue(&Arg));
127+
if (SBArg == nullptr)
128+
OS << "NULL";
129+
else
130+
SBArg->printAsOperand(OS);
131+
if (Idx + 1 < NumArgs)
132+
OS << ", ";
133+
}
134+
OS << ")";
135+
}
136+
void Function::dump(raw_ostream &OS) const {
137+
dumpNameAndArgs(OS);
138+
OS << " {\n";
139+
OS << "}\n";
140+
}
141+
void Function::dump() const {
142+
dump(dbgs());
143+
dbgs() << "\n";
144+
}
145+
#endif // NDEBUG
146+
147+
Value *Context::getValue(llvm::Value *V) const {
148+
auto It = LLVMValueToSBValueMap.find(V);
149+
if (It != LLVMValueToSBValueMap.end())
150+
return It->second.get();
151+
return nullptr;
152+
}

‎llvm/unittests/SandboxIR/SandboxIRTest.cpp

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,3 +40,22 @@ define void @foo(i32 %v1) {
4040
sandboxir::Context Ctx(C);
4141
[[maybe_unused]] sandboxir::User U(sandboxir::Value::ClassID::User, Ret, Ctx);
4242
}
43+
44+
TEST_F(SandboxIRTest, FunctionArgumentConstantAndOpaqueInstInstantiation) {
45+
parseIR(C, R"IR(
46+
define void @foo(i32 %v1) {
47+
%add = add i32 %v1, 42
48+
ret void
49+
}
50+
)IR");
51+
llvm::Function *LLVMF = &*M->getFunction("foo");
52+
llvm::BasicBlock *LLVMBB = &*LLVMF->begin();
53+
llvm::Instruction *LLVMAdd = &*LLVMBB->begin();
54+
auto *LLVMC = cast<llvm::Constant>(LLVMAdd->getOperand(1));
55+
sandboxir::Context Ctx(C);
56+
auto *LLVMArg0 = LLVMF->getArg(0);
57+
[[maybe_unused]] sandboxir::Function F(LLVMF, Ctx);
58+
[[maybe_unused]] sandboxir::Argument Arg0(LLVMArg0, Ctx);
59+
[[maybe_unused]] sandboxir::Constant Const0(LLVMC, Ctx);
60+
[[maybe_unused]] sandboxir::OpaqueInst Opaque(LLVMAdd, Ctx);
61+
}

0 commit comments

Comments
 (0)