Ryan Macnak
679a1a7867
Bug: https://github.com/dart-lang/sdk/issues/35224 Change-Id: I867b47a95d7b38e511259b06ef24424d8809096d Reviewed-on: https://dart-review.googlesource.com/c/85861 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Martin Kustermann <kustermann@google.com>
724 lines
27 KiB
C++
724 lines
27 KiB
C++
// Copyright (c) 2016, 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/kernel.h"
|
|
|
|
#include "vm/compiler/frontend/constant_evaluator.h"
|
|
#include "vm/compiler/frontend/kernel_translation_helper.h"
|
|
#include "vm/longjump.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/parser.h" // For Parser::kParameter* constants.
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
namespace dart {
|
|
namespace kernel {
|
|
|
|
bool FieldHasFunctionLiteralInitializer(const Field& field,
|
|
TokenPosition* start,
|
|
TokenPosition* end) {
|
|
Zone* zone = Thread::Current()->zone();
|
|
const Script& script = Script::Handle(zone, field.Script());
|
|
|
|
TranslationHelper translation_helper(Thread::Current());
|
|
translation_helper.InitFromScript(script);
|
|
|
|
KernelReaderHelper kernel_reader_helper(
|
|
zone, &translation_helper, Script::Handle(zone, field.Script()),
|
|
ExternalTypedData::Handle(zone, field.KernelData()),
|
|
field.KernelDataProgramOffset());
|
|
kernel_reader_helper.SetOffset(field.kernel_offset());
|
|
kernel::FieldHelper field_helper(&kernel_reader_helper);
|
|
field_helper.ReadUntilExcluding(kernel::FieldHelper::kEnd, true);
|
|
return field_helper.FieldHasFunctionLiteralInitializer(start, end);
|
|
}
|
|
|
|
KernelLineStartsReader::KernelLineStartsReader(
|
|
const dart::TypedData& line_starts_data,
|
|
dart::Zone* zone)
|
|
: line_starts_data_(line_starts_data) {
|
|
TypedDataElementType type = line_starts_data_.ElementType();
|
|
if (type == kInt8ArrayElement) {
|
|
helper_ = new KernelInt8LineStartsHelper();
|
|
} else if (type == kInt16ArrayElement) {
|
|
helper_ = new KernelInt16LineStartsHelper();
|
|
} else if (type == kInt32ArrayElement) {
|
|
helper_ = new KernelInt32LineStartsHelper();
|
|
} else {
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
intptr_t KernelLineStartsReader::LineNumberForPosition(
|
|
intptr_t position) const {
|
|
intptr_t line_count = line_starts_data_.Length();
|
|
intptr_t current_start = 0;
|
|
for (intptr_t i = 0; i < line_count; ++i) {
|
|
current_start += helper_->At(line_starts_data_, i);
|
|
if (current_start > position) {
|
|
// If current_start is greater than the desired position, it means that
|
|
// it is for the line after |position|. However, since line numbers
|
|
// start at 1, we just return |i|.
|
|
return i;
|
|
}
|
|
|
|
if (current_start == position) {
|
|
return i + 1;
|
|
}
|
|
}
|
|
return line_count;
|
|
}
|
|
|
|
void KernelLineStartsReader::LocationForPosition(intptr_t position,
|
|
intptr_t* line,
|
|
intptr_t* col) const {
|
|
intptr_t line_count = line_starts_data_.Length();
|
|
intptr_t current_start = 0;
|
|
intptr_t previous_start = 0;
|
|
for (intptr_t i = 0; i < line_count; ++i) {
|
|
current_start += helper_->At(line_starts_data_, i);
|
|
if (current_start > position) {
|
|
*line = i;
|
|
if (col != NULL) {
|
|
*col = position - previous_start + 1;
|
|
}
|
|
return;
|
|
}
|
|
if (current_start == position) {
|
|
*line = i + 1;
|
|
if (col != NULL) {
|
|
*col = 1;
|
|
}
|
|
return;
|
|
}
|
|
previous_start = current_start;
|
|
}
|
|
|
|
// If the start of any of the lines did not cross |position|,
|
|
// then it means the position falls on the last line.
|
|
*line = line_count;
|
|
if (col != NULL) {
|
|
*col = position - current_start + 1;
|
|
}
|
|
}
|
|
|
|
void KernelLineStartsReader::TokenRangeAtLine(
|
|
intptr_t source_length,
|
|
intptr_t line_number,
|
|
TokenPosition* first_token_index,
|
|
TokenPosition* last_token_index) const {
|
|
ASSERT(line_number <= line_starts_data_.Length());
|
|
intptr_t cumulative = 0;
|
|
for (intptr_t i = 0; i < line_number; ++i) {
|
|
cumulative += helper_->At(line_starts_data_, i);
|
|
}
|
|
*first_token_index = dart::TokenPosition(cumulative);
|
|
if (line_number == line_starts_data_.Length()) {
|
|
*last_token_index = dart::TokenPosition(source_length);
|
|
} else {
|
|
*last_token_index = dart::TokenPosition(
|
|
cumulative + helper_->At(line_starts_data_, line_number) - 1);
|
|
}
|
|
}
|
|
|
|
int32_t KernelLineStartsReader::KernelInt8LineStartsHelper::At(
|
|
const dart::TypedData& data,
|
|
intptr_t index) const {
|
|
return data.GetInt8(index);
|
|
}
|
|
|
|
int32_t KernelLineStartsReader::KernelInt16LineStartsHelper::At(
|
|
const dart::TypedData& data,
|
|
intptr_t index) const {
|
|
return data.GetInt16(index << 1);
|
|
}
|
|
|
|
int32_t KernelLineStartsReader::KernelInt32LineStartsHelper::At(
|
|
const dart::TypedData& data,
|
|
intptr_t index) const {
|
|
return data.GetInt32(index << 2);
|
|
}
|
|
|
|
class KernelTokenPositionCollector : public KernelReaderHelper {
|
|
public:
|
|
KernelTokenPositionCollector(
|
|
Zone* zone,
|
|
TranslationHelper* translation_helper,
|
|
const Script& script,
|
|
const ExternalTypedData& data,
|
|
intptr_t data_program_offset,
|
|
intptr_t initial_script_index,
|
|
intptr_t record_for_script_id,
|
|
GrowableArray<intptr_t>* record_token_positions_into,
|
|
GrowableArray<intptr_t>* record_yield_positions_into)
|
|
: KernelReaderHelper(zone,
|
|
translation_helper,
|
|
script,
|
|
data,
|
|
data_program_offset),
|
|
current_script_id_(initial_script_index),
|
|
record_for_script_id_(record_for_script_id),
|
|
record_token_positions_into_(record_token_positions_into),
|
|
record_yield_positions_into_(record_yield_positions_into) {}
|
|
|
|
void CollectTokenPositions(intptr_t kernel_offset);
|
|
|
|
void RecordTokenPosition(TokenPosition position) override;
|
|
void RecordYieldPosition(TokenPosition position) override;
|
|
|
|
void set_current_script_id(intptr_t id) override { current_script_id_ = id; }
|
|
|
|
private:
|
|
intptr_t current_script_id_;
|
|
intptr_t record_for_script_id_;
|
|
GrowableArray<intptr_t>* record_token_positions_into_;
|
|
GrowableArray<intptr_t>* record_yield_positions_into_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(KernelTokenPositionCollector);
|
|
};
|
|
|
|
void KernelTokenPositionCollector::CollectTokenPositions(
|
|
intptr_t kernel_offset) {
|
|
SetOffset(kernel_offset);
|
|
|
|
const Tag tag = PeekTag();
|
|
if (tag == kProcedure) {
|
|
ProcedureHelper procedure_helper(this);
|
|
procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
|
|
} else if (tag == kConstructor) {
|
|
ConstructorHelper constructor_helper(this);
|
|
constructor_helper.ReadUntilExcluding(ConstructorHelper::kEnd);
|
|
} else if (tag == kFunctionNode) {
|
|
FunctionNodeHelper function_node_helper(this);
|
|
function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
|
|
} else if (tag == kField) {
|
|
FieldHelper field_helper(this);
|
|
field_helper.ReadUntilExcluding(FieldHelper::kEnd);
|
|
} else if (tag == kClass) {
|
|
ClassHelper class_helper(this);
|
|
class_helper.ReadUntilExcluding(ClassHelper::kEnd);
|
|
} else {
|
|
ReportUnexpectedTag("a class or a member", tag);
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
void KernelTokenPositionCollector::RecordTokenPosition(TokenPosition position) {
|
|
if (record_for_script_id_ == current_script_id_ &&
|
|
record_token_positions_into_ != NULL && position.IsReal()) {
|
|
record_token_positions_into_->Add(position.value());
|
|
}
|
|
}
|
|
|
|
void KernelTokenPositionCollector::RecordYieldPosition(TokenPosition position) {
|
|
if (record_for_script_id_ == current_script_id_ &&
|
|
record_yield_positions_into_ != NULL && position.IsReal()) {
|
|
record_yield_positions_into_->Add(position.value());
|
|
}
|
|
}
|
|
|
|
static int LowestFirst(const intptr_t* a, const intptr_t* b) {
|
|
return *a - *b;
|
|
}
|
|
|
|
/**
|
|
* If index exists as sublist in list, sort the sublist from lowest to highest,
|
|
* then copy it, as Smis and without duplicates,
|
|
* to a new Array in Heap::kOld which is returned.
|
|
* Note that the source list is both sorted and de-duplicated as well, but will
|
|
* possibly contain duplicate and unsorted data at the end.
|
|
* Otherwise (when sublist doesn't exist in list) return new empty array.
|
|
*/
|
|
static RawArray* AsSortedDuplicateFreeArray(GrowableArray<intptr_t>* source) {
|
|
intptr_t size = source->length();
|
|
if (size == 0) {
|
|
return Object::empty_array().raw();
|
|
}
|
|
|
|
source->Sort(LowestFirst);
|
|
|
|
intptr_t last = 0;
|
|
for (intptr_t current = 1; current < size; ++current) {
|
|
if (source->At(last) != source->At(current)) {
|
|
(*source)[++last] = source->At(current);
|
|
}
|
|
}
|
|
Array& array_object = Array::Handle();
|
|
array_object = Array::New(last + 1, Heap::kOld);
|
|
Smi& smi_value = Smi::Handle();
|
|
for (intptr_t i = 0; i <= last; ++i) {
|
|
smi_value = Smi::New(source->At(i));
|
|
array_object.SetAt(i, smi_value);
|
|
}
|
|
return array_object.raw();
|
|
}
|
|
|
|
static void ProcessTokenPositionsEntry(
|
|
const ExternalTypedData& kernel_data,
|
|
const Script& script,
|
|
const Script& entry_script,
|
|
intptr_t kernel_offset,
|
|
intptr_t data_kernel_offset,
|
|
Zone* zone,
|
|
TranslationHelper* helper,
|
|
GrowableArray<intptr_t>* token_positions,
|
|
GrowableArray<intptr_t>* yield_positions) {
|
|
if (kernel_data.IsNull()) {
|
|
return;
|
|
}
|
|
|
|
KernelTokenPositionCollector token_position_collector(
|
|
zone, helper, script, kernel_data, data_kernel_offset,
|
|
entry_script.kernel_script_index(), script.kernel_script_index(),
|
|
token_positions, yield_positions);
|
|
|
|
token_position_collector.CollectTokenPositions(kernel_offset);
|
|
}
|
|
|
|
void CollectTokenPositionsFor(const Script& interesting_script) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
TranslationHelper helper(thread);
|
|
helper.InitFromScript(interesting_script);
|
|
|
|
GrowableArray<intptr_t> token_positions(10);
|
|
GrowableArray<intptr_t> yield_positions(1);
|
|
|
|
Isolate* isolate = thread->isolate();
|
|
const GrowableObjectArray& libs =
|
|
GrowableObjectArray::Handle(zone, isolate->object_store()->libraries());
|
|
Library& lib = Library::Handle(zone);
|
|
Object& entry = Object::Handle(zone);
|
|
Script& entry_script = Script::Handle(zone);
|
|
ExternalTypedData& data = ExternalTypedData::Handle(zone);
|
|
|
|
auto& temp_array = Array::Handle(zone);
|
|
auto& temp_field = Field::Handle(zone);
|
|
auto& temp_function = Function::Handle(zone);
|
|
for (intptr_t i = 0; i < libs.Length(); i++) {
|
|
lib ^= libs.At(i);
|
|
DictionaryIterator it(lib);
|
|
while (it.HasNext()) {
|
|
entry = it.GetNext();
|
|
data = ExternalTypedData::null();
|
|
if (entry.IsClass()) {
|
|
const Class& klass = Class::Cast(entry);
|
|
if (klass.script() == interesting_script.raw()) {
|
|
token_positions.Add(klass.token_pos().value());
|
|
}
|
|
if (klass.is_finalized()) {
|
|
temp_array = klass.fields();
|
|
for (intptr_t i = 0; i < temp_array.Length(); ++i) {
|
|
temp_field ^= temp_array.At(i);
|
|
if (temp_field.kernel_offset() <= 0) {
|
|
// Skip artificially injected fields.
|
|
continue;
|
|
}
|
|
entry_script = temp_field.Script();
|
|
if (entry_script.raw() != interesting_script.raw()) {
|
|
continue;
|
|
}
|
|
data = temp_field.KernelData();
|
|
ProcessTokenPositionsEntry(data, interesting_script, entry_script,
|
|
temp_field.kernel_offset(),
|
|
temp_field.KernelDataProgramOffset(),
|
|
zone, &helper, &token_positions,
|
|
&yield_positions);
|
|
}
|
|
temp_array = klass.functions();
|
|
for (intptr_t i = 0; i < temp_array.Length(); ++i) {
|
|
temp_function ^= temp_array.At(i);
|
|
entry_script = temp_function.script();
|
|
if (entry_script.raw() != interesting_script.raw()) {
|
|
continue;
|
|
}
|
|
data = temp_function.KernelData();
|
|
ProcessTokenPositionsEntry(data, interesting_script, entry_script,
|
|
temp_function.kernel_offset(),
|
|
temp_function.KernelDataProgramOffset(),
|
|
zone, &helper, &token_positions,
|
|
&yield_positions);
|
|
}
|
|
} else {
|
|
// Class isn't finalized yet: read the data attached to it.
|
|
ASSERT(klass.kernel_offset() > 0);
|
|
data = lib.kernel_data();
|
|
ASSERT(!data.IsNull());
|
|
const intptr_t library_kernel_offset = lib.kernel_offset();
|
|
ASSERT(library_kernel_offset > 0);
|
|
const intptr_t class_offset = klass.kernel_offset();
|
|
|
|
entry_script = klass.script();
|
|
if (entry_script.raw() != interesting_script.raw()) {
|
|
continue;
|
|
}
|
|
ProcessTokenPositionsEntry(data, interesting_script, entry_script,
|
|
class_offset, library_kernel_offset, zone,
|
|
&helper, &token_positions,
|
|
&yield_positions);
|
|
}
|
|
} else if (entry.IsFunction()) {
|
|
temp_function ^= entry.raw();
|
|
entry_script = temp_function.script();
|
|
if (entry_script.raw() != interesting_script.raw()) {
|
|
continue;
|
|
}
|
|
data = temp_function.KernelData();
|
|
ProcessTokenPositionsEntry(data, interesting_script, entry_script,
|
|
temp_function.kernel_offset(),
|
|
temp_function.KernelDataProgramOffset(),
|
|
zone, &helper, &token_positions,
|
|
&yield_positions);
|
|
} else if (entry.IsField()) {
|
|
const Field& field = Field::Cast(entry);
|
|
if (field.kernel_offset() <= 0) {
|
|
// Skip artificially injected fields.
|
|
continue;
|
|
}
|
|
entry_script = field.Script();
|
|
if (entry_script.raw() != interesting_script.raw()) {
|
|
continue;
|
|
}
|
|
data = field.KernelData();
|
|
ProcessTokenPositionsEntry(data, interesting_script, entry_script,
|
|
field.kernel_offset(),
|
|
field.KernelDataProgramOffset(), zone,
|
|
&helper, &token_positions, &yield_positions);
|
|
}
|
|
}
|
|
}
|
|
|
|
Script& script = Script::Handle(zone, interesting_script.raw());
|
|
Array& array_object = Array::Handle(zone);
|
|
array_object = AsSortedDuplicateFreeArray(&token_positions);
|
|
script.set_debug_positions(array_object);
|
|
array_object = AsSortedDuplicateFreeArray(&yield_positions);
|
|
script.set_yield_positions(array_object);
|
|
}
|
|
|
|
class MetadataEvaluator : public KernelReaderHelper {
|
|
public:
|
|
MetadataEvaluator(Zone* zone,
|
|
TranslationHelper* translation_helper,
|
|
const Script& script,
|
|
const ExternalTypedData& data,
|
|
intptr_t data_program_offset,
|
|
ActiveClass* active_class)
|
|
: KernelReaderHelper(zone,
|
|
translation_helper,
|
|
script,
|
|
data,
|
|
data_program_offset),
|
|
type_translator_(this, active_class, /* finalize= */ true),
|
|
constant_evaluator_(this, &type_translator_, active_class, nullptr) {}
|
|
|
|
RawObject* EvaluateMetadata(intptr_t kernel_offset,
|
|
bool is_annotations_offset) {
|
|
SetOffset(kernel_offset);
|
|
|
|
// Library and LibraryDependency objects do not have a tag in kernel binary.
|
|
// Synthetic metadata fields corresponding to these objects keep kernel
|
|
// offset of annotations list instead of annotated object.
|
|
if (!is_annotations_offset) {
|
|
const Tag tag = PeekTag();
|
|
|
|
if (tag == kClass) {
|
|
ClassHelper class_helper(this);
|
|
class_helper.ReadUntilExcluding(ClassHelper::kAnnotations);
|
|
} else if (tag == kProcedure) {
|
|
ProcedureHelper procedure_helper(this);
|
|
procedure_helper.ReadUntilExcluding(ProcedureHelper::kAnnotations);
|
|
} else if (tag == kField) {
|
|
FieldHelper field_helper(this);
|
|
field_helper.ReadUntilExcluding(FieldHelper::kAnnotations);
|
|
} else if (tag == kConstructor) {
|
|
ConstructorHelper constructor_helper(this);
|
|
constructor_helper.ReadUntilExcluding(ConstructorHelper::kAnnotations);
|
|
} else {
|
|
FATAL("No support for metadata on this type of kernel node\n");
|
|
}
|
|
}
|
|
|
|
return constant_evaluator_.EvaluateAnnotations();
|
|
}
|
|
|
|
private:
|
|
TypeTranslator type_translator_;
|
|
ConstantEvaluator constant_evaluator_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(MetadataEvaluator);
|
|
};
|
|
|
|
RawObject* EvaluateMetadata(const Field& metadata_field,
|
|
bool is_annotations_offset) {
|
|
LongJumpScope jump;
|
|
if (setjmp(*jump.Set()) == 0) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
TranslationHelper helper(thread);
|
|
Script& script = Script::Handle(zone, metadata_field.Script());
|
|
helper.InitFromScript(script);
|
|
|
|
const Class& owner_class = Class::Handle(zone, metadata_field.Owner());
|
|
ActiveClass active_class;
|
|
ActiveClassScope active_class_scope(&active_class, &owner_class);
|
|
|
|
MetadataEvaluator metadata_evaluator(
|
|
zone, &helper, script,
|
|
ExternalTypedData::Handle(zone, metadata_field.KernelData()),
|
|
metadata_field.KernelDataProgramOffset(), &active_class);
|
|
|
|
return metadata_evaluator.EvaluateMetadata(metadata_field.kernel_offset(),
|
|
is_annotations_offset);
|
|
|
|
} else {
|
|
return Thread::Current()->StealStickyError();
|
|
}
|
|
}
|
|
|
|
class ParameterDescriptorBuilder : public KernelReaderHelper {
|
|
public:
|
|
ParameterDescriptorBuilder(TranslationHelper* translation_helper,
|
|
const Script& script,
|
|
Zone* zone,
|
|
const ExternalTypedData& data,
|
|
intptr_t data_program_offset,
|
|
ActiveClass* active_class)
|
|
: KernelReaderHelper(zone,
|
|
translation_helper,
|
|
script,
|
|
data,
|
|
data_program_offset),
|
|
type_translator_(this, active_class, /* finalize= */ true),
|
|
constant_evaluator_(this, &type_translator_, active_class, nullptr) {}
|
|
|
|
RawObject* BuildParameterDescriptor(intptr_t kernel_offset);
|
|
|
|
private:
|
|
TypeTranslator type_translator_;
|
|
ConstantEvaluator constant_evaluator_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(ParameterDescriptorBuilder);
|
|
};
|
|
|
|
RawObject* ParameterDescriptorBuilder::BuildParameterDescriptor(
|
|
intptr_t kernel_offset) {
|
|
SetOffset(kernel_offset);
|
|
ReadUntilFunctionNode();
|
|
FunctionNodeHelper function_node_helper(this);
|
|
function_node_helper.ReadUntilExcluding(
|
|
FunctionNodeHelper::kPositionalParameters);
|
|
intptr_t param_count = function_node_helper.total_parameter_count_;
|
|
intptr_t positional_count = ReadListLength(); // read list length.
|
|
intptr_t named_parameter_count = param_count - positional_count;
|
|
|
|
const Array& param_descriptor = Array::Handle(
|
|
Array::New(param_count * Parser::kParameterEntrySize, Heap::kOld));
|
|
for (intptr_t i = 0; i < param_count; ++i) {
|
|
const intptr_t entry_start = i * Parser::kParameterEntrySize;
|
|
|
|
if (i == positional_count) {
|
|
intptr_t named_parameter_count_check =
|
|
ReadListLength(); // read list length.
|
|
ASSERT(named_parameter_count_check == named_parameter_count);
|
|
}
|
|
|
|
// Read ith variable declaration.
|
|
intptr_t param_kernel_offset = reader_.offset();
|
|
VariableDeclarationHelper helper(this);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
|
|
param_descriptor.SetAt(entry_start + Parser::kParameterIsFinalOffset,
|
|
helper.IsFinal() ? Bool::True() : Bool::False());
|
|
|
|
Tag tag = ReadTag(); // read (first part of) initializer.
|
|
if (tag == kSomething) {
|
|
// this will (potentially) read the initializer, but reset the position.
|
|
Instance& constant = Instance::ZoneHandle(
|
|
zone_, constant_evaluator_.EvaluateExpression(ReaderOffset()));
|
|
SkipExpression(); // read (actual) initializer.
|
|
param_descriptor.SetAt(entry_start + Parser::kParameterDefaultValueOffset,
|
|
constant);
|
|
} else {
|
|
param_descriptor.SetAt(entry_start + Parser::kParameterDefaultValueOffset,
|
|
Object::null_instance());
|
|
}
|
|
|
|
if (FLAG_enable_mirrors && (helper.annotation_count_ > 0)) {
|
|
AlternativeReadingScope alt(&reader_, param_kernel_offset);
|
|
VariableDeclarationHelper helper(this);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kAnnotations);
|
|
Object& metadata =
|
|
Object::ZoneHandle(zone_, constant_evaluator_.EvaluateAnnotations());
|
|
param_descriptor.SetAt(entry_start + Parser::kParameterMetadataOffset,
|
|
metadata);
|
|
} else {
|
|
param_descriptor.SetAt(entry_start + Parser::kParameterMetadataOffset,
|
|
Object::null_instance());
|
|
}
|
|
}
|
|
return param_descriptor.raw();
|
|
}
|
|
|
|
RawObject* BuildParameterDescriptor(const Function& function) {
|
|
LongJumpScope jump;
|
|
if (setjmp(*jump.Set()) == 0) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
TranslationHelper helper(thread);
|
|
Script& script = Script::Handle(zone, function.script());
|
|
helper.InitFromScript(script);
|
|
|
|
const Class& owner_class = Class::Handle(zone, function.Owner());
|
|
ActiveClass active_class;
|
|
ActiveClassScope active_class_scope(&active_class, &owner_class);
|
|
|
|
ParameterDescriptorBuilder builder(
|
|
&helper, Script::Handle(zone, function.script()), zone,
|
|
ExternalTypedData::Handle(zone, function.KernelData()),
|
|
function.KernelDataProgramOffset(), &active_class);
|
|
|
|
return builder.BuildParameterDescriptor(function.kernel_offset());
|
|
} else {
|
|
return Thread::Current()->StealStickyError();
|
|
}
|
|
}
|
|
|
|
bool NeedsDynamicInvocationForwarder(const Function& function) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
|
|
TranslationHelper helper(thread);
|
|
Script& script = Script::Handle(zone, function.script());
|
|
helper.InitFromScript(script);
|
|
|
|
// Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
|
|
// e.g. for type translation.
|
|
|
|
const Class& owner_class = Class::Handle(zone, function.Owner());
|
|
Function& outermost_function =
|
|
Function::Handle(zone, function.GetOutermostFunction());
|
|
|
|
ActiveClass active_class;
|
|
ActiveClassScope active_class_scope(&active_class, &owner_class);
|
|
ActiveMemberScope active_member(&active_class, &outermost_function);
|
|
ActiveTypeParametersScope active_type_params(&active_class, function, zone);
|
|
|
|
KernelReaderHelper reader_helper(
|
|
zone, &helper, script,
|
|
ExternalTypedData::Handle(zone, function.KernelData()),
|
|
function.KernelDataProgramOffset());
|
|
|
|
TypeTranslator type_translator(&reader_helper, &active_class,
|
|
/* finalize= */ true);
|
|
|
|
reader_helper.SetOffset(function.kernel_offset());
|
|
|
|
// Handle setters.
|
|
if (reader_helper.PeekTag() == kField) {
|
|
ASSERT(function.IsImplicitSetterFunction());
|
|
FieldHelper field_helper(&reader_helper);
|
|
field_helper.ReadUntilIncluding(FieldHelper::kFlags);
|
|
return !(field_helper.IsCovariant() ||
|
|
field_helper.IsGenericCovariantImpl());
|
|
}
|
|
|
|
reader_helper.ReadUntilFunctionNode();
|
|
|
|
FunctionNodeHelper function_node_helper(&reader_helper);
|
|
function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
|
|
intptr_t num_type_params = reader_helper.ReadListLength();
|
|
|
|
for (intptr_t i = 0; i < num_type_params; ++i) {
|
|
TypeParameterHelper helper(&reader_helper);
|
|
helper.ReadUntilExcludingAndSetJustRead(TypeParameterHelper::kBound);
|
|
AbstractType& bound = type_translator.BuildType(); // read bound
|
|
helper.Finish();
|
|
|
|
if (!bound.IsTopType() && !helper.IsGenericCovariantImpl()) {
|
|
return true;
|
|
}
|
|
}
|
|
function_node_helper.SetJustRead(FunctionNodeHelper::kTypeParameters);
|
|
function_node_helper.ReadUntilExcluding(
|
|
FunctionNodeHelper::kPositionalParameters);
|
|
|
|
// Positional.
|
|
const intptr_t num_positional_params = reader_helper.ReadListLength();
|
|
for (intptr_t i = 0; i < num_positional_params; ++i) {
|
|
VariableDeclarationHelper helper(&reader_helper);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
|
|
AbstractType& type = type_translator.BuildType(); // read type.
|
|
helper.SetJustRead(VariableDeclarationHelper::kType);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
|
|
|
|
if (!type.IsTopType() && !helper.IsGenericCovariantImpl() &&
|
|
!helper.IsCovariant()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Named.
|
|
const intptr_t num_named_params = reader_helper.ReadListLength();
|
|
for (intptr_t i = 0; i < num_named_params; ++i) {
|
|
VariableDeclarationHelper helper(&reader_helper);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kType);
|
|
AbstractType& type = type_translator.BuildType(); // read type.
|
|
helper.SetJustRead(VariableDeclarationHelper::kType);
|
|
helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
|
|
|
|
if (!type.IsTopType() && !helper.IsGenericCovariantImpl() &&
|
|
!helper.IsCovariant()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IsFieldInitializer(const Function& function, Zone* zone) {
|
|
return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
|
|
String::Handle(zone, function.name())
|
|
.StartsWith(Symbols::InitPrefix());
|
|
}
|
|
|
|
static ProcedureAttributesMetadata ProcedureAttributesOf(
|
|
Zone* zone,
|
|
const Script& script,
|
|
const ExternalTypedData& kernel_data,
|
|
intptr_t kernel_data_program_offset,
|
|
intptr_t kernel_offset) {
|
|
TranslationHelper translation_helper(Thread::Current());
|
|
translation_helper.InitFromScript(script);
|
|
KernelReaderHelper reader_helper(zone, &translation_helper, script,
|
|
kernel_data, kernel_data_program_offset);
|
|
ProcedureAttributesMetadataHelper procedure_attributes_metadata_helper(
|
|
&reader_helper);
|
|
ProcedureAttributesMetadata attrs =
|
|
procedure_attributes_metadata_helper.GetProcedureAttributes(
|
|
kernel_offset);
|
|
return attrs;
|
|
}
|
|
|
|
ProcedureAttributesMetadata ProcedureAttributesOf(const Function& function,
|
|
Zone* zone) {
|
|
const Script& script = Script::Handle(zone, function.script());
|
|
return ProcedureAttributesOf(
|
|
zone, script, ExternalTypedData::Handle(zone, function.KernelData()),
|
|
function.KernelDataProgramOffset(), function.kernel_offset());
|
|
}
|
|
|
|
ProcedureAttributesMetadata ProcedureAttributesOf(const Field& field,
|
|
Zone* zone) {
|
|
const Class& parent = Class::Handle(zone, field.Owner());
|
|
const Script& script = Script::Handle(zone, parent.script());
|
|
return ProcedureAttributesOf(
|
|
zone, script, ExternalTypedData::Handle(zone, field.KernelData()),
|
|
field.KernelDataProgramOffset(), field.kernel_offset());
|
|
}
|
|
|
|
} // namespace kernel
|
|
} // namespace dart
|
|
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|