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
25namespace spvtools {
26
27Context::Context(spv_target_env env) : context_(spvContextCreate(env)) {}
28
29Context::Context(Context&& other) : context_(other.context_) {
30 other.context_ = nullptr;
31}
32
33Context& Context::operator=(Context&& other) {
34 spvContextDestroy(context_);
35 context_ = other.context_;
36 other.context_ = nullptr;
37
38 return *this;
39}
40
41Context::~Context() { spvContextDestroy(context_); }
42
43void Context::SetMessageConsumer(MessageConsumer consumer) {
44 SetContextMessageConsumer(context_, std::move(consumer));
45}
46
47spv_context& Context::CContext() { return context_; }
48
49const spv_context& Context::CContext() const { return context_; }
50
51// Structs for holding the data members for SpvTools.
52struct SpirvTools::Impl {
53 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 }
58 ~Impl() { spvContextDestroy(context); }
59
60 spv_context context; // C interface context object.
61};
62
63SpirvTools::SpirvTools(spv_target_env env) : impl_(new Impl(env)) {
64 assert(env != SPV_ENV_WEBGPU_0);
65}
66
67SpirvTools::~SpirvTools() {}
68
69void SpirvTools::SetMessageConsumer(MessageConsumer consumer) {
70 SetContextMessageConsumer(impl_->context, std::move(consumer));
71}
72
73bool 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
79bool 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
92bool 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
97bool 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
111bool SpirvTools::Validate(const std::vector<uint32_t>& binary) const {
112 return Validate(binary.data(), binary.size());
113}
114
115bool 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
121bool 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
135bool SpirvTools::IsValid() const { return impl_->context != nullptr; }
136
137} // namespace spvtools
138