blob: f3aa259431dcd6cc79cb9cbca70683625ebc95c8 [file] [log] [blame]
// Copyright (c) 2015-2016 The Khronos Group 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 "source/diagnostic.h"
#include <cassert>
#include <cstring>
#include <iostream>
#include <sstream>
#include <utility>
#include "source/table.h"
// Diagnostic API
spv_diagnostic spvDiagnosticCreate(const spv_position position,
const char* message) {
spv_diagnostic diagnostic = new spv_diagnostic_t;
if (!diagnostic) return nullptr;
size_t length = strlen(message) + 1;
diagnostic->error = new char[length];
if (!diagnostic->error) {
delete diagnostic;
return nullptr;
}
diagnostic->position = *position;
diagnostic->isTextSource = false;
memset(diagnostic->error, 0, length);
strcpy(diagnostic->error, message);
return diagnostic;
}
void spvDiagnosticDestroy(spv_diagnostic diagnostic) {
if (!diagnostic) return;
delete[] diagnostic->error;
delete diagnostic;
}
spv_result_t spvDiagnosticPrint(const spv_diagnostic diagnostic) {
if (!diagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC;
if (diagnostic->isTextSource) {
// NOTE: This is a text position
// NOTE: add 1 to the line as editors start at line 1, we are counting new
// line characters to start at line 0
std::cerr << "error: " << diagnostic->position.line + 1 << ": "
<< diagnostic->position.column + 1 << ": " << diagnostic->error
<< "\n";
return SPV_SUCCESS;
}
// NOTE: Assume this is a binary position
std::cerr << "error: ";
if (diagnostic->position.index > 0)
std::cerr << diagnostic->position.index << ": ";
std::cerr << diagnostic->error << "\n";
return SPV_SUCCESS;
}
namespace spvtools {
DiagnosticStream::DiagnosticStream(DiagnosticStream&& other)
: stream_(),
position_(other.position_),
consumer_(other.consumer_),
disassembled_instruction_(std::move(other.disassembled_instruction_)),
error_(other.error_) {
// Prevent the other object from emitting output during destruction.
other.error_ = SPV_FAILED_MATCH;
// Some platforms are missing support for std::ostringstream functionality,
// including: move constructor, swap method. Either would have been a
// better choice than copying the string.
stream_ << other.stream_.str();
}
DiagnosticStream::~DiagnosticStream() {
if (error_ != SPV_FAILED_MATCH && consumer_ != nullptr) {
auto level = SPV_MSG_ERROR;
switch (error_) {
case SPV_SUCCESS:
case SPV_REQUESTED_TERMINATION: // Essentially success.
level = SPV_MSG_INFO;
break;
case SPV_WARNING:
level = SPV_MSG_WARNING;
break;
case SPV_UNSUPPORTED:
case SPV_ERROR_INTERNAL:
case SPV_ERROR_INVALID_TABLE:
level = SPV_MSG_INTERNAL_ERROR;
break;
case SPV_ERROR_OUT_OF_MEMORY:
level = SPV_MSG_FATAL;
break;
default:
break;
}
if (disassembled_instruction_.size() > 0)
stream_ << std::endl << " " << disassembled_instruction_ << std::endl;
consumer_(level, "input", position_, stream_.str().c_str());
}
}
void UseDiagnosticAsMessageConsumer(spv_context context,
spv_diagnostic* diagnostic) {
assert(diagnostic && *diagnostic == nullptr);
auto create_diagnostic = [diagnostic](spv_message_level_t, const char*,
const spv_position_t& position,
const char* message) {
auto p = position;
spvDiagnosticDestroy(*diagnostic); // Avoid memory leak.
*diagnostic = spvDiagnosticCreate(&p, message);
};
SetContextMessageConsumer(context, std::move(create_diagnostic));
}
std::string spvResultToString(spv_result_t res) {
std::string out;
switch (res) {
case SPV_SUCCESS:
out = "SPV_SUCCESS";
break;
case SPV_UNSUPPORTED:
out = "SPV_UNSUPPORTED";
break;
case SPV_END_OF_STREAM:
out = "SPV_END_OF_STREAM";
break;
case SPV_WARNING:
out = "SPV_WARNING";
break;
case SPV_FAILED_MATCH:
out = "SPV_FAILED_MATCH";
break;
case SPV_REQUESTED_TERMINATION:
out = "SPV_REQUESTED_TERMINATION";
break;
case SPV_ERROR_INTERNAL:
out = "SPV_ERROR_INTERNAL";
break;
case SPV_ERROR_OUT_OF_MEMORY:
out = "SPV_ERROR_OUT_OF_MEMORY";
break;
case SPV_ERROR_INVALID_POINTER:
out = "SPV_ERROR_INVALID_POINTER";
break;
case SPV_ERROR_INVALID_BINARY:
out = "SPV_ERROR_INVALID_BINARY";
break;
case SPV_ERROR_INVALID_TEXT:
out = "SPV_ERROR_INVALID_TEXT";
break;
case SPV_ERROR_INVALID_TABLE:
out = "SPV_ERROR_INVALID_TABLE";
break;
case SPV_ERROR_INVALID_VALUE:
out = "SPV_ERROR_INVALID_VALUE";
break;
case SPV_ERROR_INVALID_DIAGNOSTIC:
out = "SPV_ERROR_INVALID_DIAGNOSTIC";
break;
case SPV_ERROR_INVALID_LOOKUP:
out = "SPV_ERROR_INVALID_LOOKUP";
break;
case SPV_ERROR_INVALID_ID:
out = "SPV_ERROR_INVALID_ID";
break;
case SPV_ERROR_INVALID_CFG:
out = "SPV_ERROR_INVALID_CFG";
break;
case SPV_ERROR_INVALID_LAYOUT:
out = "SPV_ERROR_INVALID_LAYOUT";
break;
default:
out = "Unknown Error";
}
return out;
}
} // namespace spvtools