mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-10-18 11:10:05 +00:00
9fc8658ef3
Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
102 lines
3.2 KiB
C++
102 lines
3.2 KiB
C++
// Copyright (c) 2016 Google Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "libspirv.hpp"
|
|
|
|
#include "ir_loader.h"
|
|
#include "make_unique.h"
|
|
|
|
namespace spvtools {
|
|
|
|
namespace {
|
|
|
|
// Sets the module header. Meets the interface requirement of spvBinaryParse().
|
|
spv_result_t SetSpvHeader(void* builder, spv_endianness_t, uint32_t magic,
|
|
uint32_t version, uint32_t generator,
|
|
uint32_t id_bound, uint32_t reserved) {
|
|
reinterpret_cast<ir::IrLoader*>(builder)
|
|
->SetModuleHeader(magic, version, generator, id_bound, reserved);
|
|
return SPV_SUCCESS;
|
|
};
|
|
|
|
// Processes a parsed instruction. Meets the interface requirement of
|
|
// spvBinaryParse().
|
|
spv_result_t SetSpvInst(void* builder, const spv_parsed_instruction_t* inst) {
|
|
reinterpret_cast<ir::IrLoader*>(builder)->AddInstruction(inst);
|
|
return SPV_SUCCESS;
|
|
};
|
|
|
|
} // annoymous namespace
|
|
|
|
spv_result_t SpvTools::Assemble(const std::string& text,
|
|
std::vector<uint32_t>* binary) {
|
|
spv_binary spvbinary = nullptr;
|
|
spv_diagnostic diagnostic = nullptr;
|
|
|
|
spv_result_t status = spvTextToBinary(context_, text.data(), text.size(),
|
|
&spvbinary, &diagnostic);
|
|
if (status == SPV_SUCCESS) {
|
|
binary->assign(spvbinary->code, spvbinary->code + spvbinary->wordCount);
|
|
}
|
|
|
|
spvDiagnosticDestroy(diagnostic);
|
|
spvBinaryDestroy(spvbinary);
|
|
|
|
return status;
|
|
}
|
|
|
|
spv_result_t SpvTools::Disassemble(const std::vector<uint32_t>& binary,
|
|
std::string* text, uint32_t options) {
|
|
spv_text spvtext = nullptr;
|
|
spv_diagnostic diagnostic = nullptr;
|
|
|
|
spv_result_t status = spvBinaryToText(context_, binary.data(), binary.size(),
|
|
options, &spvtext, &diagnostic);
|
|
if (status == SPV_SUCCESS) {
|
|
text->assign(spvtext->str, spvtext->str + spvtext->length);
|
|
}
|
|
|
|
spvDiagnosticDestroy(diagnostic);
|
|
spvTextDestroy(spvtext);
|
|
|
|
return status;
|
|
}
|
|
|
|
std::unique_ptr<ir::Module> SpvTools::BuildModule(
|
|
const std::vector<uint32_t>& binary) {
|
|
spv_diagnostic diagnostic = nullptr;
|
|
|
|
auto module = MakeUnique<ir::Module>();
|
|
ir::IrLoader loader(module.get());
|
|
|
|
spv_result_t status =
|
|
spvBinaryParse(context_, &loader, binary.data(), binary.size(),
|
|
SetSpvHeader, SetSpvInst, &diagnostic);
|
|
|
|
spvDiagnosticDestroy(diagnostic);
|
|
|
|
loader.EndModule();
|
|
|
|
if (status == SPV_SUCCESS) return module;
|
|
return nullptr;
|
|
}
|
|
|
|
std::unique_ptr<ir::Module> SpvTools::BuildModule(const std::string& text) {
|
|
std::vector<uint32_t> binary;
|
|
if (Assemble(text, &binary) != SPV_SUCCESS) return nullptr;
|
|
return BuildModule(binary);
|
|
}
|
|
|
|
} // namespace spvtools
|