blob: c3bb0061e14b099fc305f6f4cf406abe7d95be6d [file] [log] [blame] [edit]
// Copyright 2022 The Tint Authors.
//
// 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 "src/tint/ir/disassembler.h"
#include "src/tint/ir/block.h"
#include "src/tint/ir/if.h"
#include "src/tint/ir/loop.h"
#include "src/tint/ir/switch.h"
#include "src/tint/ir/terminator.h"
#include "src/tint/switch.h"
namespace tint::ir {
namespace {
class ScopedStopNode {
public:
ScopedStopNode(std::unordered_set<const FlowNode*>* stop_nodes, const FlowNode* node)
: stop_nodes_(stop_nodes), node_(node) {
stop_nodes_->insert(node_);
}
~ScopedStopNode() { stop_nodes_->erase(node_); }
private:
std::unordered_set<const FlowNode*>* stop_nodes_;
const FlowNode* node_;
};
class ScopedIndent {
public:
explicit ScopedIndent(uint32_t* indent) : indent_(indent) { (*indent_) += 2; }
~ScopedIndent() { (*indent_) -= 2; }
private:
uint32_t* indent_;
};
} // namespace
Disassembler::Disassembler(const Module& mod) : mod_(mod) {}
Disassembler::~Disassembler() = default;
utils::StringStream& Disassembler::Indent() {
for (uint32_t i = 0; i < indent_size_; i++) {
out_ << " ";
}
return out_;
}
void Disassembler::EmitBlockInstructions(const Block* b) {
for (const auto* instr : b->instructions) {
Indent();
instr->ToString(out_) << std::endl;
}
}
size_t Disassembler::GetIdForNode(const FlowNode* node) {
TINT_ASSERT(IR, node);
auto it = flow_node_to_id_.find(node);
if (it != flow_node_to_id_.end()) {
return it->second;
}
size_t id = next_node_id_++;
flow_node_to_id_[node] = id;
return id;
}
void Disassembler::Walk(const FlowNode* node) {
if ((visited_.count(node) > 0) || (stop_nodes_.count(node) > 0)) {
return;
}
visited_.insert(node);
tint::Switch(
node,
[&](const ir::Function* f) {
Indent() << "%bb" << GetIdForNode(f) << " = Function " << f->name.Name() << std::endl;
{
ScopedIndent func_indent(&indent_size_);
ScopedStopNode scope(&stop_nodes_, f->end_target);
Walk(f->start_target);
}
Walk(f->end_target);
},
[&](const ir::Block* b) {
// If this block is dead, nothing to do
if (b->IsDead()) {
Indent() << "# Dead" << std::endl;
return;
}
Indent() << "%bb" << GetIdForNode(b) << " = Block" << std::endl;
EmitBlockInstructions(b);
if (b->branch.target->Is<Terminator>()) {
Indent() << "Return";
} else {
Indent() << "BranchTo "
<< "%bb" << GetIdForNode(b->branch.target);
}
out_ << " (";
for (const auto* v : b->branch.args) {
if (v != b->branch.args.Front()) {
out_ << ", ";
}
v->ToString(out_);
}
out_ << ")" << std::endl;
if (!b->branch.target->Is<Terminator>()) {
out_ << std::endl;
}
Walk(b->branch.target);
},
[&](const ir::Switch* s) {
Indent() << "%bb" << GetIdForNode(s) << " = Switch (";
s->condition->ToString(out_);
out_ << ")" << std::endl;
{
ScopedIndent switch_indent(&indent_size_);
ScopedStopNode scope(&stop_nodes_, s->merge.target);
for (const auto& c : s->cases) {
Indent() << "# Case ";
for (const auto& selector : c.selectors) {
if (&selector != &c.selectors.Front()) {
out_ << " ";
}
if (selector.IsDefault()) {
out_ << "default";
} else {
selector.val->ToString(out_);
}
}
out_ << std::endl;
Walk(c.start.target);
}
}
Indent() << "# Switch Merge" << std::endl;
Walk(s->merge.target);
},
[&](const ir::If* i) {
Indent() << "%bb" << GetIdForNode(i) << " = if (";
i->condition->ToString(out_);
out_ << ")" << std::endl;
{
ScopedIndent if_indent(&indent_size_);
ScopedStopNode scope(&stop_nodes_, i->merge.target);
Indent() << "# true branch" << std::endl;
Walk(i->true_.target);
Indent() << "# false branch" << std::endl;
Walk(i->false_.target);
}
if (!i->merge.target->IsDisconnected()) {
Indent() << "# if merge" << std::endl;
Walk(i->merge.target);
}
},
[&](const ir::Loop* l) {
Indent() << "%bb" << GetIdForNode(l) << " = loop" << std::endl;
{
ScopedStopNode loop_scope(&stop_nodes_, l->merge.target);
ScopedIndent loop_indent(&indent_size_);
{
ScopedStopNode inner_scope(&stop_nodes_, l->continuing.target);
Indent() << "# loop start" << std::endl;
Walk(l->start.target);
}
Indent() << "# loop continuing" << std::endl;
Walk(l->continuing.target);
}
Indent() << "# loop merge" << std::endl;
Walk(l->merge.target);
},
[&](const ir::Terminator*) { Indent() << "FunctionEnd" << std::endl
<< std::endl; });
}
std::string Disassembler::Disassemble() {
for (const auto* func : mod_.functions) {
Walk(func);
}
return out_.str();
}
} // namespace tint::ir