mirrors/sirit
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/sirit.git synced 2024-12-22 12:12:05 +00:00
Code Issues Releases Activity

Fixup build issues

Browse source
This commit is contained in:
ReinUsesLisp 2018-11-01 05:13:30 -03:00
parent f3a63aa55f
commit 91e0769db5
6 changed files with 78 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/insts/memory.cpp
View file

@ -4,7 +4,7 @@
* Lesser General Public License version 2.1 or any later version.
*/
#include "insts.h"
#include "op.h"
#include "sirit/sirit.h"
#include <cassert>
@ -12,51 +12,51 @@ namespace Sirit {
Id Module::OpVariable(Id result_type, spv::StorageClass storage_class,
Id initializer) {
auto op{new Op(spv::Op::OpVariable, bound++, result_type)};
AddEnum(op, storage_class);
auto op{std::make_unique<Op>(spv::Op::OpVariable, bound++, result_type)};
op->Add(static_cast<u32>(storage_class));
if (initializer) {
op->Add(initializer);
}
return AddCode(op);
return AddCode(std::move(op));
}
Id Module::OpLoad(Id result_type, Id pointer,
std::optional<spv::MemoryAccessMask> memory_access) {
auto op{new Op(spv::Op::OpLoad, bound++, result_type)};
auto op{std::make_unique<Op>(spv::Op::OpLoad, bound++, result_type)};
op->Add(pointer);
if (memory_access) {
AddEnum(op, *memory_access);
op->Add(static_cast<u32>(*memory_access));
}
return AddCode(op);
return AddCode(std::move(op));
}
Id Module::OpStore(Id pointer, Id object,
std::optional<spv::MemoryAccessMask> memory_access) {
auto op{new Op(spv::Op::OpStore)};
auto op{std::make_unique<Op>(spv::Op::OpStore)};
op->Add(pointer);
op->Add(object);
if (memory_access) {
AddEnum(op, *memory_access);
op->Add(static_cast<u32>(*memory_access));
}
return AddCode(op);
return AddCode(std::move(op));
}
Id Module::OpAccessChain(Id result_type, Id base,
const std::vector<Id>& indexes) {
assert(indexes.size() > 0);
auto op{new Op(spv::Op::OpAccessChain, bound++, result_type)};
auto op{std::make_unique<Op>(spv::Op::OpAccessChain, bound++, result_type)};
op->Add(base);
op->Add(indexes);
return AddCode(op);
return AddCode(std::move(op));
}
Id Module::OpCompositeInsert(Id result_type, Id object, Id composite,
const std::vector<Literal>& indexes) {
auto op{new Op(spv::Op::OpCompositeInsert, bound++, result_type)};
auto op{std::make_unique<Op>(spv::Op::OpCompositeInsert, bound++, result_type)};
op->Add(object);
op->Add(composite);
op->Add(indexes);
return AddCode(op);
return AddCode(std::move(op));
}
} // namespace Sirit

4
src/insts/misc.cpp
View file

@ -4,14 +4,14 @@
* Lesser General Public License version 2.1 or any later version.
*/
#include "insts.h"
#include "op.h"
#include "sirit/sirit.h"
#include <cassert>
namespace Sirit {
Id Module::OpUndef(Id result_type) {
return AddCode(new Op(spv::Op::OpUndef, bound++, result_type));
return AddCode(std::make_unique<Op>(spv::Op::OpUndef, bound++, result_type));
}
} // namespace Sirit

69
src/insts/type.cpp
View file

@ -4,20 +4,21 @@
* Lesser General Public License version 2.1 or any later version.
*/
#include <memory>
#include <cassert>
#include <optional>
#include "insts.h"
#include "op.h"
#include "sirit/sirit.h"
namespace Sirit {
Id Module::OpTypeVoid() {
return AddDeclaration(new Op(spv::Op::OpTypeVoid, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeVoid, bound));
}
Id Module::OpTypeBool() {
return AddDeclaration(new Op(spv::Op::OpTypeBool, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeBool, bound));
}
Id Module::OpTypeInt(int width, bool is_signed) {
@ -28,10 +29,10 @@ Id Module::OpTypeInt(int width, bool is_signed) {
} else if (width == 64) {
AddCapability(spv::Capability::Int64);
}
auto op{new Op(spv::Op::OpTypeInt, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeInt, bound)};
op->Add(width);
op->Add(is_signed ? 1 : 0);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeFloat(int width) {
@ -40,26 +41,26 @@ Id Module::OpTypeFloat(int width) {
} else if (width == 64) {
AddCapability(spv::Capability::Float64);
}
auto op{new Op(spv::Op::OpTypeFloat, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeFloat, bound)};
op->Add(width);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeVector(Id component_type, int component_count) {
assert(component_count >= 2);
auto op{new Op(spv::Op::OpTypeVector, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeVector, bound)};
op->Add(component_type);
op->Add(component_count);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeMatrix(Id column_type, int column_count) {
assert(column_count >= 2);
AddCapability(spv::Capability::Matrix);
Op* op{new Op(spv::Op::OpTypeMatrix, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeMatrix, bound)};
op->Add(column_type);
op->Add(column_count);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed,
@ -125,7 +126,7 @@ Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed,
AddCapability(spv::Capability::StorageImageExtendedFormats);
break;
}
auto op{new Op(spv::Op::OpTypeImage, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeImage, bound)};
op->Add(sampled_type);
op->Add(static_cast<u32>(dim));
op->Add(depth);
@ -137,44 +138,44 @@ Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed,
AddCapability(spv::Capability::Kernel);
op->Add(static_cast<u32>(access_qualifier.value()));
}
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeSampler() {
return AddDeclaration(new Op(spv::Op::OpTypeSampler, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeSampler, bound));
}
Id Module::OpTypeSampledImage(Id image_type) {
auto op{new Op(spv::Op::OpTypeSampledImage, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeSampledImage, bound)};
op->Add(image_type);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeArray(Id element_type, Id length) {
auto op{new Op(spv::Op::OpTypeArray, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeArray, bound)};
op->Add(element_type);
op->Add(length);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeRuntimeArray(Id element_type) {
AddCapability(spv::Capability::Shader);
auto op{new Op(spv::Op::OpTypeRuntimeArray, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeRuntimeArray, bound)};
op->Add(element_type);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeStruct(const std::vector<Id>& members) {
auto op{new Op(spv::Op::OpTypeStruct, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeStruct, bound)};
op->Add(members);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeOpaque(const std::string& name) {
AddCapability(spv::Capability::Kernel);
auto op{new Op(spv::Op::OpTypeOpaque, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeOpaque, bound)};
op->Add(name);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypePointer(spv::StorageClass storage_class, Id type) {
@ -193,44 +194,44 @@ Id Module::OpTypePointer(spv::StorageClass storage_class, Id type) {
AddCapability(spv::Capability::AtomicStorage);
break;
}
auto op{new Op(spv::Op::OpTypePointer, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypePointer, bound)};
op->Add(static_cast<u32>(storage_class));
op->Add(type);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeFunction(Id return_type, const std::vector<Id>& arguments) {
auto op{new Op(spv::Op::OpTypeFunction, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypeFunction, bound)};
op->Add(return_type);
op->Add(arguments);
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
Id Module::OpTypeEvent() {
AddCapability(spv::Capability::Kernel);
return AddDeclaration(new Op(spv::Op::OpTypeEvent, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeEvent, bound));
}
Id Module::OpTypeDeviceEvent() {
AddCapability(spv::Capability::DeviceEnqueue);
return AddDeclaration(new Op(spv::Op::OpTypeDeviceEvent, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeDeviceEvent, bound));
}
Id Module::OpTypeReserveId() {
AddCapability(spv::Capability::Pipes);
return AddDeclaration(new Op(spv::Op::OpTypeReserveId, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeReserveId, bound));
}
Id Module::OpTypeQueue() {
AddCapability(spv::Capability::DeviceEnqueue);
return AddDeclaration(new Op(spv::Op::OpTypeQueue, bound));
return AddDeclaration(std::make_unique<Op>(spv::Op::OpTypeQueue, bound));
}
Id Module::OpTypePipe(spv::AccessQualifier access_qualifier) {
AddCapability(spv::Capability::Pipes);
auto op{new Op(spv::Op::OpTypePipe, bound)};
auto op{std::make_unique<Op>(spv::Op::OpTypePipe, bound)};
op->Add(static_cast<u32>(access_qualifier));
return AddDeclaration(op);
return AddDeclaration(std::move(op));
}
} // namespace Sirit

2
src/op.cpp
View file

@ -113,7 +113,7 @@ void Op::Add(const std::vector<Id>& ids) {
}
u16 Op::WordCount() const {
u16 count{1};
u16 count = 1;
if (result_type) {
count++;
}

10
src/sirit.cpp
View file

@ -75,12 +75,12 @@ void Module::SetMemoryModel(spv::AddressingModel addressing_model,
void Module::AddEntryPoint(spv::ExecutionModel execution_model, Id entry_point,
const std::string& name,
const std::vector<Id>& interfaces) {
auto const op{new Op(spv::Op::OpEntryPoint)};
auto op{std::make_unique<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<Op>(op));
entry_points.push_back(std::move(op));
}
Id Module::Emit(Id op) {
@ -95,8 +95,9 @@ Id Module::AddGlobalVariable(Id variable) {
}
Id Module::AddCode(std::unique_ptr<Op> op) {
const auto id = op.get();
code_store.push_back(std::move(op));
return op.get();
return id;
}
Id Module::AddCode(spv::Op opcode, std::optional<u32> id) {
@ -117,8 +118,9 @@ Id Module::AddDeclaration(std::unique_ptr<Op> op) {
}
Id Module::AddAnnotation(std::unique_ptr<Op> op) {
const auto id = op.get();
annotations.push_back(std::move(op));
return op.get();
return id;
}
} // namespace Sirit

39
tests/main.cpp
View file

@ -19,48 +19,49 @@ public:
AddCapability(spv::Capability::Shader);
SetMemoryModel(spv::AddressingModel::Logical, spv::MemoryModel::GLSL450);
const auto t_void = OpName(OpTypeVoid(), "void");
const auto t_uint = OpName(OpTypeInt(32, false), "uint");
const auto t_float = OpName(OpTypeFloat(32), "float");
const auto t_void = Name(OpTypeVoid(), "void");
const auto t_uint = Name(OpTypeInt(32, false), "uint");
const auto t_float = Name(OpTypeFloat(32), "float");
const auto float4 = OpName(OpTypeVector(t_float, 4), "float4");
const auto in_float = OpName(OpTypePointer(spv::StorageClass::Input, t_float), "in_float");
const auto in_float4 = OpName(OpTypePointer(spv::StorageClass::Input, float4), "in_float4");
const auto out_float4 = OpName(OpTypePointer(spv::StorageClass::Output, float4), "out_float4");
const auto float4 = Name(OpTypeVector(t_float, 4), "float4");
const auto in_float = Name(OpTypePointer(spv::StorageClass::Input, t_float), "in_float");
const auto in_float4 = Name(OpTypePointer(spv::StorageClass::Input, float4), "in_float4");
const auto out_float4 = Name(OpTypePointer(spv::StorageClass::Output, float4), "out_float4");
const auto gl_per_vertex = OpName(OpTypeStruct({float4}), "gl_PerVertex");
const auto gl_per_vertex_ptr = OpName(OpTypePointer(spv::StorageClass::Output, gl_per_vertex), "out_gl_PerVertex");
const auto gl_per_vertex = Name(OpTypeStruct({float4}), "gl_PerVertex");
const auto gl_per_vertex_ptr = Name(OpTypePointer(spv::StorageClass::Output, gl_per_vertex), "out_gl_PerVertex");
const auto in_pos = OpName(OpVariable(in_float4, spv::StorageClass::Input), "in_pos");
const auto per_vertex = OpName(OpVariable(gl_per_vertex_ptr, spv::StorageClass::Output), "per_vertex");
const auto in_pos = Name(OpVariable(in_float4, spv::StorageClass::Input), "in_pos");
const auto per_vertex = Name(OpVariable(gl_per_vertex_ptr, spv::StorageClass::Output), "per_vertex");
Decorate(in_pos, spv::Decoration::Location, {0});
Decorate(gl_per_vertex, spv::Decoration::Block);
Decorate(gl_per_vertex, spv::Decoration::Block);
MemberDecorate(gl_per_vertex, 0, spv::Decoration::BuiltIn, {static_cast<u32>(spv::BuiltIn::Position)});
AddGlobalVariable(in_pos);
AddGlobalVariable(per_vertex);
const auto main_func = Emit(OpName(OpFunction(t_void, spv::FunctionControlMask::MaskNone, TypeFunction(t_void)), "main"));
Emit(Label());
const auto main_func = Emit(Name(OpFunction(t_void, spv::FunctionControlMask::MaskNone, OpTypeFunction(t_void)), "main"));
Emit(OpLabel());
const auto ptr_pos_x = Emit(OpAccessChain(in_float, in_pos, {OpConstant(t_uint, 0u)}));
const auto ptr_pos_y = Emit(OpAccessChain(in_float, in_pos, {OpConstant(t_uint, 1u)}));
const auto pos_x = Emit(Load(t_float, ptr_pos_x));
const auto pos_y = Emit(Load(t_float, ptr_pos_y));
const auto pos_x = Emit(OpLoad(t_float, ptr_pos_x));
const auto pos_y = Emit(OpLoad(t_float, ptr_pos_y));
auto tmp_position = Emit(Undef(float4));
auto tmp_position = Emit(OpUndef(float4));
tmp_position = Emit(OpCompositeInsert(float4, pos_x, tmp_position, {0}));
tmp_position = Emit(OpCompositeInsert(float4, pos_y, tmp_position, {1}));
tmp_position = Emit(OpCompositeInsert(float4, OpConstant(t_float, 0.f), tmp_position, {2}));
tmp_position = Emit(OpCompositeInsert(float4, OpConstant(t_float, 1.f), tmp_position, {3}));
const auto gl_position = Emit(OpAccessChain(out_float4, per_vertex, {OpConstant(t_uint, 0u)}));
Emit(Store(gl_position, tmp_position));
Emit(OpStore(gl_position, tmp_position));
Emit(Return());
Emit(FunctionEnd());
Emit(OpReturn());
Emit(OpFunctionEnd());
AddEntryPoint(spv::ExecutionModel::Vertex, main_func, "main", {in_pos, per_vertex});
}