From 1c06f8530e3e682cbff4b377b4636c53217565ae Mon Sep 17 00:00:00 2001 From: ReinUsesLisp Date: Wed, 13 Mar 2019 18:32:38 -0300 Subject: [PATCH] Remove Op prefix on Type instructions --- README.md | 2 +- include/sirit/sirit.h | 50 +++++++++++++++++++-------------------- src/instructions/type.cpp | 44 +++++++++++++++++----------------- 3 files changed, 48 insertions(+), 48 deletions(-) diff --git a/README.md b/README.md index 8fa51ee..7034547 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ public: AddCapability(spv::Capability::Shader); SetMemoryModel(spv::AddressingModel::Logical, spv::MemoryModel::GLSL450); - auto main_type{OpTypeFunction(TypeVoid())}; + auto main_type{TypeFunction(TypeVoid())}; auto main_func{Emit(OpFunction(TypeVoid(), spv::FunctionControlMask::MaskNone, main_type))}; Emit(OpLabel()); Emit(OpReturn()); diff --git a/include/sirit/sirit.h b/include/sirit/sirit.h index fb26d80..a4d3ce2 100644 --- a/include/sirit/sirit.h +++ b/include/sirit/sirit.h @@ -87,78 +87,78 @@ public: // Types /// Returns type void. - Id OpTypeVoid(); + Id TypeVoid(); /// Returns type bool. - Id OpTypeBool(); + Id TypeBool(); /// Returns type integer. - Id OpTypeInt(int width, bool is_signed); + Id TypeInt(int width, bool is_signed); /// Returns type float. - Id OpTypeFloat(int width); + Id TypeFloat(int width); /// Returns type vector. - Id OpTypeVector(Id component_type, int component_count); + Id TypeVector(Id component_type, int component_count); /// Returns type matrix. - Id OpTypeMatrix(Id column_type, int column_count); + Id TypeMatrix(Id column_type, int column_count); /// Returns type image. - Id OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed, bool ms, int sampled, - spv::ImageFormat image_format, - std::optional access_qualifier = {}); + Id TypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed, bool ms, int sampled, + spv::ImageFormat image_format, + std::optional access_qualifier = {}); /// Returns type sampler. - Id OpTypeSampler(); + Id TypeSampler(); /// Returns type sampled image. - Id OpTypeSampledImage(Id image_type); + Id TypeSampledImage(Id image_type); /// Returns type array. - Id OpTypeArray(Id element_type, Id length); + Id TypeArray(Id element_type, Id length); /// Returns type runtime array. - Id OpTypeRuntimeArray(Id element_type); + Id TypeRuntimeArray(Id element_type); /// Returns type struct. - Id OpTypeStruct(const std::vector& members = {}); + Id TypeStruct(const std::vector& members = {}); /// Returns type struct. template - Id OpTypeStruct(Ts&&... members) { - return OpTypeStruct({members...}); + Id TypeStruct(Ts&&... members) { + return TypeStruct({members...}); } /// Returns type opaque. - Id OpTypeOpaque(const std::string& name); + Id TypeOpaque(const std::string& name); /// Returns type pointer. - Id OpTypePointer(spv::StorageClass storage_class, Id type); + Id TypePointer(spv::StorageClass storage_class, Id type); /// Returns type function. - Id OpTypeFunction(Id return_type, const std::vector& arguments = {}); + Id TypeFunction(Id return_type, const std::vector& arguments = {}); /// Returns type function. template - Id OpTypeFunction(Id return_type, Ts&&... arguments) { + Id TypeFunction(Id return_type, Ts&&... arguments) { return OpTypeFunction(return_type, {arguments...}); } /// Returns type event. - Id OpTypeEvent(); + Id TypeEvent(); /// Returns type device event. - Id OpTypeDeviceEvent(); + Id TypeDeviceEvent(); /// Returns type reserve id. - Id OpTypeReserveId(); + Id TypeReserveId(); /// Returns type queue. - Id OpTypeQueue(); + Id TypeQueue(); /// Returns type pipe. - Id OpTypePipe(spv::AccessQualifier access_qualifier); + Id TypePipe(spv::AccessQualifier access_qualifier); // Constant diff --git a/src/instructions/type.cpp b/src/instructions/type.cpp index 3e9dab9..764c331 100644 --- a/src/instructions/type.cpp +++ b/src/instructions/type.cpp @@ -13,28 +13,28 @@ namespace Sirit { -Id Module::OpTypeVoid() { +Id Module::TypeVoid() { return AddDeclaration(std::make_unique(spv::Op::OpTypeVoid, bound)); } -Id Module::OpTypeBool() { +Id Module::TypeBool() { return AddDeclaration(std::make_unique(spv::Op::OpTypeBool, bound)); } -Id Module::OpTypeInt(int width, bool is_signed) { +Id Module::TypeInt(int width, bool is_signed) { auto op{std::make_unique(spv::Op::OpTypeInt, bound)}; op->Add(width); op->Add(is_signed ? 1 : 0); return AddDeclaration(std::move(op)); } -Id Module::OpTypeFloat(int width) { +Id Module::TypeFloat(int width) { auto op{std::make_unique(spv::Op::OpTypeFloat, bound)}; op->Add(width); return AddDeclaration(std::move(op)); } -Id Module::OpTypeVector(Id component_type, int component_count) { +Id Module::TypeVector(Id component_type, int component_count) { assert(component_count >= 2); auto op{std::make_unique(spv::Op::OpTypeVector, bound)}; op->Add(component_type); @@ -42,7 +42,7 @@ Id Module::OpTypeVector(Id component_type, int component_count) { return AddDeclaration(std::move(op)); } -Id Module::OpTypeMatrix(Id column_type, int column_count) { +Id Module::TypeMatrix(Id column_type, int column_count) { assert(column_count >= 2); auto op{std::make_unique(spv::Op::OpTypeMatrix, bound)}; op->Add(column_type); @@ -50,9 +50,9 @@ Id Module::OpTypeMatrix(Id column_type, int column_count) { return AddDeclaration(std::move(op)); } -Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed, bool ms, int sampled, - spv::ImageFormat image_format, - std::optional access_qualifier) { +Id Module::TypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed, bool ms, int sampled, + spv::ImageFormat image_format, + std::optional access_qualifier) { auto op{std::make_unique(spv::Op::OpTypeImage, bound)}; op->Add(sampled_type); op->Add(static_cast(dim)); @@ -67,72 +67,72 @@ Id Module::OpTypeImage(Id sampled_type, spv::Dim dim, int depth, bool arrayed, b return AddDeclaration(std::move(op)); } -Id Module::OpTypeSampler() { +Id Module::TypeSampler() { return AddDeclaration(std::make_unique(spv::Op::OpTypeSampler, bound)); } -Id Module::OpTypeSampledImage(Id image_type) { +Id Module::TypeSampledImage(Id image_type) { auto op{std::make_unique(spv::Op::OpTypeSampledImage, bound)}; op->Add(image_type); return AddDeclaration(std::move(op)); } -Id Module::OpTypeArray(Id element_type, Id length) { +Id Module::TypeArray(Id element_type, Id length) { auto op{std::make_unique(spv::Op::OpTypeArray, bound)}; op->Add(element_type); op->Add(length); return AddDeclaration(std::move(op)); } -Id Module::OpTypeRuntimeArray(Id element_type) { +Id Module::TypeRuntimeArray(Id element_type) { auto op{std::make_unique(spv::Op::OpTypeRuntimeArray, bound)}; op->Add(element_type); return AddDeclaration(std::move(op)); } -Id Module::OpTypeStruct(const std::vector& members) { +Id Module::TypeStruct(const std::vector& members) { auto op{std::make_unique(spv::Op::OpTypeStruct, bound)}; op->Add(members); return AddDeclaration(std::move(op)); } -Id Module::OpTypeOpaque(const std::string& name) { +Id Module::TypeOpaque(const std::string& name) { auto op{std::make_unique(spv::Op::OpTypeOpaque, bound)}; op->Add(name); return AddDeclaration(std::move(op)); } -Id Module::OpTypePointer(spv::StorageClass storage_class, Id type) { +Id Module::TypePointer(spv::StorageClass storage_class, Id type) { auto op{std::make_unique(spv::Op::OpTypePointer, bound)}; op->Add(static_cast(storage_class)); op->Add(type); return AddDeclaration(std::move(op)); } -Id Module::OpTypeFunction(Id return_type, const std::vector& arguments) { +Id Module::TypeFunction(Id return_type, const std::vector& arguments) { auto op{std::make_unique(spv::Op::OpTypeFunction, bound)}; op->Add(return_type); op->Add(arguments); return AddDeclaration(std::move(op)); } -Id Module::OpTypeEvent() { +Id Module::TypeEvent() { return AddDeclaration(std::make_unique(spv::Op::OpTypeEvent, bound)); } -Id Module::OpTypeDeviceEvent() { +Id Module::TypeDeviceEvent() { return AddDeclaration(std::make_unique(spv::Op::OpTypeDeviceEvent, bound)); } -Id Module::OpTypeReserveId() { +Id Module::TypeReserveId() { return AddDeclaration(std::make_unique(spv::Op::OpTypeReserveId, bound)); } -Id Module::OpTypeQueue() { +Id Module::TypeQueue() { return AddDeclaration(std::make_unique(spv::Op::OpTypeQueue, bound)); } -Id Module::OpTypePipe(spv::AccessQualifier access_qualifier) { +Id Module::TypePipe(spv::AccessQualifier access_qualifier) { auto op{std::make_unique(spv::Op::OpTypePipe, bound)}; op->Add(static_cast(access_qualifier)); return AddDeclaration(std::move(op));