blob: c50e82d4e027c34fc504f4135e0eefdcce5162a4 [file] [log] [blame]
// Copyright (c) 2018, 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/compiler_state.h"
#include <functional>
#include "vm/compiler/aot/precompiler.h"
#include "vm/compiler/backend/flow_graph_compiler.h"
#include "vm/compiler/backend/il_printer.h"
#include "vm/compiler/backend/slot.h"
#include "vm/growable_array.h"
#include "vm/scopes.h"
namespace dart {
template <typename T>
T* PutIfAbsent(Thread* thread,
ZoneGrowableArray<T*>** array_slot,
intptr_t index,
std::function<T*()> create) {
auto array = *array_slot;
if (array == nullptr) {
Zone* const Z = thread->zone();
*array_slot = array = new (Z) ZoneGrowableArray<T*>(Z, index + 1);
}
while (array->length() <= index) {
array->Add(nullptr);
}
if (array->At(index) == nullptr) {
(*array)[index] = create();
}
return array->At(index);
}
LocalVariable* CompilerState::GetDummyCapturedVariable(intptr_t context_id,
intptr_t index) {
return PutIfAbsent<LocalVariable>(
thread(), &dummy_captured_vars_, index, [&]() {
Zone* const Z = thread()->zone();
const AbstractType& dynamic_type =
AbstractType::ZoneHandle(Z, Type::DynamicType());
const String& name = String::ZoneHandle(
Z, Symbols::NewFormatted(thread(), ":context_var%" Pd, index));
LocalVariable* var = new (Z)
LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
name, dynamic_type, /*param_type=*/nullptr);
var->set_is_captured();
var->set_index(VariableIndex(index));
return var;
});
}
const ZoneGrowableArray<const Slot*>& CompilerState::GetDummyContextSlots(
intptr_t context_id,
intptr_t num_context_variables) {
return *PutIfAbsent<ZoneGrowableArray<const Slot*>>(
thread(), &dummy_slots_, num_context_variables, [&]() {
Zone* const Z = thread()->zone();
auto slots =
new (Z) ZoneGrowableArray<const Slot*>(num_context_variables);
for (intptr_t i = 0; i < num_context_variables; i++) {
LocalVariable* var = GetDummyCapturedVariable(context_id, i);
slots->Add(&Slot::GetContextVariableSlotFor(thread(), *var));
}
return slots;
});
}
CompilerTracing CompilerState::ShouldTrace(const Function& func) {
return FlowGraphPrinter::ShouldPrint(func) ? CompilerTracing::kOn
: CompilerTracing::kOff;
}
const Class& CompilerState::ComparableClass() {
if (comparable_class_ == nullptr) {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
// When obfuscation is enabled we need to obfuscate the name of the
// class before looking it up.
String& name = String::Handle(zone, Symbols::New(thread, "Comparable"));
if (thread->isolate_group()->obfuscate()) {
Obfuscator obfuscator(thread, Object::null_string());
name = obfuscator.Rename(name);
}
const Library& lib = Library::Handle(zone, Library::CoreLibrary());
const Class& cls = Class::ZoneHandle(zone, lib.LookupClass(name));
ASSERT(!cls.IsNull());
comparable_class_ = &cls;
}
return *comparable_class_;
}
const Function& CompilerState::StringBaseInterpolateSingle() {
if (interpolate_single_ == nullptr) {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
const Class& cls =
Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
ASSERT(!cls.IsNull());
interpolate_single_ = &Function::ZoneHandle(
zone, cls.LookupFunctionAllowPrivate(Symbols::InterpolateSingle()));
ASSERT(!interpolate_single_->IsNull());
}
return *interpolate_single_;
}
const Function& CompilerState::StringBaseInterpolate() {
if (interpolate_ == nullptr) {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
const Class& cls =
Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
ASSERT(!cls.IsNull());
interpolate_ = &Function::ZoneHandle(
zone, cls.LookupFunctionAllowPrivate(Symbols::Interpolate()));
ASSERT(!interpolate_->IsNull());
}
return *interpolate_;
}
void CompilerState::ReportCrash() {
OS::PrintErr("=== Crash occurred when compiling %s in %s mode in %s pass\n",
function() != nullptr ? function()->ToFullyQualifiedCString()
: "unknown function",
is_aot() ? "AOT"
: is_optimizing() ? "optimizing JIT"
: "unoptimized JIT",
pass() != nullptr ? pass()->name() : "unknown");
if (pass_state() != nullptr && pass()->id() == CompilerPass::kGenerateCode) {
if (pass_state()->graph_compiler->current_block() != nullptr) {
OS::PrintErr("=== When compiling block %s\n",
pass_state()->graph_compiler->current_block()->ToCString());
}
if (pass_state()->graph_compiler->current_instruction() != nullptr) {
OS::PrintErr(
"=== When compiling instruction %s\n",
pass_state()->graph_compiler->current_instruction()->ToCString());
}
}
if (pass_state() != nullptr && pass_state()->flow_graph() != nullptr) {
pass_state()->flow_graph()->Print(pass()->name());
} else {
OS::PrintErr("=== Flow Graph not available\n");
}
}
} // namespace dart