| // Copyright 2013 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/compiler/graph-visualizer.h" |
| |
| #include <memory> |
| #include <sstream> |
| #include <string> |
| |
| // Currently disabled due to no-usage and API leaks. |
| #if !defined(DISABLE_GRAPHS_STARBOARD) |
| |
| #include "src/base/platform/wrappers.h" |
| #include "src/codegen/optimized-compilation-info.h" |
| #include "src/codegen/source-position.h" |
| #include "src/compiler/all-nodes.h" |
| #include "src/compiler/backend/register-allocation.h" |
| #include "src/compiler/backend/register-allocator.h" |
| #include "src/compiler/compiler-source-position-table.h" |
| #include "src/compiler/graph.h" |
| #include "src/compiler/node-origin-table.h" |
| #include "src/compiler/node-properties.h" |
| #include "src/compiler/node.h" |
| #include "src/compiler/opcodes.h" |
| #include "src/compiler/operator-properties.h" |
| #include "src/compiler/operator.h" |
| #include "src/compiler/schedule.h" |
| #include "src/compiler/scheduler.h" |
| #include "src/interpreter/bytecodes.h" |
| #include "src/objects/script-inl.h" |
| #include "src/objects/shared-function-info.h" |
| #include "src/utils/ostreams.h" |
| #include "src/utils/vector.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| const char* get_cached_trace_turbo_filename(OptimizedCompilationInfo* info) { |
| if (!info->trace_turbo_filename()) { |
| info->set_trace_turbo_filename( |
| GetVisualizerLogFileName(info, FLAG_trace_turbo_path, nullptr, "json")); |
| } |
| return info->trace_turbo_filename(); |
| } |
| |
| TurboJsonFile::TurboJsonFile(OptimizedCompilationInfo* info, |
| std::ios_base::openmode mode) |
| : std::ofstream(get_cached_trace_turbo_filename(info), mode) {} |
| |
| TurboJsonFile::~TurboJsonFile() { flush(); } |
| |
| TurboCfgFile::TurboCfgFile(Isolate* isolate) |
| : std::ofstream(Isolate::GetTurboCfgFileName(isolate).c_str(), |
| std::ios_base::app) {} |
| |
| TurboCfgFile::~TurboCfgFile() { flush(); } |
| |
| std::ostream& operator<<(std::ostream& out, |
| const SourcePositionAsJSON& asJSON) { |
| asJSON.sp.PrintJson(out); |
| return out; |
| } |
| |
| std::ostream& operator<<(std::ostream& out, const NodeOriginAsJSON& asJSON) { |
| asJSON.no.PrintJson(out); |
| return out; |
| } |
| |
| class JSONEscaped { |
| public: |
| explicit JSONEscaped(const std::ostringstream& os) : str_(os.str()) {} |
| |
| friend std::ostream& operator<<(std::ostream& os, const JSONEscaped& e) { |
| for (char c : e.str_) PipeCharacter(os, c); |
| return os; |
| } |
| |
| private: |
| static std::ostream& PipeCharacter(std::ostream& os, char c) { |
| if (c == '"') return os << "\\\""; |
| if (c == '\\') return os << "\\\\"; |
| if (c == '\b') return os << "\\b"; |
| if (c == '\f') return os << "\\f"; |
| if (c == '\n') return os << "\\n"; |
| if (c == '\r') return os << "\\r"; |
| if (c == '\t') return os << "\\t"; |
| return os << c; |
| } |
| |
| const std::string str_; |
| }; |
| |
| void JsonPrintFunctionSource(std::ostream& os, int source_id, |
| std::unique_ptr<char[]> function_name, |
| Handle<Script> script, Isolate* isolate, |
| Handle<SharedFunctionInfo> shared, bool with_key) { |
| if (with_key) os << "\"" << source_id << "\" : "; |
| |
| os << "{ "; |
| os << "\"sourceId\": " << source_id; |
| os << ", \"functionName\": \"" << function_name.get() << "\" "; |
| |
| int start = 0; |
| int end = 0; |
| if (!script.is_null() && !script->IsUndefined(isolate) && !shared.is_null()) { |
| Object source_name = script->name(); |
| os << ", \"sourceName\": \""; |
| if (source_name.IsString()) { |
| std::ostringstream escaped_name; |
| escaped_name << String::cast(source_name).ToCString().get(); |
| os << JSONEscaped(escaped_name); |
| } |
| os << "\""; |
| { |
| DisallowHeapAllocation no_allocation; |
| start = shared->StartPosition(); |
| end = shared->EndPosition(); |
| os << ", \"sourceText\": \""; |
| int len = shared->EndPosition() - start; |
| SubStringRange source(String::cast(script->source()), no_allocation, |
| start, len); |
| for (const auto& c : source) { |
| os << AsEscapedUC16ForJSON(c); |
| } |
| os << "\""; |
| } |
| } else { |
| os << ", \"sourceName\": \"\""; |
| os << ", \"sourceText\": \"\""; |
| } |
| os << ", \"startPosition\": " << start; |
| os << ", \"endPosition\": " << end; |
| os << "}"; |
| } |
| |
| int SourceIdAssigner::GetIdFor(Handle<SharedFunctionInfo> shared) { |
| for (unsigned i = 0; i < printed_.size(); i++) { |
| if (printed_.at(i).is_identical_to(shared)) { |
| source_ids_.push_back(i); |
| return i; |
| } |
| } |
| const int source_id = static_cast<int>(printed_.size()); |
| printed_.push_back(shared); |
| source_ids_.push_back(source_id); |
| return source_id; |
| } |
| |
| namespace { |
| |
| void JsonPrintInlinedFunctionInfo( |
| std::ostream& os, int source_id, int inlining_id, |
| const OptimizedCompilationInfo::InlinedFunctionHolder& h) { |
| os << "\"" << inlining_id << "\" : "; |
| os << "{ \"inliningId\" : " << inlining_id; |
| os << ", \"sourceId\" : " << source_id; |
| const SourcePosition position = h.position.position; |
| if (position.IsKnown()) { |
| os << ", \"inliningPosition\" : " << AsJSON(position); |
| } |
| os << "}"; |
| } |
| |
| } // namespace |
| |
| void JsonPrintAllSourceWithPositions(std::ostream& os, |
| OptimizedCompilationInfo* info, |
| Isolate* isolate) { |
| os << "\"sources\" : {"; |
| Handle<Script> script = |
| (info->shared_info().is_null() || |
| info->shared_info()->script() == Object()) |
| ? Handle<Script>() |
| : handle(Script::cast(info->shared_info()->script()), isolate); |
| JsonPrintFunctionSource(os, -1, |
| info->shared_info().is_null() |
| ? std::unique_ptr<char[]>(new char[1]{0}) |
| : info->shared_info()->DebugName().ToCString(), |
| script, isolate, info->shared_info(), true); |
| const auto& inlined = info->inlined_functions(); |
| SourceIdAssigner id_assigner(info->inlined_functions().size()); |
| for (unsigned id = 0; id < inlined.size(); id++) { |
| os << ", "; |
| Handle<SharedFunctionInfo> shared = inlined[id].shared_info; |
| const int source_id = id_assigner.GetIdFor(shared); |
| JsonPrintFunctionSource(os, source_id, shared->DebugName().ToCString(), |
| handle(Script::cast(shared->script()), isolate), |
| isolate, shared, true); |
| } |
| os << "}, "; |
| os << "\"inlinings\" : {"; |
| bool need_comma = false; |
| for (unsigned id = 0; id < inlined.size(); id++) { |
| if (need_comma) os << ", "; |
| const int source_id = id_assigner.GetIdAt(id); |
| JsonPrintInlinedFunctionInfo(os, source_id, id, inlined[id]); |
| need_comma = true; |
| } |
| os << "}"; |
| } |
| |
| std::unique_ptr<char[]> GetVisualizerLogFileName(OptimizedCompilationInfo* info, |
| const char* optional_base_dir, |
| const char* phase, |
| const char* suffix) { |
| EmbeddedVector<char, 256> filename(0); |
| std::unique_ptr<char[]> debug_name = info->GetDebugName(); |
| int optimization_id = info->IsOptimizing() ? info->optimization_id() : 0; |
| if (strlen(debug_name.get()) > 0) { |
| SNPrintF(filename, "turbo-%s-%i", debug_name.get(), optimization_id); |
| } else if (info->has_shared_info()) { |
| SNPrintF(filename, "turbo-%p-%i", |
| reinterpret_cast<void*>(info->shared_info()->address()), |
| optimization_id); |
| } else { |
| SNPrintF(filename, "turbo-none-%i", optimization_id); |
| } |
| EmbeddedVector<char, 256> source_file(0); |
| bool source_available = false; |
| if (FLAG_trace_file_names && info->has_shared_info() && |
| info->shared_info()->script().IsScript()) { |
| Object source_name = Script::cast(info->shared_info()->script()).name(); |
| if (source_name.IsString()) { |
| String str = String::cast(source_name); |
| if (str.length() > 0) { |
| SNPrintF(source_file, "%s", str.ToCString().get()); |
| std::replace(source_file.begin(), |
| source_file.begin() + source_file.length(), '/', '_'); |
| source_available = true; |
| } |
| } |
| } |
| std::replace(filename.begin(), filename.begin() + filename.length(), ' ', |
| '_'); |
| |
| EmbeddedVector<char, 256> base_dir; |
| if (optional_base_dir != nullptr) { |
| SNPrintF(base_dir, "%s%c", optional_base_dir, |
| base::OS::DirectorySeparator()); |
| } else { |
| base_dir[0] = '\0'; |
| } |
| |
| EmbeddedVector<char, 256> full_filename; |
| if (phase == nullptr && !source_available) { |
| SNPrintF(full_filename, "%s%s.%s", base_dir.begin(), filename.begin(), |
| suffix); |
| } else if (phase != nullptr && !source_available) { |
| SNPrintF(full_filename, "%s%s-%s.%s", base_dir.begin(), filename.begin(), |
| phase, suffix); |
| } else if (phase == nullptr && source_available) { |
| SNPrintF(full_filename, "%s%s_%s.%s", base_dir.begin(), filename.begin(), |
| source_file.begin(), suffix); |
| } else { |
| SNPrintF(full_filename, "%s%s_%s-%s.%s", base_dir.begin(), filename.begin(), |
| source_file.begin(), phase, suffix); |
| } |
| |
| char* buffer = new char[full_filename.length() + 1]; |
| memcpy(buffer, full_filename.begin(), full_filename.length()); |
| buffer[full_filename.length()] = '\0'; |
| return std::unique_ptr<char[]>(buffer); |
| } |
| |
| |
| static int SafeId(Node* node) { return node == nullptr ? -1 : node->id(); } |
| static const char* SafeMnemonic(Node* node) { |
| return node == nullptr ? "null" : node->op()->mnemonic(); |
| } |
| |
| class JSONGraphNodeWriter { |
| public: |
| JSONGraphNodeWriter(std::ostream& os, Zone* zone, const Graph* graph, |
| const SourcePositionTable* positions, |
| const NodeOriginTable* origins) |
| : os_(os), |
| all_(zone, graph, false), |
| live_(zone, graph, true), |
| positions_(positions), |
| origins_(origins), |
| first_node_(true) {} |
| JSONGraphNodeWriter(const JSONGraphNodeWriter&) = delete; |
| JSONGraphNodeWriter& operator=(const JSONGraphNodeWriter&) = delete; |
| |
| void Print() { |
| for (Node* const node : all_.reachable) PrintNode(node); |
| os_ << "\n"; |
| } |
| |
| void PrintNode(Node* node) { |
| if (first_node_) { |
| first_node_ = false; |
| } else { |
| os_ << ",\n"; |
| } |
| std::ostringstream label, title, properties; |
| node->op()->PrintTo(label, Operator::PrintVerbosity::kSilent); |
| node->op()->PrintTo(title, Operator::PrintVerbosity::kVerbose); |
| node->op()->PrintPropsTo(properties); |
| os_ << "{\"id\":" << SafeId(node) << ",\"label\":\"" << JSONEscaped(label) |
| << "\"" |
| << ",\"title\":\"" << JSONEscaped(title) << "\"" |
| << ",\"live\": " << (live_.IsLive(node) ? "true" : "false") |
| << ",\"properties\":\"" << JSONEscaped(properties) << "\""; |
| IrOpcode::Value opcode = node->opcode(); |
| if (IrOpcode::IsPhiOpcode(opcode)) { |
| os_ << ",\"rankInputs\":[0," << NodeProperties::FirstControlIndex(node) |
| << "]"; |
| os_ << ",\"rankWithInput\":[" << NodeProperties::FirstControlIndex(node) |
| << "]"; |
| } else if (opcode == IrOpcode::kIfTrue || opcode == IrOpcode::kIfFalse || |
| opcode == IrOpcode::kLoop) { |
| os_ << ",\"rankInputs\":[" << NodeProperties::FirstControlIndex(node) |
| << "]"; |
| } |
| if (opcode == IrOpcode::kBranch) { |
| os_ << ",\"rankInputs\":[0]"; |
| } |
| if (positions_ != nullptr) { |
| SourcePosition position = positions_->GetSourcePosition(node); |
| if (position.IsKnown()) { |
| os_ << ", \"sourcePosition\" : " << AsJSON(position); |
| } |
| } |
| if (origins_) { |
| NodeOrigin origin = origins_->GetNodeOrigin(node); |
| if (origin.IsKnown()) { |
| os_ << ", \"origin\" : " << AsJSON(origin); |
| } |
| } |
| os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\""; |
| os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true" |
| : "false"); |
| os_ << ",\"opinfo\":\"" << node->op()->ValueInputCount() << " v " |
| << node->op()->EffectInputCount() << " eff " |
| << node->op()->ControlInputCount() << " ctrl in, " |
| << node->op()->ValueOutputCount() << " v " |
| << node->op()->EffectOutputCount() << " eff " |
| << node->op()->ControlOutputCount() << " ctrl out\""; |
| if (NodeProperties::IsTyped(node)) { |
| Type type = NodeProperties::GetType(node); |
| std::ostringstream type_out; |
| type.PrintTo(type_out); |
| os_ << ",\"type\":\"" << JSONEscaped(type_out) << "\""; |
| } |
| os_ << "}"; |
| } |
| |
| private: |
| std::ostream& os_; |
| AllNodes all_; |
| AllNodes live_; |
| const SourcePositionTable* positions_; |
| const NodeOriginTable* origins_; |
| bool first_node_; |
| }; |
| |
| |
| class JSONGraphEdgeWriter { |
| public: |
| JSONGraphEdgeWriter(std::ostream& os, Zone* zone, const Graph* graph) |
| : os_(os), all_(zone, graph, false), first_edge_(true) {} |
| JSONGraphEdgeWriter(const JSONGraphEdgeWriter&) = delete; |
| JSONGraphEdgeWriter& operator=(const JSONGraphEdgeWriter&) = delete; |
| |
| void Print() { |
| for (Node* const node : all_.reachable) PrintEdges(node); |
| os_ << "\n"; |
| } |
| |
| void PrintEdges(Node* node) { |
| for (int i = 0; i < node->InputCount(); i++) { |
| Node* input = node->InputAt(i); |
| if (input == nullptr) continue; |
| PrintEdge(node, i, input); |
| } |
| } |
| |
| void PrintEdge(Node* from, int index, Node* to) { |
| if (first_edge_) { |
| first_edge_ = false; |
| } else { |
| os_ << ",\n"; |
| } |
| const char* edge_type = nullptr; |
| if (index < NodeProperties::FirstValueIndex(from)) { |
| edge_type = "unknown"; |
| } else if (index < NodeProperties::FirstContextIndex(from)) { |
| edge_type = "value"; |
| } else if (index < NodeProperties::FirstFrameStateIndex(from)) { |
| edge_type = "context"; |
| } else if (index < NodeProperties::FirstEffectIndex(from)) { |
| edge_type = "frame-state"; |
| } else if (index < NodeProperties::FirstControlIndex(from)) { |
| edge_type = "effect"; |
| } else { |
| edge_type = "control"; |
| } |
| os_ << "{\"source\":" << SafeId(to) << ",\"target\":" << SafeId(from) |
| << ",\"index\":" << index << ",\"type\":\"" << edge_type << "\"}"; |
| } |
| |
| private: |
| std::ostream& os_; |
| AllNodes all_; |
| bool first_edge_; |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, const GraphAsJSON& ad) { |
| AccountingAllocator allocator; |
| Zone tmp_zone(&allocator, ZONE_NAME); |
| os << "{\n\"nodes\":["; |
| JSONGraphNodeWriter(os, &tmp_zone, &ad.graph, ad.positions, ad.origins) |
| .Print(); |
| os << "],\n\"edges\":["; |
| JSONGraphEdgeWriter(os, &tmp_zone, &ad.graph).Print(); |
| os << "]}"; |
| return os; |
| } |
| |
| |
| class GraphC1Visualizer { |
| public: |
| GraphC1Visualizer(std::ostream& os, Zone* zone); // NOLINT |
| GraphC1Visualizer(const GraphC1Visualizer&) = delete; |
| GraphC1Visualizer& operator=(const GraphC1Visualizer&) = delete; |
| |
| void PrintCompilation(const OptimizedCompilationInfo* info); |
| void PrintSchedule(const char* phase, const Schedule* schedule, |
| const SourcePositionTable* positions, |
| const InstructionSequence* instructions); |
| void PrintLiveRanges(const char* phase, |
| const TopTierRegisterAllocationData* data); |
| Zone* zone() const { return zone_; } |
| |
| private: |
| void PrintIndent(); |
| void PrintStringProperty(const char* name, const char* value); |
| void PrintLongProperty(const char* name, int64_t value); |
| void PrintIntProperty(const char* name, int value); |
| void PrintBlockProperty(const char* name, int rpo_number); |
| void PrintNodeId(Node* n); |
| void PrintNode(Node* n); |
| void PrintInputs(Node* n); |
| template <typename InputIterator> |
| void PrintInputs(InputIterator* i, int count, const char* prefix); |
| void PrintType(Node* node); |
| |
| void PrintLiveRange(const LiveRange* range, const char* type, int vreg); |
| void PrintLiveRangeChain(const TopLevelLiveRange* range, const char* type); |
| |
| class Tag final { |
| public: |
| Tag(GraphC1Visualizer* visualizer, const char* name) { |
| name_ = name; |
| visualizer_ = visualizer; |
| visualizer->PrintIndent(); |
| visualizer_->os_ << "begin_" << name << "\n"; |
| visualizer->indent_++; |
| } |
| |
| ~Tag() { |
| visualizer_->indent_--; |
| visualizer_->PrintIndent(); |
| visualizer_->os_ << "end_" << name_ << "\n"; |
| DCHECK_LE(0, visualizer_->indent_); |
| } |
| |
| private: |
| GraphC1Visualizer* visualizer_; |
| const char* name_; |
| }; |
| |
| std::ostream& os_; |
| int indent_; |
| Zone* zone_; |
| }; |
| |
| |
| void GraphC1Visualizer::PrintIndent() { |
| for (int i = 0; i < indent_; i++) { |
| os_ << " "; |
| } |
| } |
| |
| |
| GraphC1Visualizer::GraphC1Visualizer(std::ostream& os, Zone* zone) |
| : os_(os), indent_(0), zone_(zone) {} |
| |
| |
| void GraphC1Visualizer::PrintStringProperty(const char* name, |
| const char* value) { |
| PrintIndent(); |
| os_ << name << " \"" << value << "\"\n"; |
| } |
| |
| |
| void GraphC1Visualizer::PrintLongProperty(const char* name, int64_t value) { |
| PrintIndent(); |
| os_ << name << " " << static_cast<int>(value / 1000) << "\n"; |
| } |
| |
| |
| void GraphC1Visualizer::PrintBlockProperty(const char* name, int rpo_number) { |
| PrintIndent(); |
| os_ << name << " \"B" << rpo_number << "\"\n"; |
| } |
| |
| |
| void GraphC1Visualizer::PrintIntProperty(const char* name, int value) { |
| PrintIndent(); |
| os_ << name << " " << value << "\n"; |
| } |
| |
| void GraphC1Visualizer::PrintCompilation(const OptimizedCompilationInfo* info) { |
| Tag tag(this, "compilation"); |
| std::unique_ptr<char[]> name = info->GetDebugName(); |
| if (info->IsOptimizing()) { |
| PrintStringProperty("name", name.get()); |
| PrintIndent(); |
| os_ << "method \"" << name.get() << ":" << info->optimization_id() |
| << "\"\n"; |
| } else { |
| PrintStringProperty("name", name.get()); |
| PrintStringProperty("method", "stub"); |
| } |
| PrintLongProperty( |
| "date", |
| static_cast<int64_t>(V8::GetCurrentPlatform()->CurrentClockTimeMillis())); |
| } |
| |
| |
| void GraphC1Visualizer::PrintNodeId(Node* n) { os_ << "n" << SafeId(n); } |
| |
| |
| void GraphC1Visualizer::PrintNode(Node* n) { |
| PrintNodeId(n); |
| os_ << " " << *n->op() << " "; |
| PrintInputs(n); |
| } |
| |
| |
| template <typename InputIterator> |
| void GraphC1Visualizer::PrintInputs(InputIterator* i, int count, |
| const char* prefix) { |
| if (count > 0) { |
| os_ << prefix; |
| } |
| while (count > 0) { |
| os_ << " "; |
| PrintNodeId(**i); |
| ++(*i); |
| count--; |
| } |
| } |
| |
| |
| void GraphC1Visualizer::PrintInputs(Node* node) { |
| auto i = node->inputs().begin(); |
| PrintInputs(&i, node->op()->ValueInputCount(), " "); |
| PrintInputs(&i, OperatorProperties::GetContextInputCount(node->op()), |
| " Ctx:"); |
| PrintInputs(&i, OperatorProperties::GetFrameStateInputCount(node->op()), |
| " FS:"); |
| PrintInputs(&i, node->op()->EffectInputCount(), " Eff:"); |
| PrintInputs(&i, node->op()->ControlInputCount(), " Ctrl:"); |
| } |
| |
| |
| void GraphC1Visualizer::PrintType(Node* node) { |
| if (NodeProperties::IsTyped(node)) { |
| Type type = NodeProperties::GetType(node); |
| os_ << " type:" << type; |
| } |
| } |
| |
| |
| void GraphC1Visualizer::PrintSchedule(const char* phase, |
| const Schedule* schedule, |
| const SourcePositionTable* positions, |
| const InstructionSequence* instructions) { |
| Tag tag(this, "cfg"); |
| PrintStringProperty("name", phase); |
| const BasicBlockVector* rpo = schedule->rpo_order(); |
| for (size_t i = 0; i < rpo->size(); i++) { |
| BasicBlock* current = (*rpo)[i]; |
| Tag block_tag(this, "block"); |
| PrintBlockProperty("name", current->rpo_number()); |
| PrintIntProperty("from_bci", -1); |
| PrintIntProperty("to_bci", -1); |
| |
| PrintIndent(); |
| os_ << "predecessors"; |
| for (BasicBlock* predecessor : current->predecessors()) { |
| os_ << " \"B" << predecessor->rpo_number() << "\""; |
| } |
| os_ << "\n"; |
| |
| PrintIndent(); |
| os_ << "successors"; |
| for (BasicBlock* successor : current->successors()) { |
| os_ << " \"B" << successor->rpo_number() << "\""; |
| } |
| os_ << "\n"; |
| |
| PrintIndent(); |
| os_ << "xhandlers\n"; |
| |
| PrintIndent(); |
| os_ << "flags\n"; |
| |
| if (current->dominator() != nullptr) { |
| PrintBlockProperty("dominator", current->dominator()->rpo_number()); |
| } |
| |
| PrintIntProperty("loop_depth", current->loop_depth()); |
| |
| const InstructionBlock* instruction_block = |
| instructions->InstructionBlockAt( |
| RpoNumber::FromInt(current->rpo_number())); |
| if (instruction_block->code_start() >= 0) { |
| int first_index = instruction_block->first_instruction_index(); |
| int last_index = instruction_block->last_instruction_index(); |
| PrintIntProperty( |
| "first_lir_id", |
| LifetimePosition::GapFromInstructionIndex(first_index).value()); |
| PrintIntProperty("last_lir_id", |
| LifetimePosition::InstructionFromInstructionIndex( |
| last_index).value()); |
| } |
| |
| { |
| Tag states_tag(this, "states"); |
| Tag locals_tag(this, "locals"); |
| int total = 0; |
| for (BasicBlock::const_iterator i = current->begin(); i != current->end(); |
| ++i) { |
| if ((*i)->opcode() == IrOpcode::kPhi) total++; |
| } |
| PrintIntProperty("size", total); |
| PrintStringProperty("method", "None"); |
| int index = 0; |
| for (BasicBlock::const_iterator i = current->begin(); i != current->end(); |
| ++i) { |
| if ((*i)->opcode() != IrOpcode::kPhi) continue; |
| PrintIndent(); |
| os_ << index << " "; |
| PrintNodeId(*i); |
| os_ << " ["; |
| PrintInputs(*i); |
| os_ << "]\n"; |
| index++; |
| } |
| } |
| |
| { |
| Tag HIR_tag(this, "HIR"); |
| for (BasicBlock::const_iterator i = current->begin(); i != current->end(); |
| ++i) { |
| Node* node = *i; |
| if (node->opcode() == IrOpcode::kPhi) continue; |
| int uses = node->UseCount(); |
| PrintIndent(); |
| os_ << "0 " << uses << " "; |
| PrintNode(node); |
| if (FLAG_trace_turbo_types) { |
| os_ << " "; |
| PrintType(node); |
| } |
| if (positions != nullptr) { |
| SourcePosition position = positions->GetSourcePosition(node); |
| if (position.IsKnown()) { |
| os_ << " pos:"; |
| if (position.isInlined()) { |
| os_ << "inlining(" << position.InliningId() << "),"; |
| } |
| os_ << position.ScriptOffset(); |
| } |
| } |
| os_ << " <|@\n"; |
| } |
| |
| BasicBlock::Control control = current->control(); |
| if (control != BasicBlock::kNone) { |
| PrintIndent(); |
| os_ << "0 0 "; |
| if (current->control_input() != nullptr) { |
| PrintNode(current->control_input()); |
| } else { |
| os_ << -1 - current->rpo_number() << " Goto"; |
| } |
| os_ << " ->"; |
| for (BasicBlock* successor : current->successors()) { |
| os_ << " B" << successor->rpo_number(); |
| } |
| if (FLAG_trace_turbo_types && current->control_input() != nullptr) { |
| os_ << " "; |
| PrintType(current->control_input()); |
| } |
| os_ << " <|@\n"; |
| } |
| } |
| |
| if (instructions != nullptr) { |
| Tag LIR_tag(this, "LIR"); |
| for (int j = instruction_block->first_instruction_index(); |
| j <= instruction_block->last_instruction_index(); j++) { |
| PrintIndent(); |
| os_ << j << " " << *instructions->InstructionAt(j) << " <|@\n"; |
| } |
| } |
| } |
| } |
| |
| void GraphC1Visualizer::PrintLiveRanges( |
| const char* phase, const TopTierRegisterAllocationData* data) { |
| Tag tag(this, "intervals"); |
| PrintStringProperty("name", phase); |
| |
| for (const TopLevelLiveRange* range : data->fixed_double_live_ranges()) { |
| PrintLiveRangeChain(range, "fixed"); |
| } |
| |
| for (const TopLevelLiveRange* range : data->fixed_live_ranges()) { |
| PrintLiveRangeChain(range, "fixed"); |
| } |
| |
| for (const TopLevelLiveRange* range : data->live_ranges()) { |
| PrintLiveRangeChain(range, "object"); |
| } |
| } |
| |
| void GraphC1Visualizer::PrintLiveRangeChain(const TopLevelLiveRange* range, |
| const char* type) { |
| if (range == nullptr || range->IsEmpty()) return; |
| int vreg = range->vreg(); |
| for (const LiveRange* child = range; child != nullptr; |
| child = child->next()) { |
| PrintLiveRange(child, type, vreg); |
| } |
| } |
| |
| void GraphC1Visualizer::PrintLiveRange(const LiveRange* range, const char* type, |
| int vreg) { |
| if (range != nullptr && !range->IsEmpty()) { |
| PrintIndent(); |
| os_ << vreg << ":" << range->relative_id() << " " << type; |
| if (range->HasRegisterAssigned()) { |
| AllocatedOperand op = AllocatedOperand::cast(range->GetAssignedOperand()); |
| if (op.IsRegister()) { |
| os_ << " \"" << Register::from_code(op.register_code()) << "\""; |
| } else if (op.IsDoubleRegister()) { |
| os_ << " \"" << DoubleRegister::from_code(op.register_code()) << "\""; |
| } else if (op.IsFloatRegister()) { |
| os_ << " \"" << FloatRegister::from_code(op.register_code()) << "\""; |
| } else { |
| DCHECK(op.IsSimd128Register()); |
| os_ << " \"" << Simd128Register::from_code(op.register_code()) << "\""; |
| } |
| } else if (range->spilled()) { |
| const TopLevelLiveRange* top = range->TopLevel(); |
| int index = -1; |
| if (top->HasSpillRange()) { |
| index = kMaxInt; // This hasn't been set yet. |
| } else if (top->GetSpillOperand()->IsConstant()) { |
| os_ << " \"const(nostack):" |
| << ConstantOperand::cast(top->GetSpillOperand())->virtual_register() |
| << "\""; |
| } else { |
| index = AllocatedOperand::cast(top->GetSpillOperand())->index(); |
| if (IsFloatingPoint(top->representation())) { |
| os_ << " \"fp_stack:" << index << "\""; |
| } else { |
| os_ << " \"stack:" << index << "\""; |
| } |
| } |
| } |
| |
| const TopLevelLiveRange* parent = range->TopLevel(); |
| os_ << " " << parent->vreg() << ":" << parent->relative_id(); |
| |
| // TODO(herhut) Find something useful to print for the hint field |
| if (range->get_bundle() != nullptr) { |
| os_ << " B" << range->get_bundle()->id(); |
| } else { |
| os_ << " unknown"; |
| } |
| |
| for (const UseInterval* interval = range->first_interval(); |
| interval != nullptr; interval = interval->next()) { |
| os_ << " [" << interval->start().value() << ", " |
| << interval->end().value() << "["; |
| } |
| |
| UsePosition* current_pos = range->first_pos(); |
| while (current_pos != nullptr) { |
| if (current_pos->RegisterIsBeneficial() || FLAG_trace_all_uses) { |
| os_ << " " << current_pos->pos().value() << " M"; |
| } |
| current_pos = current_pos->next(); |
| } |
| |
| os_ << " \"\"\n"; |
| } |
| } |
| |
| |
| std::ostream& operator<<(std::ostream& os, const AsC1VCompilation& ac) { |
| AccountingAllocator allocator; |
| Zone tmp_zone(&allocator, ZONE_NAME); |
| GraphC1Visualizer(os, &tmp_zone).PrintCompilation(ac.info_); |
| return os; |
| } |
| |
| |
| std::ostream& operator<<(std::ostream& os, const AsC1V& ac) { |
| AccountingAllocator allocator; |
| Zone tmp_zone(&allocator, ZONE_NAME); |
| GraphC1Visualizer(os, &tmp_zone) |
| .PrintSchedule(ac.phase_, ac.schedule_, ac.positions_, ac.instructions_); |
| return os; |
| } |
| |
| |
| std::ostream& operator<<(std::ostream& os, |
| const AsC1VRegisterAllocationData& ac) { |
| // TODO(rmcilroy): Add support for fast register allocator. |
| if (ac.data_->type() == RegisterAllocationData::kTopTier) { |
| AccountingAllocator allocator; |
| Zone tmp_zone(&allocator, ZONE_NAME); |
| GraphC1Visualizer(os, &tmp_zone) |
| .PrintLiveRanges(ac.phase_, |
| TopTierRegisterAllocationData::cast(ac.data_)); |
| } |
| return os; |
| } |
| |
| const int kUnvisited = 0; |
| const int kOnStack = 1; |
| const int kVisited = 2; |
| |
| std::ostream& operator<<(std::ostream& os, const AsRPO& ar) { |
| AccountingAllocator allocator; |
| Zone local_zone(&allocator, ZONE_NAME); |
| |
| // Do a post-order depth-first search on the RPO graph. For every node, |
| // print: |
| // |
| // - the node id |
| // - the operator mnemonic |
| // - in square brackets its parameter (if present) |
| // - in parentheses the list of argument ids and their mnemonics |
| // - the node type (if it is typed) |
| |
| // Post-order guarantees that all inputs of a node will be printed before |
| // the node itself, if there are no cycles. Any cycles are broken |
| // arbitrarily. |
| |
| ZoneVector<byte> state(ar.graph.NodeCount(), kUnvisited, &local_zone); |
| ZoneStack<Node*> stack(&local_zone); |
| |
| stack.push(ar.graph.end()); |
| state[ar.graph.end()->id()] = kOnStack; |
| while (!stack.empty()) { |
| Node* n = stack.top(); |
| bool pop = true; |
| for (Node* const i : n->inputs()) { |
| if (state[i->id()] == kUnvisited) { |
| state[i->id()] = kOnStack; |
| stack.push(i); |
| pop = false; |
| break; |
| } |
| } |
| if (pop) { |
| state[n->id()] = kVisited; |
| stack.pop(); |
| os << "#" << n->id() << ":" << *n->op() << "("; |
| // Print the inputs. |
| int j = 0; |
| for (Node* const i : n->inputs()) { |
| if (j++ > 0) os << ", "; |
| os << "#" << SafeId(i) << ":" << SafeMnemonic(i); |
| } |
| os << ")"; |
| // Print the node type, if any. |
| if (NodeProperties::IsTyped(n)) { |
| os << " [Type: " << NodeProperties::GetType(n) << "]"; |
| } |
| os << std::endl; |
| } |
| } |
| return os; |
| } |
| |
| namespace { |
| |
| void PrintIndent(std::ostream& os, int indent) { |
| os << " "; |
| for (int i = 0; i < indent; i++) { |
| os << ". "; |
| } |
| } |
| |
| void PrintScheduledNode(std::ostream& os, int indent, Node* n) { |
| PrintIndent(os, indent); |
| os << "#" << n->id() << ":" << *n->op() << "("; |
| // Print the inputs. |
| int j = 0; |
| for (Node* const i : n->inputs()) { |
| if (j++ > 0) os << ", "; |
| os << "#" << SafeId(i) << ":" << SafeMnemonic(i); |
| } |
| os << ")"; |
| // Print the node type, if any. |
| if (NodeProperties::IsTyped(n)) { |
| os << " [Type: " << NodeProperties::GetType(n) << "]"; |
| } |
| } |
| |
| void PrintScheduledGraph(std::ostream& os, const Schedule* schedule) { |
| const BasicBlockVector* rpo = schedule->rpo_order(); |
| for (size_t i = 0; i < rpo->size(); i++) { |
| BasicBlock* current = (*rpo)[i]; |
| int indent = current->loop_depth(); |
| |
| os << " + Block B" << current->rpo_number() << " (pred:"; |
| for (BasicBlock* predecessor : current->predecessors()) { |
| os << " B" << predecessor->rpo_number(); |
| } |
| if (current->IsLoopHeader()) { |
| os << ", loop until B" << current->loop_end()->rpo_number(); |
| } else if (current->loop_header()) { |
| os << ", in loop B" << current->loop_header()->rpo_number(); |
| } |
| os << ")" << std::endl; |
| |
| for (BasicBlock::const_iterator i = current->begin(); i != current->end(); |
| ++i) { |
| Node* node = *i; |
| PrintScheduledNode(os, indent, node); |
| os << std::endl; |
| } |
| |
| if (current->SuccessorCount() > 0) { |
| if (current->control_input() != nullptr) { |
| PrintScheduledNode(os, indent, current->control_input()); |
| } else { |
| PrintIndent(os, indent); |
| os << "Goto"; |
| } |
| os << " ->"; |
| |
| bool isFirst = true; |
| for (BasicBlock* successor : current->successors()) { |
| if (isFirst) { |
| isFirst = false; |
| } else { |
| os << ","; |
| } |
| os << " B" << successor->rpo_number(); |
| } |
| os << std::endl; |
| } else { |
| DCHECK_NULL(current->control_input()); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| std::ostream& operator<<(std::ostream& os, |
| const LiveRangeAsJSON& live_range_json) { |
| const LiveRange& range = live_range_json.range_; |
| os << "{\"id\":" << range.relative_id() << ",\"type\":"; |
| if (range.HasRegisterAssigned()) { |
| const InstructionOperand op = range.GetAssignedOperand(); |
| os << "\"assigned\",\"op\":" |
| << InstructionOperandAsJSON{&op, &(live_range_json.code_)}; |
| } else if (range.spilled() && !range.TopLevel()->HasNoSpillType()) { |
| const TopLevelLiveRange* top = range.TopLevel(); |
| if (top->HasSpillOperand()) { |
| os << "\"assigned\",\"op\":" |
| << InstructionOperandAsJSON{top->GetSpillOperand(), |
| &(live_range_json.code_)}; |
| } else { |
| int index = top->GetSpillRange()->assigned_slot(); |
| os << "\"spilled\",\"op\":"; |
| if (IsFloatingPoint(top->representation())) { |
| os << "\"fp_stack:" << index << "\""; |
| } else { |
| os << "\"stack:" << index << "\""; |
| } |
| } |
| } else { |
| os << "\"none\""; |
| } |
| |
| os << ",\"intervals\":["; |
| bool first = true; |
| for (const UseInterval* interval = range.first_interval(); |
| interval != nullptr; interval = interval->next()) { |
| if (first) { |
| first = false; |
| } else { |
| os << ","; |
| } |
| os << "[" << interval->start().value() << "," << interval->end().value() |
| << "]"; |
| } |
| |
| os << "],\"uses\":["; |
| first = true; |
| for (UsePosition* current_pos = range.first_pos(); current_pos != nullptr; |
| current_pos = current_pos->next()) { |
| if (first) { |
| first = false; |
| } else { |
| os << ","; |
| } |
| os << current_pos->pos().value(); |
| } |
| |
| os << "]}"; |
| return os; |
| } |
| |
| std::ostream& operator<<( |
| std::ostream& os, |
| const TopLevelLiveRangeAsJSON& top_level_live_range_json) { |
| int vreg = top_level_live_range_json.range_.vreg(); |
| bool first = true; |
| os << "\"" << (vreg > 0 ? vreg : -vreg) << "\":{ \"child_ranges\":["; |
| for (const LiveRange* child = &(top_level_live_range_json.range_); |
| child != nullptr; child = child->next()) { |
| if (!top_level_live_range_json.range_.IsEmpty()) { |
| if (first) { |
| first = false; |
| } else { |
| os << ","; |
| } |
| os << LiveRangeAsJSON{*child, top_level_live_range_json.code_}; |
| } |
| } |
| os << "]"; |
| if (top_level_live_range_json.range_.IsFixed()) { |
| os << ", \"is_deferred\": " |
| << (top_level_live_range_json.range_.IsDeferredFixed() ? "true" |
| : "false"); |
| } |
| os << "}"; |
| return os; |
| } |
| |
| void PrintTopLevelLiveRanges(std::ostream& os, |
| const ZoneVector<TopLevelLiveRange*> ranges, |
| const InstructionSequence& code) { |
| bool first = true; |
| os << "{"; |
| for (const TopLevelLiveRange* range : ranges) { |
| if (range != nullptr && !range->IsEmpty()) { |
| if (first) { |
| first = false; |
| } else { |
| os << ","; |
| } |
| os << TopLevelLiveRangeAsJSON{*range, code}; |
| } |
| } |
| os << "}"; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, |
| const RegisterAllocationDataAsJSON& ac) { |
| if (ac.data_.type() == RegisterAllocationData::kTopTier) { |
| const TopTierRegisterAllocationData& ac_data = |
| TopTierRegisterAllocationData::cast(ac.data_); |
| os << "\"fixed_double_live_ranges\": "; |
| PrintTopLevelLiveRanges(os, ac_data.fixed_double_live_ranges(), ac.code_); |
| os << ",\"fixed_live_ranges\": "; |
| PrintTopLevelLiveRanges(os, ac_data.fixed_live_ranges(), ac.code_); |
| os << ",\"live_ranges\": "; |
| PrintTopLevelLiveRanges(os, ac_data.live_ranges(), ac.code_); |
| } else { |
| // TODO(rmcilroy): Add support for fast register allocation data. For now |
| // output the expected fields to keep Turbolizer happy. |
| os << "\"fixed_double_live_ranges\": {}"; |
| os << ",\"fixed_live_ranges\": {}"; |
| os << ",\"live_ranges\": {}"; |
| } |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const AsScheduledGraph& scheduled) { |
| PrintScheduledGraph(os, scheduled.schedule); |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const InstructionOperandAsJSON& o) { |
| const InstructionOperand* op = o.op_; |
| const InstructionSequence* code = o.code_; |
| os << "{"; |
| switch (op->kind()) { |
| case InstructionOperand::UNALLOCATED: { |
| const UnallocatedOperand* unalloc = UnallocatedOperand::cast(op); |
| os << "\"type\": \"unallocated\", "; |
| os << "\"text\": \"v" << unalloc->virtual_register() << "\""; |
| if (unalloc->basic_policy() == UnallocatedOperand::FIXED_SLOT) { |
| os << ",\"tooltip\": \"FIXED_SLOT: " << unalloc->fixed_slot_index() |
| << "\""; |
| break; |
| } |
| switch (unalloc->extended_policy()) { |
| case UnallocatedOperand::NONE: |
| break; |
| case UnallocatedOperand::FIXED_REGISTER: { |
| os << ",\"tooltip\": \"FIXED_REGISTER: " |
| << Register::from_code(unalloc->fixed_register_index()) << "\""; |
| break; |
| } |
| case UnallocatedOperand::FIXED_FP_REGISTER: { |
| os << ",\"tooltip\": \"FIXED_FP_REGISTER: " |
| << DoubleRegister::from_code(unalloc->fixed_register_index()) |
| << "\""; |
| break; |
| } |
| case UnallocatedOperand::MUST_HAVE_REGISTER: { |
| os << ",\"tooltip\": \"MUST_HAVE_REGISTER\""; |
| break; |
| } |
| case UnallocatedOperand::MUST_HAVE_SLOT: { |
| os << ",\"tooltip\": \"MUST_HAVE_SLOT\""; |
| break; |
| } |
| case UnallocatedOperand::SAME_AS_FIRST_INPUT: { |
| os << ",\"tooltip\": \"SAME_AS_FIRST_INPUT\""; |
| break; |
| } |
| case UnallocatedOperand::REGISTER_OR_SLOT: { |
| os << ",\"tooltip\": \"REGISTER_OR_SLOT\""; |
| break; |
| } |
| case UnallocatedOperand::REGISTER_OR_SLOT_OR_CONSTANT: { |
| os << ",\"tooltip\": \"REGISTER_OR_SLOT_OR_CONSTANT\""; |
| break; |
| } |
| } |
| break; |
| } |
| case InstructionOperand::CONSTANT: { |
| int vreg = ConstantOperand::cast(op)->virtual_register(); |
| os << "\"type\": \"constant\", "; |
| os << "\"text\": \"v" << vreg << "\","; |
| os << "\"tooltip\": \""; |
| std::stringstream tooltip; |
| tooltip << code->GetConstant(vreg); |
| for (const auto& c : tooltip.str()) { |
| os << AsEscapedUC16ForJSON(c); |
| } |
| os << "\""; |
| break; |
| } |
| case InstructionOperand::IMMEDIATE: { |
| os << "\"type\": \"immediate\", "; |
| const ImmediateOperand* imm = ImmediateOperand::cast(op); |
| switch (imm->type()) { |
| case ImmediateOperand::INLINE: { |
| os << "\"text\": \"#" << imm->inline_value() << "\""; |
| break; |
| } |
| case ImmediateOperand::INDEXED: { |
| int index = imm->indexed_value(); |
| os << "\"text\": \"imm:" << index << "\","; |
| os << "\"tooltip\": \""; |
| std::stringstream tooltip; |
| tooltip << code->GetImmediate(imm); |
| for (const auto& c : tooltip.str()) { |
| os << AsEscapedUC16ForJSON(c); |
| } |
| os << "\""; |
| break; |
| } |
| } |
| break; |
| } |
| case InstructionOperand::ALLOCATED: { |
| const LocationOperand* allocated = LocationOperand::cast(op); |
| os << "\"type\": \"allocated\", "; |
| os << "\"text\": \""; |
| if (op->IsStackSlot()) { |
| os << "stack:" << allocated->index(); |
| } else if (op->IsFPStackSlot()) { |
| os << "fp_stack:" << allocated->index(); |
| } else if (op->IsRegister()) { |
| if (allocated->register_code() < Register::kNumRegisters) { |
| os << Register::from_code(allocated->register_code()); |
| } else { |
| os << Register::GetSpecialRegisterName(allocated->register_code()); |
| } |
| } else if (op->IsDoubleRegister()) { |
| os << DoubleRegister::from_code(allocated->register_code()); |
| } else if (op->IsFloatRegister()) { |
| os << FloatRegister::from_code(allocated->register_code()); |
| } else { |
| DCHECK(op->IsSimd128Register()); |
| os << Simd128Register::from_code(allocated->register_code()); |
| } |
| os << "\","; |
| os << "\"tooltip\": \"" |
| << MachineReprToString(allocated->representation()) << "\""; |
| break; |
| } |
| case InstructionOperand::PENDING: |
| case InstructionOperand::INVALID: |
| UNREACHABLE(); |
| } |
| os << "}"; |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const InstructionAsJSON& i_json) { |
| const Instruction* instr = i_json.instr_; |
| |
| os << "{"; |
| os << "\"id\": " << i_json.index_ << ","; |
| os << "\"opcode\": \"" << ArchOpcodeField::decode(instr->opcode()) << "\","; |
| os << "\"flags\": \""; |
| FlagsMode fm = FlagsModeField::decode(instr->opcode()); |
| AddressingMode am = AddressingModeField::decode(instr->opcode()); |
| if (am != kMode_None) { |
| os << " : " << AddressingModeField::decode(instr->opcode()); |
| } |
| if (fm != kFlags_none) { |
| os << " && " << fm << " if " |
| << FlagsConditionField::decode(instr->opcode()); |
| } |
| os << "\","; |
| |
| os << "\"gaps\": ["; |
| for (int i = Instruction::FIRST_GAP_POSITION; |
| i <= Instruction::LAST_GAP_POSITION; i++) { |
| if (i != Instruction::FIRST_GAP_POSITION) os << ","; |
| os << "["; |
| const ParallelMove* pm = instr->parallel_moves()[i]; |
| if (pm == nullptr) { |
| os << "]"; |
| continue; |
| } |
| bool first = true; |
| for (MoveOperands* move : *pm) { |
| if (move->IsEliminated()) continue; |
| if (first) { |
| first = false; |
| } else { |
| os << ","; |
| } |
| os << "[" << InstructionOperandAsJSON{&move->destination(), i_json.code_} |
| << "," << InstructionOperandAsJSON{&move->source(), i_json.code_} |
| << "]"; |
| } |
| os << "]"; |
| } |
| os << "],"; |
| |
| os << "\"outputs\": ["; |
| bool need_comma = false; |
| for (size_t i = 0; i < instr->OutputCount(); i++) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << InstructionOperandAsJSON{instr->OutputAt(i), i_json.code_}; |
| } |
| os << "],"; |
| |
| os << "\"inputs\": ["; |
| need_comma = false; |
| for (size_t i = 0; i < instr->InputCount(); i++) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << InstructionOperandAsJSON{instr->InputAt(i), i_json.code_}; |
| } |
| os << "],"; |
| |
| os << "\"temps\": ["; |
| need_comma = false; |
| for (size_t i = 0; i < instr->TempCount(); i++) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << InstructionOperandAsJSON{instr->TempAt(i), i_json.code_}; |
| } |
| os << "]"; |
| os << "}"; |
| |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const InstructionBlockAsJSON& b) { |
| const InstructionBlock* block = b.block_; |
| const InstructionSequence* code = b.code_; |
| os << "{"; |
| os << "\"id\": " << block->rpo_number() << ","; |
| os << "\"deferred\": " << (block->IsDeferred() ? "true" : "false"); |
| os << ","; |
| os << "\"loop_header\": " << block->IsLoopHeader() << ","; |
| if (block->IsLoopHeader()) { |
| os << "\"loop_end\": " << block->loop_end() << ","; |
| } |
| os << "\"predecessors\": ["; |
| bool need_comma = false; |
| for (RpoNumber pred : block->predecessors()) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << pred.ToInt(); |
| } |
| os << "],"; |
| os << "\"successors\": ["; |
| need_comma = false; |
| for (RpoNumber succ : block->successors()) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << succ.ToInt(); |
| } |
| os << "],"; |
| os << "\"phis\": ["; |
| bool needs_comma = false; |
| InstructionOperandAsJSON json_op = {nullptr, code}; |
| for (const PhiInstruction* phi : block->phis()) { |
| if (needs_comma) os << ","; |
| needs_comma = true; |
| json_op.op_ = &phi->output(); |
| os << "{\"output\" : " << json_op << ","; |
| os << "\"operands\": ["; |
| bool op_needs_comma = false; |
| for (int input : phi->operands()) { |
| if (op_needs_comma) os << ","; |
| op_needs_comma = true; |
| os << "\"v" << input << "\""; |
| } |
| os << "]}"; |
| } |
| os << "],"; |
| |
| os << "\"instructions\": ["; |
| InstructionAsJSON json_instr = {-1, nullptr, code}; |
| need_comma = false; |
| for (int j = block->first_instruction_index(); |
| j <= block->last_instruction_index(); j++) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| json_instr.index_ = j; |
| json_instr.instr_ = code->InstructionAt(j); |
| os << json_instr; |
| } |
| os << "]"; |
| os << "}"; |
| |
| return os; |
| } |
| |
| std::ostream& operator<<(std::ostream& os, const InstructionSequenceAsJSON& s) { |
| const InstructionSequence* code = s.sequence_; |
| |
| os << "["; |
| |
| bool need_comma = false; |
| for (int i = 0; i < code->InstructionBlockCount(); i++) { |
| if (need_comma) os << ","; |
| need_comma = true; |
| os << InstructionBlockAsJSON{ |
| code->InstructionBlockAt(RpoNumber::FromInt(i)), code}; |
| } |
| os << "]"; |
| |
| return os; |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // DISABLE_GRAPHS_STARBOARD |
