blob: 96b12f460a88f8040fb956d04c0a0655730b4eb8 [file] [log] [blame]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/compiler/backend/il_printer.h"
#include <tuple>
#include "vm/compiler/api/print_filter.h"
#include "vm/compiler/backend/il.h"
#include "vm/compiler/backend/linearscan.h"
#include "vm/compiler/backend/range_analysis.h"
#include "vm/compiler/ffi/native_calling_convention.h"
#include "vm/os.h"
#include "vm/parser.h"
namespace dart {
#if defined(INCLUDE_IL_PRINTER)
DEFINE_FLAG(bool,
display_sorted_ic_data,
false,
"Calls display a unary, sorted-by count form of ICData");
DEFINE_FLAG(bool, print_environments, false, "Print SSA environments.");
DEFINE_FLAG(bool,
print_flow_graph_as_json,
false,
"Use machine readable output when printing IL graphs.");
DECLARE_FLAG(bool, trace_inlining_intervals);
class IlTestPrinter : public AllStatic {
public:
static void PrintGraph(const char* phase, FlowGraph* flow_graph) {
JSONWriter writer;
writer.OpenObject();
writer.PrintProperty("p", phase);
writer.PrintProperty("f", flow_graph->function().ToFullyQualifiedCString());
writer.OpenArray("b");
for (auto block : flow_graph->reverse_postorder()) {
PrintBlock(&writer, block);
}
writer.CloseArray();
writer.OpenObject("desc");
AttributesSerializer(&writer).WriteDescriptors();
writer.CloseObject();
writer.OpenObject("flags");
writer.PrintPropertyBool("nnbd", IsolateGroup::Current()->null_safety());
writer.CloseObject();
writer.CloseObject();
THR_Print("%s\n", writer.ToCString());
}
static void PrintBlock(JSONWriter* writer, BlockEntryInstr* block) {
writer->OpenObject();
writer->PrintProperty64("b", block->block_id());
writer->PrintProperty("o", block->DebugName());
if (auto block_with_defs = block->AsBlockEntryWithInitialDefs()) {
if (block_with_defs->initial_definitions() != nullptr &&
block_with_defs->initial_definitions()->length() > 0) {
writer->OpenArray("d");
for (auto defn : *block_with_defs->initial_definitions()) {
if (defn->IsConstant() && !defn->HasUses()) continue;
PrintInstruction(writer, defn);
}
writer->CloseArray();
}
}
writer->OpenArray("is");
if (auto join = block->AsJoinEntry()) {
for (PhiIterator it(join); !it.Done(); it.Advance()) {
PrintInstruction(writer, it.Current());
}
}
for (auto instr : block->instructions()) {
PrintInstruction(writer, instr);
}
writer->CloseArray();
writer->CloseObject();
}
static void PrintInstruction(JSONWriter* writer,
Instruction* instr,
const char* name = nullptr) {
writer->OpenObject(name);
if (auto defn = instr->AsDefinition()) {
if (defn->ssa_temp_index() != -1) {
writer->PrintProperty("v", defn->ssa_temp_index());
}
}
writer->PrintProperty("o", instr->DebugName());
if (auto branch = instr->AsBranch()) {
PrintInstruction(writer, branch->comparison(), "cc");
} else {
if (instr->InputCount() != 0) {
writer->OpenArray("i");
for (intptr_t i = 0; i < instr->InputCount(); i++) {
writer->PrintValue(instr->InputAt(i)->definition()->ssa_temp_index());
}
writer->CloseArray();
} else if (instr->ArgumentCount() != 0 &&
instr->GetPushArguments() != nullptr) {
writer->OpenArray("i");
for (intptr_t i = 0; i < instr->ArgumentCount(); i++) {
writer->PrintValue(
instr->ArgumentValueAt(i)->definition()->ssa_temp_index());
}
writer->CloseArray();
}
AttributesSerializer serializer(writer);
instr->Accept(&serializer);
}
if (instr->SuccessorCount() > 0) {
writer->OpenArray("s");
for (auto succ : instr->successors()) {
writer->PrintValue(succ->block_id());
}
writer->CloseArray();
}
writer->CloseObject();
}
template <typename T>
class HasGetAttributes {
template <typename U>
static std::true_type test(decltype(&U::GetAttributes));
template <typename U>
static std::false_type test(...);
public:
static constexpr bool value = decltype(test<T>(0))::value;
};
class AttributesSerializer : public InstructionVisitor {
public:
explicit AttributesSerializer(JSONWriter* writer) : writer_(writer) {}
void WriteDescriptors() {
#define DECLARE_VISIT_INSTRUCTION(ShortName, Attrs) \
WriteDescriptor<ShortName##Instr>(#ShortName);
FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
#undef DECLARE_VISIT_INSTRUCTION
}
#define DECLARE_VISIT_INSTRUCTION(ShortName, Attrs) \
virtual void Visit##ShortName(ShortName##Instr* instr) { Write(instr); }
FOR_EACH_INSTRUCTION(DECLARE_VISIT_INSTRUCTION)
#undef DECLARE_VISIT_INSTRUCTION
private:
void WriteAttribute(const char* value) { writer_->PrintValue(value); }
void WriteAttribute(intptr_t value) { writer_->PrintValue(value); }
void WriteAttribute(Token::Kind kind) {
writer_->PrintValue(Token::Str(kind));
}
void WriteAttribute(const Slot* slot) { writer_->PrintValue(slot->Name()); }
template <typename... Ts>
void WriteTuple(const std::tuple<Ts...>& tuple) {
std::apply([&](Ts const&... elements) { WriteAttribute(elements...); },
tuple);
}
template <typename T,
typename = typename std::enable_if_t<HasGetAttributes<T>::value>>
void Write(T* instr) {
writer_->OpenArray("d");
WriteTuple(instr->GetAttributes());
writer_->CloseArray();
}
void Write(Instruction* instr) {
// Default, do nothing.
}
template <typename T>
void WriteDescriptor(
const char* name,
typename std::enable_if_t<HasGetAttributes<T>::value>* = 0) {
writer_->OpenArray(name);
WriteTuple(T::GetAttributeNames());
writer_->CloseArray();
}
template <typename T>
void WriteDescriptor(
const char* name,
typename std::enable_if_t<!HasGetAttributes<T>::value>* = 0) {}
JSONWriter* writer_;
};
};
bool FlowGraphPrinter::ShouldPrint(
const Function& function,
uint8_t** compiler_pass_filter /* = nullptr */) {
return compiler::PrintFilter::ShouldPrint(function, compiler_pass_filter);
}
void FlowGraphPrinter::PrintGraph(const char* phase, FlowGraph* flow_graph) {
LogBlock lb;
if (FLAG_print_flow_graph_as_json) {
IlTestPrinter::PrintGraph(phase, flow_graph);
} else {
THR_Print("*** BEGIN CFG\n%s\n", phase);
FlowGraphPrinter printer(*flow_graph);
printer.PrintBlocks();
THR_Print("*** END CFG\n");
}
fflush(stdout);
}
void FlowGraphPrinter::PrintBlock(BlockEntryInstr* block,
bool print_locations) {
// Print the block entry.
PrintOneInstruction(block, print_locations);
THR_Print("\n");
// And all the successors in the block.
for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
Instruction* current = it.Current();
PrintOneInstruction(current, print_locations);
THR_Print("\n");
}
}
void FlowGraphPrinter::PrintBlocks() {
if (!function_.IsNull()) {
THR_Print("==== %s (%s", function_.ToFullyQualifiedCString(),
Function::KindToCString(function_.kind()));
// Output saved arguments descriptor information for dispatchers that
// have it, so it's easy to see which dispatcher this graph represents.
if (function_.HasSavedArgumentsDescriptor()) {
const auto& args_desc_array = Array::Handle(function_.saved_args_desc());
const ArgumentsDescriptor args_desc(args_desc_array);
THR_Print(", %s", args_desc.ToCString());
}
THR_Print(")\n");
}
for (intptr_t i = 0; i < block_order_.length(); ++i) {
PrintBlock(block_order_[i], print_locations_);
}
}
void FlowGraphPrinter::PrintInstruction(Instruction* instr) {
PrintOneInstruction(instr, print_locations_);
}
void FlowGraphPrinter::PrintOneInstruction(Instruction* instr,
bool print_locations) {
char str[4000];
BufferFormatter f(str, sizeof(str));
instr->PrintTo(&f);
if (FLAG_print_environments && (instr->env() != NULL)) {
instr->env()->PrintTo(&f);
}
if (print_locations && (instr->HasLocs())) {
instr->locs()->PrintTo(&f);
}
if (FlowGraphAllocator::HasLifetimePosition(instr)) {
THR_Print("%3" Pd ": ", FlowGraphAllocator::GetLifetimePosition(instr));
}
if (!instr->IsBlockEntry()) THR_Print(" ");
THR_Print("%s", str);
if (FLAG_trace_inlining_intervals) {
THR_Print(" iid: %" Pd "", instr->inlining_id());
}
}
void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
TokenPosition token_pos,
Value* value,
const AbstractType& dst_type,
const String& dst_name,
bool eliminated) {
const char* compile_type_name = "unknown";
if (value != NULL && value->reaching_type_ != NULL) {
compile_type_name = value->reaching_type_->ToCString();
}
THR_Print(
"%s type check: compile type %s is %s specific than "
"type '%s' of '%s'.\n",
eliminated ? "Eliminated" : "Generated", compile_type_name,
eliminated ? "more" : "not more",
String::Handle(dst_type.Name()).ToCString(), dst_name.ToCString());
}
static void PrintTargetsHelper(BaseTextBuffer* f,
const CallTargets& targets,
intptr_t num_checks_to_print) {
f->AddString(" Targets[");
f->Printf("%" Pd ": ", targets.length());
Function& target = Function::Handle();
if ((num_checks_to_print == FlowGraphPrinter::kPrintAll) ||
(num_checks_to_print > targets.length())) {
num_checks_to_print = targets.length();
}
for (intptr_t i = 0; i < num_checks_to_print; i++) {
const CidRange& range = targets[i];
const auto target_info = targets.TargetAt(i);
const intptr_t count = target_info->count;
target = target_info->target->ptr();
if (i > 0) {
f->AddString(" | ");
}
if (range.IsSingleCid()) {
const Class& cls = Class::Handle(
IsolateGroup::Current()->class_table()->At(range.cid_start));
f->Printf("%s", String::Handle(cls.Name()).ToCString());
f->Printf(" cid %" Pd " cnt:%" Pd " trgt:'%s'", range.cid_start, count,
target.ToQualifiedCString());
} else {
const Class& cls = Class::Handle(target.Owner());
f->Printf("cid %" Pd "-%" Pd " %s", range.cid_start, range.cid_end,
String::Handle(cls.Name()).ToCString());
f->Printf(" cnt:%" Pd " trgt:'%s'", count, target.ToQualifiedCString());
}
if (target_info->exactness.IsTracking()) {
f->Printf(" %s", target_info->exactness.ToCString());
}
}
if (num_checks_to_print < targets.length()) {
f->AddString("...");
}
f->AddString("]");
}
static void PrintCidsHelper(BaseTextBuffer* f,
const Cids& targets,
intptr_t num_checks_to_print) {
f->AddString(" Cids[");
f->Printf("%" Pd ": ", targets.length());
if ((num_checks_to_print == FlowGraphPrinter::kPrintAll) ||
(num_checks_to_print > targets.length())) {
num_checks_to_print = targets.length();
}
for (intptr_t i = 0; i < num_checks_to_print; i++) {
const CidRange& range = targets[i];
if (i > 0) {
f->AddString(" | ");
}
const Class& cls = Class::Handle(
IsolateGroup::Current()->class_table()->At(range.cid_start));
f->Printf("%s etc. ", String::Handle(cls.Name()).ToCString());
if (range.IsSingleCid()) {
f->Printf(" cid %" Pd, range.cid_start);
} else {
f->Printf(" cid %" Pd "-%" Pd, range.cid_start, range.cid_end);
}
}
if (num_checks_to_print < targets.length()) {
f->AddString("...");
}
f->AddString("]");
}
static void PrintICDataHelper(BaseTextBuffer* f,
const ICData& ic_data,
intptr_t num_checks_to_print) {
f->AddString(" IC[");
if (ic_data.is_tracking_exactness()) {
f->Printf(
"(%s) ",
AbstractType::Handle(ic_data.receivers_static_type()).ToCString());
}
f->Printf("%" Pd ": ", ic_data.NumberOfChecks());
Function& target = Function::Handle();
if ((num_checks_to_print == FlowGraphPrinter::kPrintAll) ||
(num_checks_to_print > ic_data.NumberOfChecks())) {
num_checks_to_print = ic_data.NumberOfChecks();
}
for (intptr_t i = 0; i < num_checks_to_print; i++) {
GrowableArray<intptr_t> class_ids;
ic_data.GetCheckAt(i, &class_ids, &target);
const intptr_t count = ic_data.GetCountAt(i);
if (i > 0) {
f->AddString(" | ");
}
for (intptr_t k = 0; k < class_ids.length(); k++) {
if (k > 0) {
f->AddString(", ");
}
const Class& cls = Class::Handle(
IsolateGroup::Current()->class_table()->At(class_ids[k]));
f->Printf("%s", String::Handle(cls.Name()).ToCString());
}
f->Printf(" cnt:%" Pd " trgt:'%s'", count, target.ToQualifiedCString());
if (ic_data.is_tracking_exactness()) {
f->Printf(" %s", ic_data.GetExactnessAt(i).ToCString());
}
}
if (num_checks_to_print < ic_data.NumberOfChecks()) {
f->AddString("...");
}
f->AddString("]");
}
static void PrintICDataSortedHelper(BaseTextBuffer* f,
const ICData& ic_data_orig) {
const ICData& ic_data =
ICData::Handle(ic_data_orig.AsUnaryClassChecksSortedByCount());
f->Printf(" IC[n:%" Pd "; ", ic_data.NumberOfChecks());
for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
const intptr_t count = ic_data.GetCountAt(i);
const intptr_t cid = ic_data.GetReceiverClassIdAt(i);
const Class& cls =
Class::Handle(IsolateGroup::Current()->class_table()->At(cid));
f->Printf("%s : %" Pd ", ", String::Handle(cls.Name()).ToCString(), count);
}
f->AddString("]");
}
void FlowGraphPrinter::PrintICData(const ICData& ic_data,
intptr_t num_checks_to_print) {
char buffer[1024];
BufferFormatter f(buffer, sizeof(buffer));
PrintICDataHelper(&f, ic_data, num_checks_to_print);
THR_Print("%s ", buffer);
const Array& a = Array::Handle(ic_data.arguments_descriptor());
THR_Print(" arg-desc %" Pd "\n", a.Length());
}
void FlowGraphPrinter::PrintCidRangeData(const CallTargets& targets,
intptr_t num_checks_to_print) {
char buffer[1024];
BufferFormatter f(buffer, sizeof(buffer));
PrintTargetsHelper(&f, targets, num_checks_to_print);
THR_Print("%s ", buffer);
// TODO(erikcorry): Print args descriptor.
}
static void PrintUse(BaseTextBuffer* f, const Definition& definition) {
if (definition.HasSSATemp()) {
if (definition.HasPairRepresentation()) {
f->Printf("(v%" Pd ", v%" Pd ")", definition.ssa_temp_index(),
definition.ssa_temp_index() + 1);
} else {
f->Printf("v%" Pd "", definition.ssa_temp_index());
}
} else if (definition.HasTemp()) {
f->Printf("t%" Pd "", definition.temp_index());
}
}
const char* Instruction::ToCString() const {
char buffer[1024];
BufferFormatter f(buffer, sizeof(buffer));
PrintTo(&f);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
void Instruction::PrintTo(BaseTextBuffer* f) const {
if (GetDeoptId() != DeoptId::kNone) {
f->Printf("%s:%" Pd "(", DebugName(), GetDeoptId());
} else {
f->Printf("%s(", DebugName());
}
PrintOperandsTo(f);
f->AddString(")");
}
void Instruction::PrintOperandsTo(BaseTextBuffer* f) const {
for (int i = 0; i < InputCount(); ++i) {
if (i > 0) f->AddString(", ");
if (InputAt(i) != NULL) InputAt(i)->PrintTo(f);
}
}
void Definition::PrintTo(BaseTextBuffer* f) const {
PrintUse(f, *this);
if (HasSSATemp() || HasTemp()) f->AddString(" <- ");
if (GetDeoptId() != DeoptId::kNone) {
f->Printf("%s:%" Pd "(", DebugName(), GetDeoptId());
} else {
f->Printf("%s(", DebugName());
}
PrintOperandsTo(f);
f->AddString(")");
if (range_ != NULL) {
f->AddString(" ");
range_->PrintTo(f);
}
if (type_ != NULL) {
f->AddString(" ");
type_->PrintTo(f);
}
}
void CheckNullInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Definition::PrintOperandsTo(f);
switch (exception_type()) {
case kNoSuchMethod:
f->AddString(", NoSuchMethodError");
break;
case kArgumentError:
f->AddString(", ArgumentError");
break;
case kCastError:
f->AddString(", CastError");
break;
}
}
void Definition::PrintOperandsTo(BaseTextBuffer* f) const {
for (int i = 0; i < InputCount(); ++i) {
if (i > 0) f->AddString(", ");
if (InputAt(i) != NULL) {
InputAt(i)->PrintTo(f);
}
}
}
void RedefinitionInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Definition::PrintOperandsTo(f);
if (constrained_type_ != nullptr) {
f->Printf(" ^ %s", constrained_type_->ToCString());
}
}
void ReachabilityFenceInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
}
const char* Value::ToCString() const {
char buffer[1024];
BufferFormatter f(buffer, sizeof(buffer));
PrintTo(&f);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
void Value::PrintTo(BaseTextBuffer* f) const {
PrintUse(f, *definition());
if ((reaching_type_ != NULL) && (reaching_type_ != definition()->type_)) {
f->AddString(" ");
reaching_type_->PrintTo(f);
}
}
void ConstantInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const char* cstr = value().ToCString();
const char* new_line = strchr(cstr, '\n');
if (new_line == NULL) {
f->Printf("#%s", cstr);
} else {
const intptr_t pos = new_line - cstr;
char* buffer = Thread::Current()->zone()->Alloc<char>(pos + 1);
strncpy(buffer, cstr, pos);
buffer[pos] = '\0';
f->Printf("#%s\\n...", buffer);
}
if (representation() != kNoRepresentation && representation() != kTagged) {
f->Printf(" %s", RepresentationToCString(representation()));
}
}
void ConstraintInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
f->AddString(" ^ ");
constraint()->PrintTo(f);
}
void Range::PrintTo(BaseTextBuffer* f) const {
f->AddString("[");
min_.PrintTo(f);
f->AddString(", ");
max_.PrintTo(f);
f->AddString("]");
}
const char* Range::ToCString(const Range* range) {
if (range == NULL) return "[_|_, _|_]";
char buffer[256];
BufferFormatter f(buffer, sizeof(buffer));
range->PrintTo(&f);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
void RangeBoundary::PrintTo(BaseTextBuffer* f) const {
switch (kind_) {
case kSymbol:
f->Printf("v%" Pd "",
reinterpret_cast<Definition*>(value_)->ssa_temp_index());
if (offset_ != 0) f->Printf("%+" Pd64 "", offset_);
break;
case kNegativeInfinity:
f->AddString("-inf");
break;
case kPositiveInfinity:
f->AddString("+inf");
break;
case kConstant:
f->Printf("%" Pd64 "", value_);
break;
case kUnknown:
f->AddString("_|_");
break;
}
}
const char* RangeBoundary::ToCString() const {
char buffer[256];
BufferFormatter f(buffer, sizeof(buffer));
PrintTo(&f);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
void MakeTempInstr::PrintOperandsTo(BaseTextBuffer* f) const {}
void DropTempsInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%" Pd "", num_temps());
if (value() != NULL) {
f->AddString(", ");
value()->PrintTo(f);
}
}
void AssertAssignableInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
f->AddString(", ");
dst_type()->PrintTo(f);
f->Printf(", '%s',", dst_name().ToCString());
f->AddString(" instantiator_type_args(");
instantiator_type_arguments()->PrintTo(f);
f->AddString("), function_type_args(");
function_type_arguments()->PrintTo(f);
f->AddString(")");
}
void AssertSubtypeInstr::PrintOperandsTo(BaseTextBuffer* f) const {
sub_type()->PrintTo(f);
f->AddString(", ");
super_type()->PrintTo(f);
f->AddString(", ");
dst_name()->PrintTo(f);
f->AddString(", instantiator_type_args(");
instantiator_type_arguments()->PrintTo(f);
f->AddString("), function_type_args(");
function_type_arguments()->PrintTo(f);
f->AddString(")");
}
void AssertBooleanInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
}
void ClosureCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
if (FLAG_precompiled_mode) {
f->AddString(" closure=");
} else {
f->AddString(" function=");
}
InputAt(InputCount() - 1)->PrintTo(f);
f->Printf("<%" Pd ">", type_args_len());
for (intptr_t i = 0; i < ArgumentCount(); ++i) {
f->AddString(", ");
ArgumentValueAt(i)->PrintTo(f);
}
}
void InstanceCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf(" %s<%" Pd ">", function_name().ToCString(), type_args_len());
for (intptr_t i = 0; i < ArgumentCount(); ++i) {
f->AddString(", ");
ArgumentValueAt(i)->PrintTo(f);
}
if (HasICData()) {
if (FLAG_display_sorted_ic_data) {
PrintICDataSortedHelper(f, *ic_data());
} else {
PrintICDataHelper(f, *ic_data(), FlowGraphPrinter::kPrintAll);
}
}
if (result_type() != nullptr) {
f->Printf(", result_type = %s", result_type()->ToCString());
}
if (entry_kind() == Code::EntryKind::kUnchecked) {
f->AddString(" using unchecked entrypoint");
}
}
void PolymorphicInstanceCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf(" %s<%" Pd ">", function_name().ToCString(), type_args_len());
for (intptr_t i = 0; i < ArgumentCount(); ++i) {
f->AddString(", ");
ArgumentValueAt(i)->PrintTo(f);
}
PrintTargetsHelper(f, targets_, FlowGraphPrinter::kPrintAll);
if (complete()) {
f->AddString(" COMPLETE");
}
if (entry_kind() == Code::EntryKind::kUnchecked) {
f->AddString(" using unchecked entrypoint");
}
}
void DispatchTableCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const String& name =
String::Handle(interface_target().QualifiedUserVisibleName());
f->AddString(" cid=");
class_id()->PrintTo(f);
f->Printf(" %s<%" Pd ">", name.ToCString(), type_args_len());
for (intptr_t i = 0; i < ArgumentCount(); ++i) {
f->AddString(", ");
ArgumentValueAt(i)->PrintTo(f);
}
}
void StrictCompareInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", Token::Str(kind()));
left()->PrintTo(f);
f->AddString(", ");
right()->PrintTo(f);
if (needs_number_check()) {
f->Printf(", with number check");
}
}
void TestCidsInstr::PrintOperandsTo(BaseTextBuffer* f) const {
left()->PrintTo(f);
f->Printf(" %s [", Token::Str(kind()));
intptr_t length = cid_results().length();
for (intptr_t i = 0; i < length; i += 2) {
f->Printf("0x%" Px ":%s ", cid_results()[i],
cid_results()[i + 1] == 0 ? "false" : "true");
}
f->AddString("] ");
if (CanDeoptimize()) {
ASSERT(deopt_id() != DeoptId::kNone);
f->AddString("else deoptimize ");
} else {
ASSERT(deopt_id() == DeoptId::kNone);
f->Printf("else %s ", cid_results()[length - 1] != 0 ? "false" : "true");
}
}
void EqualityCompareInstr::PrintOperandsTo(BaseTextBuffer* f) const {
left()->PrintTo(f);
f->Printf(" %s ", Token::Str(kind()));
right()->PrintTo(f);
}
void StaticCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf(" %s<%" Pd "> ", String::Handle(function().name()).ToCString(),
type_args_len());
for (intptr_t i = 0; i < ArgumentCount(); ++i) {
if (i > 0) f->AddString(", ");
ArgumentValueAt(i)->PrintTo(f);
}
if (entry_kind() == Code::EntryKind::kUnchecked) {
f->AddString(", using unchecked entrypoint");
}
if (function().recognized_kind() != MethodRecognizer::kUnknown) {
f->Printf(", recognized_kind = %s",
MethodRecognizer::KindToCString(function().recognized_kind()));
}
if (result_type() != nullptr) {
f->Printf(", result_type = %s", result_type()->ToCString());
}
}
void LoadLocalInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s @%d", local().name().ToCString(), local().index().value());
}
void StoreLocalInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s @%d, ", local().name().ToCString(), local().index().value());
value()->PrintTo(f);
}
void NativeCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", native_name().ToCString());
}
void GuardFieldInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s %s, ", String::Handle(field().name()).ToCString(),
field().GuardedPropertiesAsCString());
value()->PrintTo(f);
}
void StoreInstanceFieldInstr::PrintOperandsTo(BaseTextBuffer* f) const {
instance()->PrintTo(f);
f->Printf(" . %s = ", slot().Name());
value()->PrintTo(f);
// Here, we just print the value of the enum field. We would prefer to get
// the final decision on whether a store barrier will be emitted by calling
// ShouldEmitStoreBarrier(), but that can change parts of the flow graph.
if (emit_store_barrier_ == kNoStoreBarrier) {
f->AddString(", NoStoreBarrier");
}
}
void IfThenElseInstr::PrintOperandsTo(BaseTextBuffer* f) const {
comparison()->PrintOperandsTo(f);
f->Printf(" ? %" Pd " : %" Pd, if_true_, if_false_);
}
void LoadStaticFieldInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", String::Handle(field().name()).ToCString());
if (calls_initializer()) {
f->AddString(", CallsInitializer");
}
}
void StoreStaticFieldInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", String::Handle(field().name()).ToCString());
value()->PrintTo(f);
}
void InstanceOfInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
f->Printf(" IS %s,", String::Handle(type().Name()).ToCString());
f->AddString(" instantiator_type_args(");
instantiator_type_arguments()->PrintTo(f);
f->AddString("), function_type_args(");
function_type_arguments()->PrintTo(f);
f->AddString(")");
}
void RelationalOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", Token::Str(kind()));
left()->PrintTo(f);
f->AddString(", ");
right()->PrintTo(f);
}
void AllocationInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Definition::PrintOperandsTo(f);
if (Identity().IsNotAliased()) {
if (InputCount() > 0) {
f->AddString(", ");
}
f->AddString("<not-aliased>");
}
}
void AllocateObjectInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("cls=%s", String::Handle(cls().ScrubbedName()).ToCString());
if (InputCount() > 0 || Identity().IsNotAliased()) {
f->AddString(", ");
}
AllocationInstr::PrintOperandsTo(f);
}
void MaterializeObjectInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", String::Handle(cls_.ScrubbedName()).ToCString());
for (intptr_t i = 0; i < InputCount(); i++) {
f->AddString(", ");
f->Printf("%s: ", slots_[i]->Name());
InputAt(i)->PrintTo(f);
}
}
void LoadFieldInstr::PrintOperandsTo(BaseTextBuffer* f) const {
instance()->PrintTo(f);
f->Printf(" . %s%s", slot().Name(), slot().is_immutable() ? " {final}" : "");
if (calls_initializer()) {
f->AddString(", CallsInitializer");
}
}
void LoadUntaggedInstr::PrintOperandsTo(BaseTextBuffer* f) const {
object()->PrintTo(f);
f->Printf(", %" Pd, offset());
}
void InstantiateTypeInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const String& type_name = String::Handle(type().Name());
f->Printf("%s,", type_name.ToCString());
f->AddString(" instantiator_type_args(");
instantiator_type_arguments()->PrintTo(f);
f->AddString("), function_type_args(");
function_type_arguments()->PrintTo(f);
f->AddString(")");
}
void InstantiateTypeArgumentsInstr::PrintOperandsTo(BaseTextBuffer* f) const {
type_arguments()->PrintTo(f);
f->AddString(", instantiator_type_args(");
instantiator_type_arguments()->PrintTo(f);
f->AddString("), function_type_args(");
function_type_arguments()->PrintTo(f);
f->Printf(")");
if (!instantiator_class().IsNull()) {
f->Printf(", instantiator_class(%s)", instantiator_class().ToCString());
}
}
void AllocateContextInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("num_variables=%" Pd "", num_context_variables());
if (InputCount() > 0 || Identity().IsNotAliased()) {
f->AddString(", ");
}
TemplateAllocation::PrintOperandsTo(f);
}
void AllocateUninitializedContextInstr::PrintOperandsTo(
BaseTextBuffer* f) const {
f->Printf("num_variables=%" Pd "", num_context_variables());
if (InputCount() > 0 || Identity().IsNotAliased()) {
f->AddString(", ");
}
TemplateAllocation::PrintOperandsTo(f);
}
void MathUnaryInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("'%s', ", MathUnaryInstr::KindToCString(kind()));
value()->PrintTo(f);
}
void TruncDivModInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Definition::PrintOperandsTo(f);
}
void ExtractNthOutputInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("Extract %" Pd " from ", index());
Definition::PrintOperandsTo(f);
}
void UnaryIntegerOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", Token::Str(op_kind()));
value()->PrintTo(f);
}
void BinaryIntegerOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", Token::Str(op_kind()));
if (is_truncating()) {
f->AddString(" [tr]");
} else if (!can_overflow()) {
f->AddString(" [-o]");
}
f->AddString(", ");
left()->PrintTo(f);
f->AddString(", ");
right()->PrintTo(f);
}
void BinaryDoubleOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", Token::Str(op_kind()));
left()->PrintTo(f);
f->AddString(", ");
right()->PrintTo(f);
}
void DoubleTestOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
switch (op_kind()) {
case MethodRecognizer::kDouble_getIsNaN:
f->AddString("IsNaN ");
break;
case MethodRecognizer::kDouble_getIsInfinite:
f->AddString("IsInfinite ");
break;
default:
UNREACHABLE();
}
value()->PrintTo(f);
}
static const char* const simd_op_kind_string[] = {
#define CASE(Arity, Mask, Name, ...) #Name,
SIMD_OP_LIST(CASE, CASE)
#undef CASE
};
void SimdOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", simd_op_kind_string[kind()]);
if (HasMask()) {
f->Printf(", mask = %" Pd "", mask());
}
for (intptr_t i = 0; i < InputCount(); i++) {
f->AddString(", ");
InputAt(i)->PrintTo(f);
}
}
void UnaryDoubleOpInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", Token::Str(op_kind()));
value()->PrintTo(f);
}
void LoadClassIdInstr::PrintOperandsTo(BaseTextBuffer* f) const {
if (!input_can_be_smi_) {
f->AddString("<non-smi> ");
}
object()->PrintTo(f);
}
void CheckClassIdInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
const Class& cls = Class::Handle(
IsolateGroup::Current()->class_table()->At(cids().cid_start));
const String& name = String::Handle(cls.ScrubbedName());
if (cids().IsSingleCid()) {
f->Printf(", %s", name.ToCString());
} else {
const Class& cls2 = Class::Handle(
IsolateGroup::Current()->class_table()->At(cids().cid_end));
const String& name2 = String::Handle(cls2.ScrubbedName());
f->Printf(", cid %" Pd "-%" Pd " %s-%s", cids().cid_start, cids().cid_end,
name.ToCString(), name2.ToCString());
}
}
void CheckClassInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
PrintCidsHelper(f, cids_, FlowGraphPrinter::kPrintAll);
if (IsNullCheck()) {
f->AddString(" nullcheck");
}
}
void CheckConditionInstr::PrintOperandsTo(BaseTextBuffer* f) const {
comparison()->PrintOperandsTo(f);
}
void InvokeMathCFunctionInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s, ", MethodRecognizer::KindToCString(recognized_kind_));
Definition::PrintOperandsTo(f);
}
void BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(
BaseTextBuffer* f) const {
const GrowableArray<Definition*>& defns = initial_definitions_;
if (defns.length() > 0) {
f->AddString(" {");
for (intptr_t i = 0; i < defns.length(); ++i) {
Definition* def = defns[i];
// Skip constants which are not used in the graph.
if (def->IsConstant() && !def->HasUses()) continue;
f->AddString("\n ");
def->PrintTo(f);
}
f->AddString("\n}");
}
}
void GraphEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[graph]:%" Pd, block_id(), GetDeoptId());
BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(f);
}
void JoinEntryInstr::PrintTo(BaseTextBuffer* f) const {
if (try_index() != kInvalidTryIndex) {
f->Printf("B%" Pd "[join try_idx %" Pd "]:%" Pd " pred(", block_id(),
try_index(), GetDeoptId());
} else {
f->Printf("B%" Pd "[join]:%" Pd " pred(", block_id(), GetDeoptId());
}
for (intptr_t i = 0; i < predecessors_.length(); ++i) {
if (i > 0) f->AddString(", ");
f->Printf("B%" Pd, predecessors_[i]->block_id());
}
f->AddString(")");
if (phis_ != NULL) {
f->AddString(" {");
for (intptr_t i = 0; i < phis_->length(); ++i) {
if ((*phis_)[i] == NULL) continue;
f->AddString("\n ");
(*phis_)[i]->PrintTo(f);
}
f->AddString("\n}");
}
if (HasParallelMove()) {
f->AddString(" ");
parallel_move()->PrintTo(f);
}
}
void IndirectEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[join indirect", block_id());
if (try_index() != kInvalidTryIndex) {
f->Printf(" try_idx %" Pd, try_index());
}
f->Printf("]:%" Pd " pred(", GetDeoptId());
for (intptr_t i = 0; i < predecessors_.length(); ++i) {
if (i > 0) f->AddString(", ");
f->Printf("B%" Pd, predecessors_[i]->block_id());
}
f->AddString(")");
if (phis_ != NULL) {
f->AddString(" {");
for (intptr_t i = 0; i < phis_->length(); ++i) {
if ((*phis_)[i] == NULL) continue;
f->AddString("\n ");
(*phis_)[i]->PrintTo(f);
}
f->AddString("\n}");
}
if (HasParallelMove()) {
f->AddString(" ");
parallel_move()->PrintTo(f);
}
}
const char* RepresentationToCString(Representation rep) {
switch (rep) {
case kTagged:
return "tagged";
case kUntagged:
return "untagged";
case kUnboxedDouble:
return "double";
case kUnboxedFloat:
return "float";
case kUnboxedUint8:
return "uint8";
case kUnboxedUint16:
return "uint16";
case kUnboxedInt32:
return "int32";
case kUnboxedUint32:
return "uint32";
case kUnboxedInt64:
return "int64";
case kUnboxedFloat32x4:
return "float32x4";
case kUnboxedInt32x4:
return "int32x4";
case kUnboxedFloat64x2:
return "float64x2";
case kPairOfTagged:
return "tagged-pair";
case kNoRepresentation:
return "none";
case kNumRepresentations:
UNREACHABLE();
}
return "?";
}
void PhiInstr::PrintTo(BaseTextBuffer* f) const {
if (HasPairRepresentation()) {
f->Printf("(v%" Pd ", v%" Pd ") <- phi(", ssa_temp_index(),
ssa_temp_index() + 1);
} else {
f->Printf("v%" Pd " <- phi(", ssa_temp_index());
}
for (intptr_t i = 0; i < inputs_.length(); ++i) {
if (inputs_[i] != NULL) inputs_[i]->PrintTo(f);
if (i < inputs_.length() - 1) f->AddString(", ");
}
f->AddString(")");
f->AddString(is_alive() ? " alive" : " dead");
if (range_ != NULL) {
f->AddString(" ");
range_->PrintTo(f);
}
if (representation() != kNoRepresentation && representation() != kTagged) {
f->Printf(" %s", RepresentationToCString(representation()));
}
if (HasType()) {
f->Printf(" %s", TypeAsCString());
}
}
void UnboxIntegerInstr::PrintOperandsTo(BaseTextBuffer* f) const {
if (is_truncating()) {
f->AddString("[tr], ");
}
if (SpeculativeModeOfInputs() == kGuardInputs) {
f->AddString("[guard-inputs], ");
} else {
f->AddString("[non-speculative], ");
}
Definition::PrintOperandsTo(f);
}
void IntConverterInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s->%s%s, ", RepresentationToCString(from()),
RepresentationToCString(to()), is_truncating() ? "[tr]" : "");
Definition::PrintOperandsTo(f);
}
void BitCastInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Definition::PrintOperandsTo(f);
f->Printf(" (%s -> %s)", RepresentationToCString(from()),
RepresentationToCString(to()));
}
void ParameterInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%" Pd, index());
}
void SpecialParameterInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s", KindToCString(kind()));
}
const char* SpecialParameterInstr::ToCString() const {
char buffer[1024];
BufferFormatter bf(buffer, 1024);
PrintTo(&bf);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
void CheckStackOverflowInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("stack=%" Pd ", loop=%" Pd, stack_depth(), loop_depth());
}
void TargetEntryInstr::PrintTo(BaseTextBuffer* f) const {
if (try_index() != kInvalidTryIndex) {
f->Printf("B%" Pd "[target try_idx %" Pd "]:%" Pd, block_id(), try_index(),
GetDeoptId());
} else {
f->Printf("B%" Pd "[target]:%" Pd, block_id(), GetDeoptId());
}
if (HasParallelMove()) {
f->AddString(" ");
parallel_move()->PrintTo(f);
}
}
void OsrEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[osr entry]:%" Pd " stack_depth=%" Pd, block_id(),
GetDeoptId(), stack_depth());
if (HasParallelMove()) {
f->AddString("\n");
parallel_move()->PrintTo(f);
}
BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(f);
}
void FunctionEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[function entry]:%" Pd, block_id(), GetDeoptId());
if (HasParallelMove()) {
f->AddString("\n");
parallel_move()->PrintTo(f);
}
BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(f);
}
void NativeEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[native function entry]:%" Pd, block_id(), GetDeoptId());
if (HasParallelMove()) {
f->AddString("\n");
parallel_move()->PrintTo(f);
}
BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(f);
}
void ReturnInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Instruction::PrintOperandsTo(f);
if (yield_index() != UntaggedPcDescriptors::kInvalidYieldIndex) {
f->Printf(", yield_index = %" Pd "", yield_index());
}
}
void FfiCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->AddString(" pointer=");
InputAt(TargetAddressIndex())->PrintTo(f);
if (marshaller_.PassTypedData()) {
f->AddString(", typed_data=");
InputAt(TypedDataIndex())->PrintTo(f);
}
intptr_t def_index = 0;
for (intptr_t arg_index = 0; arg_index < marshaller_.num_args();
arg_index++) {
const auto& arg_location = marshaller_.Location(arg_index);
const bool is_compound = arg_location.container_type().IsCompound();
const intptr_t num_defs = marshaller_.NumDefinitions(arg_index);
f->AddString(", ");
if (is_compound) f->AddString("(");
for (intptr_t i = 0; i < num_defs; i++) {
InputAt(def_index)->PrintTo(f);
if ((i + 1) < num_defs) f->AddString(", ");
def_index++;
}
if (is_compound) f->AddString(")");
f->AddString(" (@");
arg_location.PrintTo(f);
f->AddString(")");
}
}
void CCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->AddString(" target_address=");
InputAt(TargetAddressIndex())->PrintTo(f);
const auto& argument_locations =
native_calling_convention_.argument_locations();
for (intptr_t i = 0; i < argument_locations.length(); i++) {
const auto& arg_location = *argument_locations.At(i);
f->AddString(", ");
InputAt(i)->PrintTo(f);
f->AddString(" (@");
arg_location.PrintTo(f);
f->AddString(")");
}
}
void NativeReturnInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
f->AddString(" (@");
marshaller_.Location(compiler::ffi::kResultIndex).PrintTo(f);
f->AddString(")");
}
void NativeParameterInstr::PrintOperandsTo(BaseTextBuffer* f) const {
// Where the calling convention puts it.
marshaller_.Location(marshaller_.ArgumentIndex(def_index_)).PrintTo(f);
f->AddString(" at ");
// Where the arguments are when pushed on the stack.
marshaller_.NativeLocationOfNativeParameter(def_index_).PrintTo(f);
}
void CatchBlockEntryInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("B%" Pd "[target catch try_idx %" Pd " catch_try_idx %" Pd "]",
block_id(), try_index(), catch_try_index());
if (HasParallelMove()) {
f->AddString("\n");
parallel_move()->PrintTo(f);
}
BlockEntryWithInitialDefs::PrintInitialDefinitionsTo(f);
}
void LoadIndexedUnsafeInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s[", RegisterNames::RegisterName(base_reg()));
index()->PrintTo(f);
f->Printf(" + %" Pd "]", offset());
}
void StoreIndexedUnsafeInstr::PrintOperandsTo(BaseTextBuffer* f) const {
f->Printf("%s[", RegisterNames::RegisterName(base_reg()));
index()->PrintTo(f);
f->Printf(" + %" Pd "], ", offset());
value()->PrintTo(f);
}
void StoreIndexedInstr::PrintOperandsTo(BaseTextBuffer* f) const {
Instruction::PrintOperandsTo(f);
if (!ShouldEmitStoreBarrier()) {
f->AddString(", NoStoreBarrier");
}
}
void TailCallInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const char* name = "<unknown code>";
if (code_.IsStubCode()) {
name = StubCode::NameOfStub(code_.EntryPoint());
} else {
const Object& owner = Object::Handle(code_.owner());
if (owner.IsFunction()) {
name = Function::Handle(Function::RawCast(owner.ptr()))
.ToFullyQualifiedCString();
}
}
f->Printf("%s(", name);
InputAt(0)->PrintTo(f);
f->AddString(")");
}
void Call1ArgStubInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const char* name = "";
switch (stub_id_) {
case StubId::kCloneSuspendState:
name = "CloneSuspendState";
break;
case StubId::kInitAsync:
name = "InitAsync";
break;
case StubId::kInitAsyncStar:
name = "InitAsyncStar";
break;
case StubId::kInitSyncStar:
name = "InitSyncStar";
break;
}
f->Printf("%s(", name);
operand()->PrintTo(f);
f->AddString(")");
}
void SuspendInstr::PrintOperandsTo(BaseTextBuffer* f) const {
const char* name = "";
switch (stub_id_) {
case StubId::kAwait:
name = "Await";
break;
case StubId::kYieldAsyncStar:
name = "YieldAsyncStar";
break;
case StubId::kYieldSyncStar:
name = "YieldSyncStar";
break;
}
f->Printf("%s(", name);
operand()->PrintTo(f);
f->AddString(")");
}
void PushArgumentInstr::PrintOperandsTo(BaseTextBuffer* f) const {
value()->PrintTo(f);
}
void GotoInstr::PrintTo(BaseTextBuffer* f) const {
if (HasParallelMove()) {
parallel_move()->PrintTo(f);
f->AddString(" ");
}
if (GetDeoptId() != DeoptId::kNone) {
f->Printf("goto:%" Pd " B%" Pd "", GetDeoptId(), successor()->block_id());
} else {
f->Printf("goto: B%" Pd "", successor()->block_id());
}
}
void IndirectGotoInstr::PrintTo(BaseTextBuffer* f) const {
if (GetDeoptId() != DeoptId::kNone) {
f->Printf("igoto:%" Pd "(", GetDeoptId());
} else {
f->AddString("igoto:(");
}
InputAt(0)->PrintTo(f);
f->AddString(")");
}
void BranchInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("%s ", DebugName());
f->AddString("if ");
comparison()->PrintTo(f);
f->Printf(" goto (%" Pd ", %" Pd ")", true_successor()->block_id(),
false_successor()->block_id());
}
void ParallelMoveInstr::PrintTo(BaseTextBuffer* f) const {
f->Printf("%s ", DebugName());
for (intptr_t i = 0; i < moves_.length(); i++) {
if (i != 0) f->AddString(", ");
moves_[i]->dest().PrintTo(f);
f->AddString(" <- ");
moves_[i]->src().PrintTo(f);
}
}
void Utf8ScanInstr::PrintTo(BaseTextBuffer* f) const {
Definition::PrintTo(f);
f->Printf(" [%s]", scan_flags_field_.Name());
}
void Environment::PrintTo(BaseTextBuffer* f) const {
f->AddString(" env={ ");
int arg_count = 0;
for (intptr_t i = 0; i < values_.length(); ++i) {
if (i > 0) f->AddString(", ");
if (values_[i]->definition()->IsPushArgument()) {
f->Printf("a%d", arg_count++);
} else {
values_[i]->PrintTo(f);
}
if ((locations_ != NULL) && !locations_[i].IsInvalid()) {
f->AddString(" [");
locations_[i].PrintTo(f);
f->AddString("]");
}
}
f->AddString(" }");
if (outer_ != NULL) outer_->PrintTo(f);
}
const char* Environment::ToCString() const {
char buffer[1024];
BufferFormatter bf(buffer, 1024);
PrintTo(&bf);
return Thread::Current()->zone()->MakeCopyOfString(buffer);
}
#else // defined(INCLUDE_IL_PRINTER)
const char* Instruction::ToCString() const {
return DebugName();
}
void FlowGraphPrinter::PrintOneInstruction(Instruction* instr,
bool print_locations) {
UNREACHABLE();
}
void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
TokenPosition token_pos,
Value* value,
const AbstractType& dst_type,
const String& dst_name,
bool eliminated) {
UNREACHABLE();
}
void FlowGraphPrinter::PrintBlock(BlockEntryInstr* block,
bool print_locations) {
UNREACHABLE();
}
void FlowGraphPrinter::PrintGraph(const char* phase, FlowGraph* flow_graph) {
UNREACHABLE();
}
void FlowGraphPrinter::PrintICData(const ICData& ic_data,
intptr_t num_checks_to_print) {
UNREACHABLE();
}
bool FlowGraphPrinter::ShouldPrint(
const Function& function,
uint8_t** compiler_pass_filter /* = nullptr */) {
return false;
}
#endif // defined(INCLUDE_IL_PRINTER)
} // namespace dart