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

Rename Ref alias to Id

Browse source
This commit is contained in:
ReinUsesLisp 2018-10-31 22:20:49 -03:00
parent b8188f5ec4
commit 63ca1b5243
12 changed files with 121 additions and 121 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
include/sirit/sirit.h
View file

@ -23,7 +23,7 @@ class Operand;
using Literal = std::variant<std::uint32_t, std::uint64_t, std::int32_t, using Literal = std::variant<std::uint32_t, std::uint64_t, std::int32_t,
std::int64_t, float, double>; std::int64_t, float, double>;
using Ref = const Op*; using Id = const Op*;
class Module { class Module {
public: public:
@ -46,9 +46,9 @@ class Module {
spv::MemoryModel memory_model); spv::MemoryModel memory_model);
/// Adds an entry point. /// Adds an entry point.
void AddEntryPoint(spv::ExecutionModel execution_model, Ref entry_point, void AddEntryPoint(spv::ExecutionModel execution_model, Id entry_point,
const std::string& name, const std::string& name,
const std::vector<Ref>& interfaces = {}); const std::vector<Id>& interfaces = {});
/** /**
* Adds an instruction to module's code * Adds an instruction to module's code
@ -56,190 +56,190 @@ class Module {
* be emitted. * be emitted.
* @return Returns op. * @return Returns op.
*/ */
Ref Emit(Ref op); Id Emit(Id op);
/** /**
* Adds a global variable * Adds a global variable
* @param variable Global variable to add. * @param variable Global variable to add.
* @return Returns variable. * @return Returns variable.
*/ */
Ref AddGlobalVariable(Ref variable); Id AddGlobalVariable(Id variable);
// Types // Types
/// Returns type void. /// Returns type void.
Ref OpTypeVoid(); Id OpTypeVoid();
/// Returns type bool. /// Returns type bool.
Ref OpTypeBool(); Id OpTypeBool();
/// Returns type integer. /// Returns type integer.
Ref OpTypeInt(int width, bool is_signed); Id OpTypeInt(int width, bool is_signed);
/// Returns type float. /// Returns type float.
Ref OpTypeFloat(int width); Id OpTypeFloat(int width);
/// Returns type vector. /// Returns type vector.
Ref OpTypeVector(Ref component_type, int component_count); Id OpTypeVector(Id component_type, int component_count);
/// Returns type matrix. /// Returns type matrix.
Ref OpTypeMatrix(Ref column_type, int column_count); Id OpTypeMatrix(Id column_type, int column_count);
/// Returns type image. /// Returns type image.
Ref OpTypeImage(Ref sampled_type, spv::Dim dim, int depth, bool arrayed, Id OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed,
bool ms, int sampled, spv::ImageFormat image_format, bool ms, int sampled, spv::ImageFormat image_format,
std::optional<spv::AccessQualifier> access_qualifier = {}); std::optional<spv::AccessQualifier> access_qualifier = {});
/// Returns type sampler. /// Returns type sampler.
Ref OpTypeSampler(); Id OpTypeSampler();
/// Returns type sampled image. /// Returns type sampled image.
Ref OpTypeSampledImage(Ref image_type); Id OpTypeSampledImage(Id image_type);
/// Returns type array. /// Returns type array.
Ref OpTypeArray(Ref element_type, Ref length); Id OpTypeArray(Id element_type, Id length);
/// Returns type runtime array. /// Returns type runtime array.
Ref OpTypeRuntimeArray(Ref element_type); Id OpTypeRuntimeArray(Id element_type);
/// Returns type struct. /// Returns type struct.
Ref OpTypeStruct(const std::vector<Ref>& members = {}); Id OpTypeStruct(const std::vector<Id>& members = {});
/// Returns type opaque. /// Returns type opaque.
Ref OpTypeOpaque(const std::string& name); Id OpTypeOpaque(const std::string& name);
/// Returns type pointer. /// Returns type pointer.
Ref OpTypePointer(spv::StorageClass storage_class, Ref type); Id OpTypePointer(spv::StorageClass storage_class, Id type);
/// Returns type function. /// Returns type function.
Ref OpTypeFunction(Ref return_type, const std::vector<Ref>& arguments = {}); Id OpTypeFunction(Id return_type, const std::vector<Id>& arguments = {});
/// Returns type event. /// Returns type event.
Ref OpTypeEvent(); Id OpTypeEvent();
/// Returns type device event. /// Returns type device event.
Ref OpTypeDeviceEvent(); Id OpTypeDeviceEvent();
/// Returns type reserve id. /// Returns type reserve id.
Ref OpTypeReserveId(); Id OpTypeReserveId();
/// Returns type queue. /// Returns type queue.
Ref OpTypeQueue(); Id OpTypeQueue();
/// Returns type pipe. /// Returns type pipe.
Ref OpTypePipe(spv::AccessQualifier access_qualifier); Id OpTypePipe(spv::AccessQualifier access_qualifier);
// Constant // Constant
/// Returns a true scalar constant. /// Returns a true scalar constant.
Ref OpConstantTrue(Ref result_type); Id OpConstantTrue(Id result_type);
/// Returns a false scalar constant. /// Returns a false scalar constant.
Ref OpConstantFalse(Ref result_type); Id OpConstantFalse(Id result_type);
/// Returns a numeric scalar constant. /// Returns a numeric scalar constant.
Ref OpConstant(Ref result_type, const Literal& literal); Id OpConstant(Id result_type, const Literal& literal);
/// Returns a numeric scalar constant. /// Returns a numeric scalar constant.
Ref OpConstantComposite(Ref result_type, Id OpConstantComposite(Id result_type,
const std::vector<Ref>& constituents); const std::vector<Id>& constituents);
/// Returns a sampler constant. /// Returns a sampler constant.
Ref OpConstantSampler(Ref result_type, Id OpConstantSampler(Id result_type,
spv::SamplerAddressingMode addressing_mode, spv::SamplerAddressingMode addressing_mode,
bool normalized, spv::SamplerFilterMode filter_mode); bool normalized, spv::SamplerFilterMode filter_mode);
/// Returns a null constant value. /// Returns a null constant value.
Ref OpConstantNull(Ref result_type); Id OpConstantNull(Id result_type);
// Function // Function
/// Declares a function. /// Declares a function.
Ref OpFunction(Ref result_type, spv::FunctionControlMask function_control, Id OpFunction(Id result_type, spv::FunctionControlMask function_control,
Ref function_type); Id function_type);
/// Ends a function. /// Ends a function.
Ref OpFunctionEnd(); Id OpFunctionEnd();
// Flow // Flow
/// Declare a structured loop. /// Declare a structured loop.
Ref OpLoopMerge(Ref merge_block, Ref continue_target, Id OpLoopMerge(Id merge_block, Id continue_target,
spv::LoopControlMask loop_control, spv::LoopControlMask loop_control,
const std::vector<Ref>& literals = {}); const std::vector<Id>& literals = {});
/// Declare a structured selection. /// Declare a structured selection.
Ref OpSelectionMerge(Ref merge_block, Id OpSelectionMerge(Id merge_block,
spv::SelectionControlMask selection_control); spv::SelectionControlMask selection_control);
/// The block label instruction: Any reference to a block is through this /// The block label instruction: Any reference to a block is through this
/// ref. /// ref.
Ref OpLabel(); Id OpLabel();
/// Unconditional jump to label. /// Unconditional jump to label.
Ref OpBranch(Ref target_label); Id OpBranch(Id target_label);
/// If condition is true branch to true_label, otherwise branch to /// If condition is true branch to true_label, otherwise branch to
/// false_label. /// false_label.
Ref OpBranchConditional(Ref condition, Ref true_label, Ref false_label, Id OpBranchConditional(Id condition, Id true_label, Id false_label,
std::uint32_t true_weight = 0, std::uint32_t true_weight = 0,
std::uint32_t false_weight = 0); std::uint32_t false_weight = 0);
/// Returns with no value from a function with void return type. /// Returns with no value from a function with void return type.
Ref OpReturn(); Id OpReturn();
// Debug // Debug
/// Assign a name string to a reference. /// Assign a name string to a reference.
/// @return target /// @return target
Ref Name(Ref target, const std::string& name); Id Name(Id target, const std::string& name);
// Memory // Memory
/// Allocate an object in memory, resulting in a copy to it. /// Allocate an object in memory, resulting in a copy to it.
Ref OpVariable(Ref result_type, spv::StorageClass storage_class, Id OpVariable(Id result_type, spv::StorageClass storage_class,
Ref initializer = nullptr); Id initializer = nullptr);
/// Load through a pointer. /// Load through a pointer.
Ref OpLoad(Ref result_type, Ref pointer, Id OpLoad(Id result_type, Id pointer,
std::optional<spv::MemoryAccessMask> memory_access = {}); std::optional<spv::MemoryAccessMask> memory_access = {});
/// Store through a pointer. /// Store through a pointer.
Ref OpStore(Ref pointer, Ref object, Id OpStore(Id pointer, Id object,
std::optional<spv::MemoryAccessMask> memory_access = {}); std::optional<spv::MemoryAccessMask> memory_access = {});
/// Create a pointer into a composite object that can be used with OpLoad /// Create a pointer into a composite object that can be used with OpLoad
/// and OpStore. /// and OpStore.
Ref OpAccessChain(Ref result_type, Ref base, Id OpAccessChain(Id result_type, Id base,
const std::vector<Ref>& indexes = {}); const std::vector<Id>& indexes = {});
/// Make a copy of a composite object, while modifying one part of it. /// Make a copy of a composite object, while modifying one part of it.
Ref OpCompositeInsert(Ref result_type, Ref object, Ref composite, Id OpCompositeInsert(Id result_type, Id object, Id composite,
const std::vector<Literal>& indexes = {}); const std::vector<Literal>& indexes = {});
// Annotation // Annotation
/// Add a decoration to target. /// Add a decoration to target.
Ref Decorate(Ref target, spv::Decoration decoration, Id Decorate(Id target, spv::Decoration decoration,
const std::vector<Literal>& literals = {}); const std::vector<Literal>& literals = {});
Ref MemberDecorate(Ref structure_type, Literal member, Id MemberDecorate(Id structure_type, Literal member,
spv::Decoration decoration, spv::Decoration decoration,
const std::vector<Literal>& literals = {}); const std::vector<Literal>& literals = {});
// Misc // Misc
/// Make an intermediate object whose value is undefined. /// Make an intermediate object whose value is undefined.
Ref OpUndef(Ref result_type); Id OpUndef(Id result_type);
private: private:
Ref AddCode(Op* op); Id AddCode(Op* op);
Ref AddCode(spv::Op opcode, std::optional<std::uint32_t> id = {}); Id AddCode(spv::Op opcode, std::optional<std::uint32_t> id = {});
Ref AddDeclaration(Op* op); Id AddDeclaration(Op* op);
Ref AddAnnotation(Op* op); Id AddAnnotation(Op* op);
std::uint32_t bound{1}; std::uint32_t bound{1};
@ -262,9 +262,9 @@ class Module {
std::vector<std::unique_ptr<Op>> declarations; std::vector<std::unique_ptr<Op>> declarations;
std::vector<Ref> global_variables; std::vector<Id> global_variables;
std::vector<Ref> code; std::vector<Id> code;
std::vector<std::unique_ptr<Op>> code_store; std::vector<std::unique_ptr<Op>> code_store;
}; };

4
src/insts/annotation.cpp
View file

@ -9,7 +9,7 @@
namespace Sirit { namespace Sirit {
Ref Module::Decorate(Ref target, spv::Decoration decoration, Id Module::Decorate(Id target, spv::Decoration decoration,
const std::vector<Literal>& literals) { const std::vector<Literal>& literals) {
auto op{new Op(spv::Op::OpDecorate)}; auto op{new Op(spv::Op::OpDecorate)};
op->Add(target); op->Add(target);
@ -18,7 +18,7 @@ Ref Module::Decorate(Ref target, spv::Decoration decoration,
return AddAnnotation(op); return AddAnnotation(op);
} }
Ref Module::MemberDecorate(Ref structure_type, Literal member, Id Module::MemberDecorate(Id structure_type, Literal member,
spv::Decoration decoration, spv::Decoration decoration,
const std::vector<Literal>& literals) { const std::vector<Literal>& literals) {
auto op{new Op(spv::Op::OpMemberDecorate)}; auto op{new Op(spv::Op::OpMemberDecorate)};

14
src/insts/constant.cpp
View file

@ -10,28 +10,28 @@
namespace Sirit { namespace Sirit {
Ref Module::OpConstantTrue(Ref result_type) { Id Module::OpConstantTrue(Id result_type) {
return AddDeclaration(new Op(spv::Op::OpConstantTrue, bound, result_type)); return AddDeclaration(new Op(spv::Op::OpConstantTrue, bound, result_type));
} }
Ref Module::OpConstantFalse(Ref result_type) { Id Module::OpConstantFalse(Id result_type) {
return AddDeclaration(new Op(spv::Op::OpConstantFalse, bound, result_type)); return AddDeclaration(new Op(spv::Op::OpConstantFalse, bound, result_type));
} }
Ref Module::OpConstant(Ref result_type, const Literal& literal) { Id Module::OpConstant(Id result_type, const Literal& literal) {
auto op{new Op(spv::Op::OpConstant, bound, result_type)}; auto op{new Op(spv::Op::OpConstant, bound, result_type)};
op->Add(literal); op->Add(literal);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpConstantComposite(Ref result_type, Id Module::OpConstantComposite(Id result_type,
const std::vector<Ref>& constituents) { const std::vector<Id>& constituents) {
auto op{new Op(spv::Op::OpConstantComposite, bound, result_type)}; auto op{new Op(spv::Op::OpConstantComposite, bound, result_type)};
op->Add(constituents); op->Add(constituents);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpConstantSampler(Ref result_type, Id Module::OpConstantSampler(Id result_type,
spv::SamplerAddressingMode addressing_mode, spv::SamplerAddressingMode addressing_mode,
bool normalized, bool normalized,
spv::SamplerFilterMode filter_mode) { spv::SamplerFilterMode filter_mode) {
@ -44,7 +44,7 @@ Ref Module::OpConstantSampler(Ref result_type,
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpConstantNull(Ref result_type) { Id Module::OpConstantNull(Id result_type) {
return AddDeclaration(new Op(spv::Op::OpConstantNull, bound, result_type)); return AddDeclaration(new Op(spv::Op::OpConstantNull, bound, result_type));
} }

2
src/insts/debug.cpp
View file

@ -9,7 +9,7 @@
namespace Sirit { namespace Sirit {
Ref Module::Name(Ref target, const std::string& name) { Id Module::Name(Id target, const std::string& name) {
auto op{new Op(spv::Op::OpName)}; auto op{new Op(spv::Op::OpName)};
op->Add(target); op->Add(target);
op->Add(name); op->Add(name);

14
src/insts/flow.cpp
View file

@ -9,9 +9,9 @@
namespace Sirit { namespace Sirit {
Ref Module::OpLoopMerge(Ref merge_block, Ref continue_target, Id Module::OpLoopMerge(Id merge_block, Id continue_target,
spv::LoopControlMask loop_control, spv::LoopControlMask loop_control,
const std::vector<Ref>& literals) { const std::vector<Id>& literals) {
auto op{new Op(spv::Op::OpLoopMerge)}; auto op{new Op(spv::Op::OpLoopMerge)};
op->Add(merge_block); op->Add(merge_block);
op->Add(continue_target); op->Add(continue_target);
@ -20,7 +20,7 @@ Ref Module::OpLoopMerge(Ref merge_block, Ref continue_target,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpSelectionMerge(Ref merge_block, Id Module::OpSelectionMerge(Id merge_block,
spv::SelectionControlMask selection_control) { spv::SelectionControlMask selection_control) {
auto op{new Op(spv::Op::OpSelectionMerge)}; auto op{new Op(spv::Op::OpSelectionMerge)};
op->Add(merge_block); op->Add(merge_block);
@ -28,15 +28,15 @@ Ref Module::OpSelectionMerge(Ref merge_block,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpLabel() { return AddCode(spv::Op::OpLabel, bound++); } Id Module::OpLabel() { return AddCode(spv::Op::OpLabel, bound++); }
Ref Module::OpBranch(Ref target_label) { Id Module::OpBranch(Id target_label) {
auto op{new Op(spv::Op::OpBranch)}; auto op{new Op(spv::Op::OpBranch)};
op->Add(target_label); op->Add(target_label);
return AddCode(op); return AddCode(op);
} }
Ref Module::OpBranchConditional(Ref condition, Ref true_label, Ref false_label, Id Module::OpBranchConditional(Id condition, Id true_label, Id false_label,
std::uint32_t true_weight, std::uint32_t true_weight,
std::uint32_t false_weight) { std::uint32_t false_weight) {
auto op{new Op(spv::Op::OpBranchConditional)}; auto op{new Op(spv::Op::OpBranchConditional)};
@ -50,6 +50,6 @@ Ref Module::OpBranchConditional(Ref condition, Ref true_label, Ref false_label,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpReturn() { return AddCode(spv::Op::OpReturn); } Id Module::OpReturn() { return AddCode(spv::Op::OpReturn); }
} // namespace Sirit } // namespace Sirit

6
src/insts/function.cpp
View file

@ -9,15 +9,15 @@
namespace Sirit { namespace Sirit {
Ref Module::OpFunction(Ref result_type, Id Module::OpFunction(Id result_type,
spv::FunctionControlMask function_control, spv::FunctionControlMask function_control,
Ref function_type) { Id function_type) {
auto op{new Op{spv::Op::OpFunction, bound++, result_type}}; auto op{new Op{spv::Op::OpFunction, bound++, result_type}};
op->Add(static_cast<u32>(function_control)); op->Add(static_cast<u32>(function_control));
op->Add(function_type); op->Add(function_type);
return AddCode(op); return AddCode(op);
} }
Ref Module::OpFunctionEnd() { return AddCode(spv::Op::OpFunctionEnd); } Id Module::OpFunctionEnd() { return AddCode(spv::Op::OpFunctionEnd); }
} // namespace Sirit } // namespace Sirit

14
src/insts/memory.cpp
View file

@ -10,8 +10,8 @@
namespace Sirit { namespace Sirit {
Ref Module::OpVariable(Ref result_type, spv::StorageClass storage_class, Id Module::OpVariable(Id result_type, spv::StorageClass storage_class,
Ref initializer) { Id initializer) {
auto op{new Op(spv::Op::OpVariable, bound++, result_type)}; auto op{new Op(spv::Op::OpVariable, bound++, result_type)};
AddEnum(op, storage_class); AddEnum(op, storage_class);
if (initializer) { if (initializer) {
@ -20,7 +20,7 @@ Ref Module::OpVariable(Ref result_type, spv::StorageClass storage_class,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpLoad(Ref result_type, Ref pointer, Id Module::OpLoad(Id result_type, Id pointer,
std::optional<spv::MemoryAccessMask> memory_access) { std::optional<spv::MemoryAccessMask> memory_access) {
auto op{new Op(spv::Op::OpLoad, bound++, result_type)}; auto op{new Op(spv::Op::OpLoad, bound++, result_type)};
op->Add(pointer); op->Add(pointer);
@ -30,7 +30,7 @@ Ref Module::OpLoad(Ref result_type, Ref pointer,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpStore(Ref pointer, Ref object, Id Module::OpStore(Id pointer, Id object,
std::optional<spv::MemoryAccessMask> memory_access) { std::optional<spv::MemoryAccessMask> memory_access) {
auto op{new Op(spv::Op::OpStore)}; auto op{new Op(spv::Op::OpStore)};
op->Add(pointer); op->Add(pointer);
@ -41,8 +41,8 @@ Ref Module::OpStore(Ref pointer, Ref object,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpAccessChain(Ref result_type, Ref base, Id Module::OpAccessChain(Id result_type, Id base,
const std::vector<Ref>& indexes) { const std::vector<Id>& indexes) {
assert(indexes.size() > 0); assert(indexes.size() > 0);
auto op{new Op(spv::Op::OpAccessChain, bound++, result_type)}; auto op{new Op(spv::Op::OpAccessChain, bound++, result_type)};
op->Add(base); op->Add(base);
@ -50,7 +50,7 @@ Ref Module::OpAccessChain(Ref result_type, Ref base,
return AddCode(op); return AddCode(op);
} }
Ref Module::OpCompositeInsert(Ref result_type, Ref object, Ref composite, Id Module::OpCompositeInsert(Id result_type, Id object, Id composite,
const std::vector<Literal>& indexes) { const std::vector<Literal>& indexes) {
auto op{new Op(spv::Op::OpCompositeInsert, bound++, result_type)}; auto op{new Op(spv::Op::OpCompositeInsert, bound++, result_type)};
op->Add(object); op->Add(object);

2
src/insts/misc.cpp
View file

@ -10,7 +10,7 @@
namespace Sirit { namespace Sirit {
Ref Module::OpUndef(Ref result_type) { Id Module::OpUndef(Id result_type) {
return AddCode(new Op(spv::Op::OpUndef, bound++, result_type)); return AddCode(new Op(spv::Op::OpUndef, bound++, result_type));
} }

40
src/insts/type.cpp
View file

@ -12,15 +12,15 @@
namespace Sirit { namespace Sirit {
Ref Module::OpTypeVoid() { Id Module::OpTypeVoid() {
return AddDeclaration(new Op(spv::Op::OpTypeVoid, bound)); return AddDeclaration(new Op(spv::Op::OpTypeVoid, bound));
} }
Ref Module::OpTypeBool() { Id Module::OpTypeBool() {
return AddDeclaration(new Op(spv::Op::OpTypeBool, bound)); return AddDeclaration(new Op(spv::Op::OpTypeBool, bound));
} }
Ref Module::OpTypeInt(int width, bool is_signed) { Id Module::OpTypeInt(int width, bool is_signed) {
if (width == 8) { if (width == 8) {
AddCapability(spv::Capability::Int8); AddCapability(spv::Capability::Int8);
} else if (width == 16) { } else if (width == 16) {
@ -34,7 +34,7 @@ Ref Module::OpTypeInt(int width, bool is_signed) {
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeFloat(int width) { Id Module::OpTypeFloat(int width) {
if (width == 16) { if (width == 16) {
AddCapability(spv::Capability::Float16); AddCapability(spv::Capability::Float16);
} else if (width == 64) { } else if (width == 64) {
@ -45,7 +45,7 @@ Ref Module::OpTypeFloat(int width) {
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeVector(Ref component_type, int component_count) { Id Module::OpTypeVector(Id component_type, int component_count) {
assert(component_count >= 2); assert(component_count >= 2);
auto op{new Op(spv::Op::OpTypeVector, bound)}; auto op{new Op(spv::Op::OpTypeVector, bound)};
op->Add(component_type); op->Add(component_type);
@ -53,7 +53,7 @@ Ref Module::OpTypeVector(Ref component_type, int component_count) {
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeMatrix(Ref column_type, int column_count) { Id Module::OpTypeMatrix(Id column_type, int column_count) {
assert(column_count >= 2); assert(column_count >= 2);
AddCapability(spv::Capability::Matrix); AddCapability(spv::Capability::Matrix);
Op* op{new Op(spv::Op::OpTypeMatrix, bound)}; Op* op{new Op(spv::Op::OpTypeMatrix, bound)};
@ -62,7 +62,7 @@ Ref Module::OpTypeMatrix(Ref column_type, int column_count) {
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeImage(Ref sampled_type, spv::Dim dim, int depth, bool arrayed, Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed,
bool ms, int sampled, spv::ImageFormat image_format, bool ms, int sampled, spv::ImageFormat image_format,
std::optional<spv::AccessQualifier> access_qualifier) { std::optional<spv::AccessQualifier> access_qualifier) {
switch (dim) { switch (dim) {
@ -140,44 +140,44 @@ Ref Module::OpTypeImage(Ref sampled_type, spv::Dim dim, int depth, bool arrayed,
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeSampler() { Id Module::OpTypeSampler() {
return AddDeclaration(new Op(spv::Op::OpTypeSampler, bound)); return AddDeclaration(new Op(spv::Op::OpTypeSampler, bound));
} }
Ref Module::OpTypeSampledImage(Ref image_type) { Id Module::OpTypeSampledImage(Id image_type) {
auto op{new Op(spv::Op::OpTypeSampledImage, bound)}; auto op{new Op(spv::Op::OpTypeSampledImage, bound)};
op->Add(image_type); op->Add(image_type);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeArray(Ref element_type, Ref length) { Id Module::OpTypeArray(Id element_type, Id length) {
auto op{new Op(spv::Op::OpTypeArray, bound)}; auto op{new Op(spv::Op::OpTypeArray, bound)};
op->Add(element_type); op->Add(element_type);
op->Add(length); op->Add(length);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeRuntimeArray(Ref element_type) { Id Module::OpTypeRuntimeArray(Id element_type) {
AddCapability(spv::Capability::Shader); AddCapability(spv::Capability::Shader);
auto op{new Op(spv::Op::OpTypeRuntimeArray, bound)}; auto op{new Op(spv::Op::OpTypeRuntimeArray, bound)};
op->Add(element_type); op->Add(element_type);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeStruct(const std::vector<Ref>& members) { Id Module::OpTypeStruct(const std::vector<Id>& members) {
auto op{new Op(spv::Op::OpTypeStruct, bound)}; auto op{new Op(spv::Op::OpTypeStruct, bound)};
op->Add(members); op->Add(members);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeOpaque(const std::string& name) { Id Module::OpTypeOpaque(const std::string& name) {
AddCapability(spv::Capability::Kernel); AddCapability(spv::Capability::Kernel);
auto op{new Op(spv::Op::OpTypeOpaque, bound)}; auto op{new Op(spv::Op::OpTypeOpaque, bound)};
op->Add(name); op->Add(name);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypePointer(spv::StorageClass storage_class, Ref type) { Id Module::OpTypePointer(spv::StorageClass storage_class, Id type) {
switch (storage_class) { switch (storage_class) {
case spv::StorageClass::Uniform: case spv::StorageClass::Uniform:
case spv::StorageClass::Output: case spv::StorageClass::Output:
@ -199,34 +199,34 @@ Ref Module::OpTypePointer(spv::StorageClass storage_class, Ref type) {
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeFunction(Ref return_type, const std::vector<Ref>& arguments) { Id Module::OpTypeFunction(Id return_type, const std::vector<Id>& arguments) {
auto op{new Op(spv::Op::OpTypeFunction, bound)}; auto op{new Op(spv::Op::OpTypeFunction, bound)};
op->Add(return_type); op->Add(return_type);
op->Add(arguments); op->Add(arguments);
return AddDeclaration(op); return AddDeclaration(op);
} }
Ref Module::OpTypeEvent() { Id Module::OpTypeEvent() {
AddCapability(spv::Capability::Kernel); AddCapability(spv::Capability::Kernel);
return AddDeclaration(new Op(spv::Op::OpTypeEvent, bound)); return AddDeclaration(new Op(spv::Op::OpTypeEvent, bound));
} }
Ref Module::OpTypeDeviceEvent() { Id Module::OpTypeDeviceEvent() {
AddCapability(spv::Capability::DeviceEnqueue); AddCapability(spv::Capability::DeviceEnqueue);
return AddDeclaration(new Op(spv::Op::OpTypeDeviceEvent, bound)); return AddDeclaration(new Op(spv::Op::OpTypeDeviceEvent, bound));
} }
Ref Module::OpTypeReserveId() { Id Module::OpTypeReserveId() {
AddCapability(spv::Capability::Pipes); AddCapability(spv::Capability::Pipes);
return AddDeclaration(new Op(spv::Op::OpTypeReserveId, bound)); return AddDeclaration(new Op(spv::Op::OpTypeReserveId, bound));
} }
Ref Module::OpTypeQueue() { Id Module::OpTypeQueue() {
AddCapability(spv::Capability::DeviceEnqueue); AddCapability(spv::Capability::DeviceEnqueue);
return AddDeclaration(new Op(spv::Op::OpTypeQueue, bound)); return AddDeclaration(new Op(spv::Op::OpTypeQueue, bound));
} }
Ref Module::OpTypePipe(spv::AccessQualifier access_qualifier) { Id Module::OpTypePipe(spv::AccessQualifier access_qualifier) {
AddCapability(spv::Capability::Pipes); AddCapability(spv::Capability::Pipes);
auto op{new Op(spv::Op::OpTypePipe, bound)}; auto op{new Op(spv::Op::OpTypePipe, bound)};
op->Add(static_cast<u32>(access_qualifier)); op->Add(static_cast<u32>(access_qualifier));

6
src/op.cpp
View file

@ -14,7 +14,7 @@
namespace Sirit { namespace Sirit {
Op::Op(spv::Op opcode, std::optional<u32> id, Ref result_type) Op::Op(spv::Op opcode, std::optional<u32> id, Id result_type)
: opcode(opcode), id(id), result_type(result_type) { : opcode(opcode), id(id), result_type(result_type) {
operand_type = OperandType::Op; operand_type = OperandType::Op;
} }
@ -106,8 +106,8 @@ void Op::Add(u32 integer) { Sink(LiteralNumber::Create<u32>(integer)); }
void Op::Add(const std::string& string) { Sink(new LiteralString(string)); } void Op::Add(const std::string& string) { Sink(new LiteralString(string)); }
void Op::Add(const std::vector<Ref>& ids) { void Op::Add(const std::vector<Id>& ids) {
for (Ref op : ids) { for (Id op : ids) {
Add(op); Add(op);
} }
} }

6
src/op.h
View file

@ -17,7 +17,7 @@ namespace Sirit {
class Op : public Operand { class Op : public Operand {
public: public:
explicit Op(spv::Op opcode, std::optional<u32> id = {}, explicit Op(spv::Op opcode, std::optional<u32> id = {},
Ref result_type = nullptr); Id result_type = nullptr);
~Op(); ~Op();
virtual void Fetch(Stream& stream) const; virtual void Fetch(Stream& stream) const;
@ -41,14 +41,14 @@ class Op : public Operand {
void Add(const std::string& string); void Add(const std::string& string);
void Add(const std::vector<Ref>& ids); void Add(const std::vector<Id>& ids);
private: private:
u16 WordCount() const; u16 WordCount() const;
spv::Op opcode; spv::Op opcode;
Ref result_type; Id result_type;
std::optional<u32> id; std::optional<u32> id;

16
src/sirit.cpp
View file

@ -72,9 +72,9 @@ void Module::SetMemoryModel(spv::AddressingModel addressing_model,
this->memory_model = memory_model; this->memory_model = memory_model;
} }
void Module::AddEntryPoint(spv::ExecutionModel execution_model, Ref entry_point, void Module::AddEntryPoint(spv::ExecutionModel execution_model, Id entry_point,
const std::string& name, const std::string& name,
const std::vector<Ref>& interfaces) { const std::vector<Id>& interfaces) {
auto const op{new Op(spv::Op::OpEntryPoint)}; auto const op{new Op(spv::Op::OpEntryPoint)};
op->Add(static_cast<u32>(execution_model)); op->Add(static_cast<u32>(execution_model));
op->Add(entry_point); op->Add(entry_point);
@ -83,29 +83,29 @@ void Module::AddEntryPoint(spv::ExecutionModel execution_model, Ref entry_point,
entry_points.push_back(std::unique_ptr<Op>(op)); entry_points.push_back(std::unique_ptr<Op>(op));
} }
Ref Module::Emit(Ref op) { Id Module::Emit(Id op) {
assert(op); assert(op);
code.push_back(op); code.push_back(op);
return op; return op;
} }
Ref Module::AddGlobalVariable(Ref variable) { Id Module::AddGlobalVariable(Id variable) {
assert(variable); assert(variable);
global_variables.push_back(variable); global_variables.push_back(variable);
return variable; return variable;
} }
Ref Module::AddCode(Op* op) { Id Module::AddCode(Op* op) {
assert(op); assert(op);
code_store.push_back(std::unique_ptr<Op>(op)); code_store.push_back(std::unique_ptr<Op>(op));
return op; return op;
} }
Ref Module::AddCode(spv::Op opcode, std::optional<u32> id) { Id Module::AddCode(spv::Op opcode, std::optional<u32> id) {
return AddCode(new Op(opcode, id)); return AddCode(new Op(opcode, id));
} }
Ref Module::AddDeclaration(Op* op) { Id Module::AddDeclaration(Op* op) {
const auto& found{ const auto& found{
std::find_if(declarations.begin(), declarations.end(), std::find_if(declarations.begin(), declarations.end(),
[&op](const auto& other) { return *other == *op; })}; [&op](const auto& other) { return *other == *op; })};
@ -119,7 +119,7 @@ Ref Module::AddDeclaration(Op* op) {
} }
} }
Ref Module::AddAnnotation(Op* op) { Id Module::AddAnnotation(Op* op) {
assert(op); assert(op);
annotations.push_back(std::unique_ptr<Op>(op)); annotations.push_back(std::unique_ptr<Op>(op));
return op; return op;