mirrors-yuzu-emu/sirit
1
0
Fork 0
mirror of https://github.com/yuzu-emu/sirit synced 2024-11-22 14:43:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rename Ref -> Op

Browse source
This commit is contained in:
ReinUsesLisp 2018-08-25 20:34:06 -03:00
parent 34d215d3d8
commit 1de01c95ae
6 changed files with 88 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
include/sirit/sirit.h
View file

@ -16,7 +16,7 @@ namespace Sirit {
static const std::uint32_t GeneratorMagicNumber = 0;
class Ref;
class Op;
class Module {
public:
@ -44,37 +44,37 @@ public:
void SetMemoryModel(spv::AddressingModel addressing_model, spv::MemoryModel memory_model);
/// Adds an entry point.
void AddEntryPoint(spv::ExecutionModel execution_model, const Ref* entry_point,
const std::string& name, const std::vector<const Ref*>& interfaces = {});
void AddEntryPoint(spv::ExecutionModel execution_model, const Op* entry_point,
const std::string& name, const std::vector<const Op*>& interfaces = {});
/// Returns type void.
const Ref* TypeVoid();
const Op* TypeVoid();
/// Returns a function type.
const Ref* TypeFunction(const Ref* return_type, const std::vector<const Ref*>& arguments = {});
const Op* TypeFunction(const Op* return_type, const std::vector<const Op*>& arguments = {});
/// Adds a reference to code block
void Add(const Ref* ref);
/// Adds an instruction to module's code block
const Op* Emit(const Op* op);
/// Emits a function.
const Ref* EmitFunction(const Ref* result_type, spv::FunctionControlMask function_control,
const Ref* function_type);
const Op* Function(const Op* result_type, spv::FunctionControlMask function_control,
const Op* function_type);
/// Emits a label. It starts a block.
const Ref* EmitLabel();
const Op* Label();
/// Emits a return. It ends a block.
const Ref* EmitReturn();
const Op* Return();
/// Emits a function end.
const Ref* EmitFunctionEnd();
const Op* FunctionEnd();
private:
const Ref* AddCode(Ref* ref);
const Op* AddCode(Op* op);
const Ref* AddCode(spv::Op opcode, std::uint32_t id = UINT32_MAX);
const Op* AddCode(spv::Op opcode, std::uint32_t id = UINT32_MAX);
const Ref* AddDeclaration(Ref* ref);
const Op* AddDeclaration(Op* op);
std::uint32_t bound{1};
@ -82,24 +82,24 @@ private:
std::set<std::string> extensions;
std::set<std::unique_ptr<Ref>> ext_inst_import;
std::set<std::unique_ptr<Op>> ext_inst_import;
spv::AddressingModel addressing_model{spv::AddressingModel::Logical};
spv::MemoryModel memory_model{spv::MemoryModel::GLSL450};
std::vector<std::unique_ptr<Ref>> entry_points;
std::vector<std::unique_ptr<Op>> entry_points;
std::vector<std::unique_ptr<Ref>> execution_mode;
std::vector<std::unique_ptr<Op>> execution_mode;
std::vector<std::unique_ptr<Ref>> debug;
std::vector<std::unique_ptr<Op>> debug;
std::vector<std::unique_ptr<Ref>> annotations;
std::vector<std::unique_ptr<Op>> annotations;
std::vector<std::unique_ptr<Ref>> declarations;
std::vector<std::unique_ptr<Op>> declarations;
std::vector<const Ref*> code;
std::vector<const Op*> code;
std::vector<std::unique_ptr<Ref>> code_store;
std::vector<std::unique_ptr<Op>> code_store;
};
} // namespace Sirit

4
src/CMakeLists.txt
View file

@ -1,8 +1,8 @@
add_library(sirit
../include/sirit/sirit.h
sirit.cpp
ref.cpp
ref.h
op.cpp
op.h
stream.cpp
stream.h
operand.cpp

38
src/ref.cpp → src/op.cpp
View file

@ -7,35 +7,35 @@
#include <cassert>
#include "common_types.h"
#include "operand.h"
#include "ref.h"
#include "op.h"
namespace Sirit {
Ref::Ref(spv::Op opcode_, u32 id_, const Ref* result_type_)
Op::Op(spv::Op opcode_, u32 id_, const Op* result_type_)
: opcode(opcode_), id(id_), result_type(result_type_) {
operand_type = OperandType::Ref;
}
Ref::~Ref() = default;
Op::~Op() = default;
void Ref::Fetch(Stream& stream) const {
void Op::Fetch(Stream& stream) const {
assert(id != UINT32_MAX);
stream.Write(id);
}
u16 Ref::GetWordCount() const {
u16 Op::GetWordCount() const {
return 1;
}
bool Ref::operator==(const Operand& other) const {
bool Op::operator==(const Operand& other) const {
if (operand_type != other.GetType()) {
return false;
}
const Ref& ref = dynamic_cast<const Ref&>(other);
if (ref.opcode == opcode && result_type == ref.result_type &&
operands.size() == ref.operands.size()) {
const Op& op = dynamic_cast<const Op&>(other);
if (op.opcode == opcode && result_type == op.result_type &&
operands.size() == op.operands.size()) {
for (std::size_t i{}; i < operands.size(); i++) {
if (*operands[i] != *ref.operands[i]) {
if (*operands[i] != *op.operands[i]) {
return false;
}
}
@ -44,7 +44,7 @@ bool Ref::operator==(const Operand& other) const {
return false;
}
void Ref::Write(Stream& stream) const {
void Op::Write(Stream& stream) const {
stream.Write(static_cast<u16>(opcode));
stream.Write(WordCount());
@ -59,30 +59,30 @@ void Ref::Write(Stream& stream) const {
}
}
void Ref::Add(Operand* operand) {
void Op::Add(Operand* operand) {
Add(static_cast<const Operand*>(operand));
operand_store.push_back(std::unique_ptr<Operand>(operand));
}
void Ref::Add(const Operand* operand) {
void Op::Add(const Operand* operand) {
operands.push_back(operand);
}
void Ref::Add(u32 integer) {
void Op::Add(u32 integer) {
Add(new LiteralInteger(integer));
}
void Ref::Add(const std::string& string) {
void Op::Add(const std::string& string) {
Add(new LiteralString(string));
}
void Ref::Add(const std::vector<const Ref*>& ids) {
for (const Ref* ref : ids) {
Add(ref);
void Op::Add(const std::vector<const Op*>& ids) {
for (const Op* op : ids) {
Add(op);
}
}
u16 Ref::WordCount() const {
u16 Op::WordCount() const {
u16 count{1};
if (result_type) {
count++;

10
src/ref.h → src/op.h
View file

@ -13,10 +13,10 @@
namespace Sirit {
class Ref : public Operand {
class Op : public Operand {
public:
explicit Ref(spv::Op opcode, u32 id = UINT32_MAX, const Ref* result_type = nullptr);
~Ref();
explicit Op(spv::Op opcode, u32 id = UINT32_MAX, const Op* result_type = nullptr);
~Op();
virtual void Fetch(Stream& stream) const;
virtual u16 GetWordCount() const;
@ -33,14 +33,14 @@ public:
void Add(const std::string& string);
void Add(const std::vector<const Ref*>& ids);
void Add(const std::vector<const Op*>& ids);
private:
u16 WordCount() const;
spv::Op opcode;
const Ref* result_type;
const Op* result_type;
u32 id;

69
src/sirit.cpp
View file

@ -8,16 +8,16 @@
#include <cassert>
#include "sirit/sirit.h"
#include "common_types.h"
#include "ref.h"
#include "op.h"
#include "stream.h"
namespace Sirit {
template<typename T>
static void WriteEnum(Stream& stream, spv::Op op, T value) {
Ref ref{op};
ref.Add(static_cast<u32>(value));
ref.Write(stream);
static void WriteEnum(Stream& stream, spv::Op opcode, T value) {
Op op{opcode};
op.Add(static_cast<u32>(value));
op.Write(stream);
}
Module::Module() {}
@ -42,7 +42,7 @@ std::vector<u8> Module::Assembly() const {
// TODO write ext inst imports
Ref memory_model_ref{spv::Op::OpMemoryModel};
Op memory_model_ref{spv::Op::OpMemoryModel};
memory_model_ref.Add(static_cast<u32>(addressing_model));
memory_model_ref.Add(static_cast<u32>(memory_model));
memory_model_ref.Write(stream);
@ -79,74 +79,75 @@ void Module::SetMemoryModel(spv::AddressingModel addressing_model, spv::MemoryMo
this->memory_model = memory_model;
}
void Module::AddEntryPoint(spv::ExecutionModel execution_model, const Ref* entry_point,
const std::string& name, const std::vector<const Ref*>& interfaces) {
Ref* op{new Ref(spv::Op::OpEntryPoint)};
void Module::AddEntryPoint(spv::ExecutionModel execution_model, const Op* entry_point,
const std::string& name, const std::vector<const Op*>& interfaces) {
Op* op{new Op(spv::Op::OpEntryPoint)};
op->Add(static_cast<u32>(execution_model));
op->Add(entry_point);
op->Add(name);
op->Add(interfaces);
entry_points.push_back(std::unique_ptr<Ref>(op));
entry_points.push_back(std::unique_ptr<Op>(op));
}
const Ref* Module::TypeVoid() {
return AddDeclaration(new Ref(spv::Op::OpTypeVoid, bound));
const Op* Module::TypeVoid() {
return AddDeclaration(new Op(spv::Op::OpTypeVoid, bound));
}
const Ref* Module::TypeFunction(const Ref* return_type, const std::vector<const Ref*>& arguments) {
Ref* type_func{new Ref(spv::Op::OpTypeFunction, bound)};
const Op* Module::TypeFunction(const Op* return_type, const std::vector<const Op*>& arguments) {
Op* type_func{new Op(spv::Op::OpTypeFunction, bound)};
type_func->Add(return_type);
for (const Ref* arg : arguments) {
for (const Op* arg : arguments) {
type_func->Add(arg);
}
return AddDeclaration(type_func);
}
void Module::Add(const Ref* ref) {
assert(ref);
code.push_back(ref);
const Op* Module::Emit(const Op* op) {
assert(op);
code.push_back(op);
return op;
}
const Ref* Module::EmitFunction(const Ref* result_type, spv::FunctionControlMask function_control,
const Ref* function_type) {
Ref* op{new Ref{spv::Op::OpFunction, bound++, result_type}};
const Op* Module::Function(const Op* result_type, spv::FunctionControlMask function_control,
const Op* function_type) {
Op* op{new Op{spv::Op::OpFunction, bound++, result_type}};
op->Add(static_cast<u32>(function_control));
op->Add(function_type);
return AddCode(op);
}
const Ref* Module::EmitLabel() {
const Op* Module::Label() {
return AddCode(spv::Op::OpLabel, bound++);
}
const Ref* Module::EmitReturn() {
const Op* Module::Return() {
return AddCode(spv::Op::OpReturn);
}
const Ref* Module::EmitFunctionEnd() {
const Op* Module::FunctionEnd() {
return AddCode(spv::Op::OpFunctionEnd);
}
const Ref* Module::AddCode(Ref* ref) {
code_store.push_back(std::unique_ptr<Ref>(ref));
return ref;
const Op* Module::AddCode(Op* op) {
code_store.push_back(std::unique_ptr<Op>(op));
return op;
}
const Ref* Module::AddCode(spv::Op opcode, u32 id) {
return AddCode(new Ref{opcode, id});
const Op* Module::AddCode(spv::Op opcode, u32 id) {
return AddCode(new Op{opcode, id});
}
const Ref* Module::AddDeclaration(Ref* ref) {
const Op* Module::AddDeclaration(Op* op) {
const auto& found{std::find_if(declarations.begin(), declarations.end(), [=](const auto& other) {
return *other == *ref;
return *other == *op;
})};
if (found != declarations.end()) {
delete ref;
delete op;
return found->get();
} else {
declarations.push_back(std::unique_ptr<Ref>(ref));
declarations.push_back(std::unique_ptr<Op>(op));
bound++;
return ref;
return op;
}
}

9
tests/main.cpp
View file

@ -18,11 +18,10 @@ public:
SetMemoryModel(spv::AddressingModel::Logical, spv::MemoryModel::GLSL450);
auto main_type{TypeFunction(TypeVoid())};
auto main_func{EmitFunction(TypeVoid(), spv::FunctionControlMask::MaskNone, main_type)};
Add(main_func);
Add(EmitLabel());
Add(EmitReturn());
Add(EmitFunctionEnd());
auto main_func{Emit(Function(TypeVoid(), spv::FunctionControlMask::MaskNone, main_type))};
Emit(Label());
Emit(Return());
Emit(FunctionEnd());
AddEntryPoint(spv::ExecutionModel::Vertex, main_func, "main");
}