SPIRV-Tools/source/opt/ir_loader.cpp
Lei Zhang 114af21994 Add MessageConsumer to PassManager, Pass, and analysis interfaces.
Also convert some uses of assert() in optimization code to use
SPIRV_ASSERT(), SPIRV_UNIMPLEMENTED(), or SPIRV_UNREACHABLE()
accordingly.
2016-09-16 13:14:57 -04:00

119 lines
4.4 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 "ir_loader.h"
#include "log.h"
#include "reflect.h"
namespace spvtools {
namespace ir {
void IrLoader::AddInstruction(const spv_parsed_instruction_t* inst) {
const auto opcode = static_cast<SpvOp>(inst->opcode);
if (IsDebugLineInst(opcode)) {
dbg_line_info_.push_back(Instruction(*inst));
return;
}
std::unique_ptr<Instruction> spv_inst(
new Instruction(*inst, std::move(dbg_line_info_)));
dbg_line_info_.clear();
// Handle function and basic block boundaries first, then normal
// instructions.
if (opcode == SpvOpFunction) {
SPIRV_ASSERT(consumer_, function_ == nullptr);
SPIRV_ASSERT(consumer_, block_ == nullptr);
function_.reset(new Function(std::move(spv_inst)));
} else if (opcode == SpvOpFunctionEnd) {
SPIRV_ASSERT(consumer_, function_ != nullptr);
SPIRV_ASSERT(consumer_, block_ == nullptr);
function_->SetFunctionEnd(std::move(spv_inst));
module_->AddFunction(std::move(function_));
function_ = nullptr;
} else if (opcode == SpvOpLabel) {
SPIRV_ASSERT(consumer_, function_ != nullptr);
SPIRV_ASSERT(consumer_, block_ == nullptr);
block_.reset(new BasicBlock(std::move(spv_inst)));
} else if (IsTerminatorInst(opcode)) {
SPIRV_ASSERT(consumer_, function_ != nullptr);
SPIRV_ASSERT(consumer_, block_ != nullptr);
block_->AddInstruction(std::move(spv_inst));
function_->AddBasicBlock(std::move(block_));
block_ = nullptr;
} else {
if (function_ == nullptr) { // Outside function definition
SPIRV_ASSERT(consumer_, block_ == nullptr);
if (opcode == SpvOpCapability) {
module_->AddCapability(std::move(spv_inst));
} else if (opcode == SpvOpExtension) {
module_->AddExtension(std::move(spv_inst));
} else if (opcode == SpvOpExtInstImport) {
module_->AddExtInstImport(std::move(spv_inst));
} else if (opcode == SpvOpMemoryModel) {
module_->SetMemoryModel(std::move(spv_inst));
} else if (opcode == SpvOpEntryPoint) {
module_->AddEntryPoint(std::move(spv_inst));
} else if (opcode == SpvOpExecutionMode) {
module_->AddExecutionMode(std::move(spv_inst));
} else if (IsDebugInst(opcode)) {
module_->AddDebugInst(std::move(spv_inst));
} else if (IsAnnotationInst(opcode)) {
module_->AddAnnotationInst(std::move(spv_inst));
} else if (IsTypeInst(opcode)) {
module_->AddType(std::move(spv_inst));
} else if (IsConstantInst(opcode) || opcode == SpvOpVariable ||
opcode == SpvOpUndef) {
module_->AddGlobalValue(std::move(spv_inst));
} else {
SPIRV_UNIMPLEMENTED(consumer_,
"unhandled inst type outside function defintion");
}
} else {
if (block_ == nullptr) { // Inside function but outside blocks
SPIRV_ASSERT(consumer_, opcode == SpvOpFunctionParameter);
function_->AddParameter(std::move(spv_inst));
} else {
block_->AddInstruction(std::move(spv_inst));
}
}
}
}
// Resolves internal references among the module, functions, basic blocks, etc.
// This function should be called after adding all instructions.
void IrLoader::EndModule() {
if (block_ && function_) {
// We're in the middle of a basic block, but the terminator is missing.
// Register the block anyway. This lets us write tests with less
// boilerplate.
function_->AddBasicBlock(std::move(block_));
block_ = nullptr;
}
if (function_) {
// We're in the middle of a function, but the OpFunctionEnd is missing.
// Register the function anyway. This lets us write tests with less
// boilerplate.
module_->AddFunction(std::move(function_));
function_ = nullptr;
}
for (auto& function : *module_) {
for (auto& bb : function) bb.SetParent(&function);
function.SetParent(module_);
}
}
} // namespace ir
} // namespace spvtools