1 // Copyright (c) 2016 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "spirv-tools/libspirv.hpp"
16
17 #include <cassert>
18 #include <iostream>
19 #include <string>
20 #include <utility>
21 #include <vector>
22
23 #include "source/table.h"
24
25 namespace spvtools {
26
Context(spv_target_env env)27 Context::Context(spv_target_env env) : context_(spvContextCreate(env)) {}
28
Context(Context && other)29 Context::Context(Context&& other) : context_(other.context_) {
30 other.context_ = nullptr;
31 }
32
operator =(Context && other)33 Context& Context::operator=(Context&& other) {
34 spvContextDestroy(context_);
35 context_ = other.context_;
36 other.context_ = nullptr;
37
38 return *this;
39 }
40
~Context()41 Context::~Context() { spvContextDestroy(context_); }
42
SetMessageConsumer(MessageConsumer consumer)43 void Context::SetMessageConsumer(MessageConsumer consumer) {
44 SetContextMessageConsumer(context_, std::move(consumer));
45 }
46
CContext()47 spv_context& Context::CContext() { return context_; }
48
CContext() const49 const spv_context& Context::CContext() const { return context_; }
50
51 // Structs for holding the data members for SpvTools.
52 struct SpirvTools::Impl {
Implspvtools::SpirvTools::Impl53 explicit Impl(spv_target_env env) : context(spvContextCreate(env)) {
54 // The default consumer in spv_context_t is a null consumer, which provides
55 // equivalent functionality (from the user's perspective) as a real consumer
56 // does nothing.
57 }
~Implspvtools::SpirvTools::Impl58 ~Impl() { spvContextDestroy(context); }
59
60 spv_context context; // C interface context object.
61 };
62
SpirvTools(spv_target_env env)63 SpirvTools::SpirvTools(spv_target_env env) : impl_(new Impl(env)) {
64 assert(env != SPV_ENV_WEBGPU_0);
65 }
66
~SpirvTools()67 SpirvTools::~SpirvTools() {}
68
SetMessageConsumer(MessageConsumer consumer)69 void SpirvTools::SetMessageConsumer(MessageConsumer consumer) {
70 SetContextMessageConsumer(impl_->context, std::move(consumer));
71 }
72
Assemble(const std::string & text,std::vector<uint32_t> * binary,uint32_t options) const73 bool SpirvTools::Assemble(const std::string& text,
74 std::vector<uint32_t>* binary,
75 uint32_t options) const {
76 return Assemble(text.data(), text.size(), binary, options);
77 }
78
Assemble(const char * text,const size_t text_size,std::vector<uint32_t> * binary,uint32_t options) const79 bool SpirvTools::Assemble(const char* text, const size_t text_size,
80 std::vector<uint32_t>* binary,
81 uint32_t options) const {
82 spv_binary spvbinary = nullptr;
83 spv_result_t status = spvTextToBinaryWithOptions(
84 impl_->context, text, text_size, options, &spvbinary, nullptr);
85 if (status == SPV_SUCCESS) {
86 binary->assign(spvbinary->code, spvbinary->code + spvbinary->wordCount);
87 }
88 spvBinaryDestroy(spvbinary);
89 return status == SPV_SUCCESS;
90 }
91
Disassemble(const std::vector<uint32_t> & binary,std::string * text,uint32_t options) const92 bool SpirvTools::Disassemble(const std::vector<uint32_t>& binary,
93 std::string* text, uint32_t options) const {
94 return Disassemble(binary.data(), binary.size(), text, options);
95 }
96
Disassemble(const uint32_t * binary,const size_t binary_size,std::string * text,uint32_t options) const97 bool SpirvTools::Disassemble(const uint32_t* binary, const size_t binary_size,
98 std::string* text, uint32_t options) const {
99 spv_text spvtext = nullptr;
100 spv_result_t status = spvBinaryToText(impl_->context, binary, binary_size,
101 options, &spvtext, nullptr);
102 if (status == SPV_SUCCESS &&
103 (options & SPV_BINARY_TO_TEXT_OPTION_PRINT) == 0) {
104 assert(spvtext);
105 text->assign(spvtext->str, spvtext->str + spvtext->length);
106 }
107 spvTextDestroy(spvtext);
108 return status == SPV_SUCCESS;
109 }
110
Validate(const std::vector<uint32_t> & binary) const111 bool SpirvTools::Validate(const std::vector<uint32_t>& binary) const {
112 return Validate(binary.data(), binary.size());
113 }
114
Validate(const uint32_t * binary,const size_t binary_size) const115 bool SpirvTools::Validate(const uint32_t* binary,
116 const size_t binary_size) const {
117 return spvValidateBinary(impl_->context, binary, binary_size, nullptr) ==
118 SPV_SUCCESS;
119 }
120
Validate(const uint32_t * binary,const size_t binary_size,spv_validator_options options) const121 bool SpirvTools::Validate(const uint32_t* binary, const size_t binary_size,
122 spv_validator_options options) const {
123 spv_const_binary_t the_binary{binary, binary_size};
124 spv_diagnostic diagnostic = nullptr;
125 bool valid = spvValidateWithOptions(impl_->context, options, &the_binary,
126 &diagnostic) == SPV_SUCCESS;
127 if (!valid && impl_->context->consumer) {
128 impl_->context->consumer.operator()(
129 SPV_MSG_ERROR, nullptr, diagnostic->position, diagnostic->error);
130 }
131 spvDiagnosticDestroy(diagnostic);
132 return valid;
133 }
134
IsValid() const135 bool SpirvTools::IsValid() const { return impl_->context != nullptr; }
136
137 } // namespace spvtools
138