Google Git
Sign in
dart / sdk.git / 88021fd67a668180609fffb2daabcee6053741ef / . / runtime / vm / program_visitor.cc
blob: 4bb663a4dbd4f235efc21d3a5badc2f3b5879bd8 [file] [log] [blame]
// Copyright (c) 2015, 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.
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "vm/program_visitor.h"
#include "vm/closure_functions_cache.h"
#include "vm/code_patcher.h"
#include "vm/deopt_instructions.h"
#include "vm/hash_map.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/symbols.h"
namespace dart {
class WorklistElement : public ZoneAllocated {
public:
WorklistElement(Zone* zone, const Object& object)
: object_(Object::Handle(zone, object.ptr())), next_(nullptr) {}
ObjectPtr value() const { return object_.ptr(); }
void set_next(WorklistElement* elem) { next_ = elem; }
WorklistElement* next() const { return next_; }
private:
const Object& object_;
WorklistElement* next_;
DISALLOW_COPY_AND_ASSIGN(WorklistElement);
};
// Implements a FIFO queue, using IsEmpty, Add, Remove operations.
class Worklist : public ValueObject {
public:
explicit Worklist(Zone* zone)
: zone_(zone), first_(nullptr), last_(nullptr) {}
bool IsEmpty() const { return first_ == nullptr; }
void Add(const Object& value) {
auto element = new (zone_) WorklistElement(zone_, value);
if (first_ == nullptr) {
first_ = element;
ASSERT(last_ == nullptr);
} else {
ASSERT(last_ != nullptr);
last_->set_next(element);
}
last_ = element;
ASSERT(first_ != nullptr && last_ != nullptr);
}
ObjectPtr Remove() {
ASSERT(first_ != nullptr);
WorklistElement* result = first_;
first_ = first_->next();
if (first_ == nullptr) {
last_ = nullptr;
}
return result->value();
}
private:
Zone* const zone_;
WorklistElement* first_;
WorklistElement* last_;
DISALLOW_COPY_AND_ASSIGN(Worklist);
};
// Walks through the classes, functions, and code for the current program.
//
// Uses the heap object ID table to determine whether or not a given object
// has been visited already.
class ProgramWalker : public ValueObject {
public:
ProgramWalker(Zone* zone, Heap* heap, ClassVisitor* visitor)
: heap_(heap),
visitor_(visitor),
worklist_(zone),
class_object_(Object::Handle(zone)),
class_fields_(Array::Handle(zone)),
class_field_(Field::Handle(zone)),
class_functions_(Array::Handle(zone)),
class_function_(Function::Handle(zone)),
class_code_(Code::Handle(zone)),
function_code_(Code::Handle(zone)),
static_calls_array_(Array::Handle(zone)),
static_calls_table_entry_(Object::Handle(zone)),
worklist_entry_(Object::Handle(zone)) {}
~ProgramWalker() { heap_->ResetObjectIdTable(); }
// Adds the given object to the worklist if it's an object type that the
// visitor can visit.
void AddToWorklist(const Object& object) {
// We don't visit null, non-heap objects, or objects in the VM heap.
if (object.IsNull() || object.IsSmi() || object.InVMIsolateHeap()) return;
// Check and set visited, even if we don't end up adding this to the list.
if (heap_->GetObjectId(object.ptr()) != 0) return;
heap_->SetObjectId(object.ptr(), 1);
if (object.IsClass() ||
(object.IsFunction() && visitor_->IsFunctionVisitor()) ||
(object.IsCode() && visitor_->IsCodeVisitor())) {
worklist_.Add(object);
}
}
void VisitWorklist() {
while (!worklist_.IsEmpty()) {
worklist_entry_ = worklist_.Remove();
if (worklist_entry_.IsClass()) {
VisitClass(Class::Cast(worklist_entry_));
} else if (worklist_entry_.IsFunction()) {
VisitFunction(Function::Cast(worklist_entry_));
} else if (worklist_entry_.IsCode()) {
VisitCode(Code::Cast(worklist_entry_));
} else {
FATAL1("Got unexpected object %s", worklist_entry_.ToCString());
}
}
}
private:
void VisitClass(const Class& cls) {
visitor_->VisitClass(cls);
if (!visitor_->IsFunctionVisitor()) return;
class_functions_ = cls.current_functions();
for (intptr_t j = 0; j < class_functions_.Length(); j++) {
class_function_ ^= class_functions_.At(j);
AddToWorklist(class_function_);
if (class_function_.HasImplicitClosureFunction()) {
class_function_ = class_function_.ImplicitClosureFunction();
AddToWorklist(class_function_);
}
}
class_functions_ = cls.invocation_dispatcher_cache();
for (intptr_t j = 0; j < class_functions_.Length(); j++) {
class_object_ = class_functions_.At(j);
if (class_object_.IsFunction()) {
class_function_ ^= class_functions_.At(j);
AddToWorklist(class_function_);
}
}
class_fields_ = cls.fields();
for (intptr_t j = 0; j < class_fields_.Length(); j++) {
class_field_ ^= class_fields_.At(j);
if (class_field_.HasInitializerFunction()) {
class_function_ = class_field_.InitializerFunction();
AddToWorklist(class_function_);
}
}
if (!visitor_->IsCodeVisitor()) return;
class_code_ = cls.allocation_stub();
if (!class_code_.IsNull()) AddToWorklist(class_code_);
}
void VisitFunction(const Function& function) {
ASSERT(visitor_->IsFunctionVisitor());
visitor_->AsFunctionVisitor()->VisitFunction(function);
if (!visitor_->IsCodeVisitor() || !function.HasCode()) return;
function_code_ = function.CurrentCode();
AddToWorklist(function_code_);
}
void VisitCode(const Code& code) {
ASSERT(visitor_->IsCodeVisitor());
visitor_->AsCodeVisitor()->VisitCode(code);
// In the precompiler, some entries in the static calls table may need
// to be visited as they may not be reachable from other sources.
//
// TODO(dartbug.com/41636): Figure out why walking the static calls table
// in JIT mode with the DedupInstructions visitor fails, so we can remove
// the check for AOT mode.
static_calls_array_ = code.static_calls_target_table();
if (FLAG_precompiled_mode && !static_calls_array_.IsNull()) {
StaticCallsTable static_calls(static_calls_array_);
for (auto& view : static_calls) {
static_calls_table_entry_ =
view.Get<Code::kSCallTableCodeOrTypeTarget>();
if (static_calls_table_entry_.IsCode()) {
AddToWorklist(Code::Cast(static_calls_table_entry_));
}
}
}
}
Heap* const heap_;
ClassVisitor* const visitor_;
Worklist worklist_;
Object& class_object_;
Array& class_fields_;
Field& class_field_;
Array& class_functions_;
Function& class_function_;
Code& class_code_;
Code& function_code_;
Array& static_calls_array_;
Object& static_calls_table_entry_;
Object& worklist_entry_;
};
void ProgramVisitor::WalkProgram(Zone* zone,
IsolateGroup* isolate_group,
ClassVisitor* visitor) {
auto const object_store = isolate_group->object_store();
auto const heap = isolate_group->heap();
ProgramWalker walker(zone, heap, visitor);
// Walk through the libraries and patches, looking for visitable objects.
const auto& libraries =
GrowableObjectArray::Handle(zone, object_store->libraries());
auto& lib = Library::Handle(zone);
auto& cls = Class::Handle(zone);
auto& entry = Object::Handle(zone);
auto& patches = GrowableObjectArray::Handle(zone);
for (intptr_t i = 0; i < libraries.Length(); i++) {
lib ^= libraries.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
walker.AddToWorklist(cls);
}
patches = lib.used_scripts();
for (intptr_t j = 0; j < patches.Length(); j++) {
entry = patches.At(j);
walker.AddToWorklist(entry);
}
}
// If there's a global object pool, add any visitable objects.
const auto& global_object_pool =
ObjectPool::Handle(zone, object_store->global_object_pool());
if (!global_object_pool.IsNull()) {
auto& object = Object::Handle(zone);
for (intptr_t i = 0; i < global_object_pool.Length(); i++) {
auto const type = global_object_pool.TypeAt(i);
if (type != ObjectPool::EntryType::kTaggedObject) continue;
object = global_object_pool.ObjectAt(i);
walker.AddToWorklist(object);
}
}
if (visitor->IsFunctionVisitor()) {
// Function objects not necessarily reachable from classes.
ClosureFunctionsCache::ForAllClosureFunctions([&](const Function& fun) {
walker.AddToWorklist(fun);
ASSERT(!fun.HasImplicitClosureFunction());
return true; // Continue iteration.
});
// TODO(dartbug.com/43049): Use a more general solution and remove manual
// tracking through object_store->ffi_callback_functions.
auto& function = Function::Handle(zone);
const auto& ffi_callback_entries = GrowableObjectArray::Handle(
zone, object_store->ffi_callback_functions());
if (!ffi_callback_entries.IsNull()) {
for (intptr_t i = 0; i < ffi_callback_entries.Length(); i++) {
function ^= ffi_callback_entries.At(i);
walker.AddToWorklist(function);
}
}
}
if (visitor->IsCodeVisitor()) {
// Code objects not necessarily reachable from functions.
auto& code = Code::Handle(zone);
const auto& dispatch_table_entries =
Array::Handle(zone, object_store->dispatch_table_code_entries());
if (!dispatch_table_entries.IsNull()) {
for (intptr_t i = 0; i < dispatch_table_entries.Length(); i++) {
code ^= dispatch_table_entries.At(i);
walker.AddToWorklist(code);
}
}
}
// Walk the program starting from any roots we added to the worklist.
walker.VisitWorklist();
}
// A base class for deduplication of objects. T is the type of canonical objects
// being stored, whereas S is a trait appropriate for a DirectChainedHashMap
// based set containing those canonical objects.
template <typename T, typename S>
class Dedupper : public ValueObject {
public:
explicit Dedupper(Zone* zone) : zone_(zone), canonical_objects_(zone) {}
virtual ~Dedupper() {}
protected:
// Predicate for objects of type T. Must be overridden for class hierarchies
// like Instance and AbstractType, as it defaults to class ID comparison.
virtual bool IsCorrectType(const Object& obj) const {
return obj.GetClassId() == T::kClassId;
}
// Predicate for choosing Ts to canonicalize.
virtual bool CanCanonicalize(const T& t) const { return true; }
// Predicate for objects that are okay to add to the canonical hash set.
// Override IsCorrectType and/or CanCanonicalize to change the behavior.
bool ShouldAdd(const Object& obj) const {
return !obj.IsNull() && IsCorrectType(obj) && CanCanonicalize(T::Cast(obj));
}
void AddCanonical(const T& obj) {
if (!ShouldAdd(obj)) return;
ASSERT(!canonical_objects_.HasKey(&obj));
canonical_objects_.Insert(&T::ZoneHandle(zone_, obj.ptr()));
}
void AddVMBaseObjects() {
const auto& object_table = Object::vm_isolate_snapshot_object_table();
auto& obj = Object::Handle(zone_);
for (intptr_t i = 0; i < object_table.Length(); i++) {
obj = object_table.At(i);
if (!ShouldAdd(obj)) continue;
AddCanonical(T::Cast(obj));
}
}
typename T::ObjectPtrType Dedup(const T& obj) {
if (ShouldAdd(obj)) {
if (auto const canonical = canonical_objects_.LookupValue(&obj)) {
return canonical->ptr();
}
AddCanonical(obj);
}
return obj.ptr();
}
Zone* const zone_;
DirectChainedHashMap<S> canonical_objects_;
};
void ProgramVisitor::BindStaticCalls(Zone* zone, IsolateGroup* isolate_group) {
class BindStaticCallsVisitor : public CodeVisitor {
public:
explicit BindStaticCallsVisitor(Zone* zone)
: table_(Array::Handle(zone)),
kind_and_offset_(Smi::Handle(zone)),
target_(Object::Handle(zone)),
target_code_(Code::Handle(zone)) {}
void VisitCode(const Code& code) {
table_ = code.static_calls_target_table();
if (table_.IsNull()) return;
StaticCallsTable static_calls(table_);
// We can only remove the target table in precompiled mode, since more
// calls may be added later otherwise.
bool only_call_via_code = FLAG_precompiled_mode;
for (const auto& view : static_calls) {
kind_and_offset_ = view.Get<Code::kSCallTableKindAndOffset>();
auto const kind = Code::KindField::decode(kind_and_offset_.Value());
if (kind != Code::kCallViaCode) {
ASSERT(kind == Code::kPcRelativeCall ||
kind == Code::kPcRelativeTailCall ||
kind == Code::kPcRelativeTTSCall);
only_call_via_code = false;
continue;
}
target_ = view.Get<Code::kSCallTableFunctionTarget>();
if (target_.IsNull()) {
target_ =
Code::RawCast(view.Get<Code::kSCallTableCodeOrTypeTarget>());
ASSERT(!target_.IsNull()); // Already bound.
continue;
}
auto const pc_offset =
Code::OffsetField::decode(kind_and_offset_.Value());
const uword pc = pc_offset + code.PayloadStart();
// In JIT mode, static calls initially call the CallStaticFunction stub
// because their target might not be compiled yet. If the target has
// been compiled by this point, we patch the call to call the target
// directly.
//
// In precompiled mode, the binder runs after tree shaking, during which
// all targets have been compiled, and so the binder replaces all static
// calls with direct calls to the target.
//
// Cf. runtime entry PatchStaticCall called from CallStaticFunction
// stub.
const auto& fun = Function::Cast(target_);
ASSERT(!FLAG_precompiled_mode || fun.HasCode());
target_code_ = fun.HasCode() ? fun.CurrentCode()
: StubCode::CallStaticFunction().ptr();
CodePatcher::PatchStaticCallAt(pc, code, target_code_);
}
if (only_call_via_code) {
ASSERT(FLAG_precompiled_mode);
// In precompiled mode, the Dart runtime won't patch static calls
// anymore, so drop the static call table to save space.
// Note: it is okay to drop the table fully even when generating
// V8 snapshot profile because code objects are linked through the
// pool.
code.set_static_calls_target_table(Object::empty_array());
}
}
private:
Array& table_;
Smi& kind_and_offset_;
Object& target_;
Code& target_code_;
};
BindStaticCallsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
DECLARE_FLAG(charp, trace_precompiler_to);
DECLARE_FLAG(charp, write_v8_snapshot_profile_to);
void ProgramVisitor::ShareMegamorphicBuckets(Zone* zone,
IsolateGroup* isolate_group) {
const GrowableObjectArray& table = GrowableObjectArray::Handle(
zone, isolate_group->object_store()->megamorphic_cache_table());
if (table.IsNull()) return;
MegamorphicCache& cache = MegamorphicCache::Handle(zone);
const intptr_t capacity = 1;
const Array& buckets = Array::Handle(
zone, Array::New(MegamorphicCache::kEntryLength * capacity, Heap::kOld));
const Function& handler = Function::Handle(zone);
MegamorphicCache::SetEntry(buckets, 0, Object::smi_illegal_cid(), handler);
for (intptr_t i = 0; i < table.Length(); i++) {
cache ^= table.At(i);
cache.set_buckets(buckets);
cache.set_mask(capacity - 1);
cache.set_filled_entry_count(0);
}
}
class StackMapEntry : public ZoneAllocated {
public:
StackMapEntry(Zone* zone, const CompressedStackMaps::Iterator& it)
: maps_(CompressedStackMaps::Handle(zone, it.maps_.ptr())),
bits_container_(
CompressedStackMaps::Handle(zone, it.bits_container_.ptr())),
// If the map uses the global table, this accessor call ensures the
// entry is fully loaded before we retrieve [it.current_bits_offset_].
spill_slot_bit_count_(it.SpillSlotBitCount()),
non_spill_slot_bit_count_(it.Length() - it.SpillSlotBitCount()),
bits_offset_(it.current_bits_offset_) {
ASSERT(!maps_.IsNull() && !maps_.IsGlobalTable());
ASSERT(!bits_container_.IsNull());
ASSERT(!maps_.UsesGlobalTable() || bits_container_.IsGlobalTable());
ASSERT(it.current_spill_slot_bit_count_ >= 0);
}
static const intptr_t kHashBits = 30;
uword Hash() {
if (hash_ != 0) return hash_;
uint32_t hash = 0;
hash = CombineHashes(hash, spill_slot_bit_count_);
hash = CombineHashes(hash, non_spill_slot_bit_count_);
{
NoSafepointScope scope;
auto const start = PayloadData();
auto const end = start + PayloadLength();
for (auto cursor = start; cursor < end; cursor++) {
hash = CombineHashes(hash, *cursor);
}
}
hash_ = FinalizeHash(hash, kHashBits);
return hash_;
}
bool Equals(const StackMapEntry& other) const {
if (spill_slot_bit_count_ != other.spill_slot_bit_count_ ||
non_spill_slot_bit_count_ != other.non_spill_slot_bit_count_) {
return false;
}
// Since we ensure that bits in the payload that are not part of the
// actual stackmap data are cleared, we can just compare payloads by byte
// instead of calling IsObject for each bit.
NoSafepointScope scope;
return memcmp(PayloadData(), other.PayloadData(), PayloadLength()) == 0;
}
// Encodes this StackMapEntry to the given array of bytes and returns the
// initial offset of the entry in the array.
intptr_t EncodeTo(NonStreamingWriteStream* stream) {
auto const current_offset = stream->Position();
stream->WriteLEB128(spill_slot_bit_count_);
stream->WriteLEB128(non_spill_slot_bit_count_);
{
NoSafepointScope scope;
stream->WriteBytes(PayloadData(), PayloadLength());
}
return current_offset;
}
intptr_t UsageCount() const { return uses_; }
void IncrementUsageCount() { uses_ += 1; }
private:
intptr_t Length() const {
return spill_slot_bit_count_ + non_spill_slot_bit_count_;
}
intptr_t PayloadLength() const {
return Utils::RoundUp(Length(), kBitsPerByte) >> kBitsPerByteLog2;
}
const uint8_t* PayloadData() const {
ASSERT(!Thread::Current()->IsAtSafepoint());
return bits_container_.ptr()->untag()->data() + bits_offset_;
}
const CompressedStackMaps& maps_;
const CompressedStackMaps& bits_container_;
const intptr_t spill_slot_bit_count_;
const intptr_t non_spill_slot_bit_count_;
const intptr_t bits_offset_;
intptr_t uses_ = 1;
intptr_t hash_ = 0;
};
// Used for maps of indices and offsets. These are non-negative, and so the
// value for entries may be 0. Since 0 is kNoValue for
// RawPointerKeyValueTrait<const StackMapEntry, intptr_t>, we can't just use it.
class StackMapEntryKeyIntValueTrait {
public:
typedef StackMapEntry* Key;
typedef intptr_t Value;
struct Pair {
Key key;
Value value;
Pair() : key(nullptr), value(-1) {}
Pair(const Key key, const Value& value)
: key(ASSERT_NOTNULL(key)), value(value) {}
Pair(const Pair& other) : key(other.key), value(other.value) {}
Pair& operator=(const Pair&) = default;
};
static Key KeyOf(Pair kv) { return kv.key; }
static Value ValueOf(Pair kv) { return kv.value; }
static uword Hash(Key key) { return key->Hash(); }
static bool IsKeyEqual(Pair kv, Key key) { return key->Equals(*kv.key); }
};
typedef DirectChainedHashMap<StackMapEntryKeyIntValueTrait> StackMapEntryIntMap;
void ProgramVisitor::NormalizeAndDedupCompressedStackMaps(
Zone* zone,
IsolateGroup* isolate_group) {
// Walks all the CSMs in Code objects and collects their entry information
// for consolidation.
class CollectStackMapEntriesVisitor : public CodeVisitor {
public:
CollectStackMapEntriesVisitor(Zone* zone,
const CompressedStackMaps& global_table)
: zone_(zone),
old_global_table_(global_table),
compressed_stackmaps_(CompressedStackMaps::Handle(zone)),
collected_entries_(zone, 2),
entry_indices_(zone),
entry_offset_(zone) {
ASSERT(old_global_table_.IsNull() || old_global_table_.IsGlobalTable());
}
void VisitCode(const Code& code) {
compressed_stackmaps_ = code.compressed_stackmaps();
CompressedStackMaps::Iterator it(compressed_stackmaps_,
old_global_table_);
while (it.MoveNext()) {
auto const entry = new (zone_) StackMapEntry(zone_, it);
auto const index = entry_indices_.LookupValue(entry);
if (index < 0) {
auto new_index = collected_entries_.length();
collected_entries_.Add(entry);
entry_indices_.Insert({entry, new_index});
} else {
collected_entries_.At(index)->IncrementUsageCount();
}
}
}
// Creates a new global table of stack map information. Also adds the
// offsets of encoded StackMapEntry objects to entry_offsets for use
// when normalizing CompressedStackMaps.
CompressedStackMapsPtr CreateGlobalTable(
StackMapEntryIntMap* entry_offsets) {
ASSERT(entry_offsets->IsEmpty());
if (collected_entries_.length() == 0) {
return CompressedStackMaps::null();
}
// First, sort the entries from most used to least used. This way,
// the most often used CSMs will have the lowest offsets, which means
// they will be smaller when LEB128 encoded.
collected_entries_.Sort(
[](StackMapEntry* const* e1, StackMapEntry* const* e2) {
return static_cast<int>((*e2)->UsageCount() - (*e1)->UsageCount());
});
MallocWriteStream stream(128);
// Encode the entries and record their offset in the payload. Sorting the
// entries may have changed their indices, so update those as well.
for (intptr_t i = 0, n = collected_entries_.length(); i < n; i++) {
auto const entry = collected_entries_.At(i);
entry_indices_.Update({entry, i});
entry_offsets->Insert({entry, entry->EncodeTo(&stream)});
}
const auto& data = CompressedStackMaps::Handle(
zone_, CompressedStackMaps::NewGlobalTable(stream.buffer(),
stream.bytes_written()));
return data.ptr();
}
private:
Zone* const zone_;
const CompressedStackMaps& old_global_table_;
CompressedStackMaps& compressed_stackmaps_;
GrowableArray<StackMapEntry*> collected_entries_;
StackMapEntryIntMap entry_indices_;
StackMapEntryIntMap entry_offset_;
};
// Walks all the CSMs in Code objects, normalizes them, and then dedups them.
//
// We use normalized to refer to CSMs whose entries are references to the
// new global table created during stack map collection, and non-normalized
// for CSMs that either have inlined entry information or whose entries are
// references to the _old_ global table in the object store, if any.
class NormalizeAndDedupCompressedStackMapsVisitor
: public CodeVisitor,
public Dedupper<CompressedStackMaps,
PointerKeyValueTrait<const CompressedStackMaps>> {
public:
NormalizeAndDedupCompressedStackMapsVisitor(Zone* zone,
IsolateGroup* isolate_group)
: Dedupper(zone),
old_global_table_(CompressedStackMaps::Handle(
zone,
isolate_group->object_store()
->canonicalized_stack_map_entries())),
entry_offsets_(zone),
maps_(CompressedStackMaps::Handle(zone)) {
ASSERT(old_global_table_.IsNull() || old_global_table_.IsGlobalTable());
// The stack map normalization and deduplication happens in two phases:
//
// 1) Visit all CompressedStackMaps (CSM) objects and collect individual
// entry info as canonicalized StackMapEntries (SMEs). Also record the
// frequency the same entry info was seen across all CSMs in each SME.
CollectStackMapEntriesVisitor collect_visitor(zone, old_global_table_);
WalkProgram(zone, isolate_group, &collect_visitor);
// The results of phase 1 are used to create a new global table with
// entries sorted by decreasing frequency, so that entries that appear
// more often in CSMs have smaller payload offsets (less bytes used in
// the LEB128 encoding). The new global table is put into place
// immediately, as we already have a handle on the old table.
const auto& new_global_table = CompressedStackMaps::Handle(
zone, collect_visitor.CreateGlobalTable(&entry_offsets_));
isolate_group->object_store()->set_canonicalized_stack_map_entries(
new_global_table);
// 2) Visit all CSMs and replace each with a canonicalized normalized
// version that uses the new global table for non-PC offset entry
// information. This part is done in VisitCode.
}
void VisitCode(const Code& code) {
maps_ = code.compressed_stackmaps();
if (maps_.IsNull()) return;
// First check is to make sure [maps] hasn't already been normalized,
// since any normalized map already has a canonical entry in the set.
if (auto const canonical = canonical_objects_.LookupValue(&maps_)) {
maps_ = canonical->ptr();
} else {
maps_ = NormalizeEntries(maps_);
maps_ = Dedup(maps_);
}
code.set_compressed_stackmaps(maps_);
}
private:
// Creates a normalized CSM from the given non-normalized CSM.
CompressedStackMapsPtr NormalizeEntries(const CompressedStackMaps& maps) {
if (maps.payload_size() == 0) {
// No entries, so use the canonical empty map.
return Object::empty_compressed_stackmaps().ptr();
}
MallocWriteStream new_payload(maps.payload_size());
CompressedStackMaps::Iterator it(maps, old_global_table_);
intptr_t last_offset = 0;
while (it.MoveNext()) {
StackMapEntry entry(zone_, it);
const intptr_t entry_offset = entry_offsets_.LookupValue(&entry);
const intptr_t pc_delta = it.pc_offset() - last_offset;
new_payload.WriteLEB128(pc_delta);
new_payload.WriteLEB128(entry_offset);
last_offset = it.pc_offset();
}
return CompressedStackMaps::NewUsingTable(new_payload.buffer(),
new_payload.bytes_written());
}
const CompressedStackMaps& old_global_table_;
StackMapEntryIntMap entry_offsets_;
CompressedStackMaps& maps_;
};
NormalizeAndDedupCompressedStackMapsVisitor dedup_visitor(zone,
isolate_group);
WalkProgram(zone, isolate_group, &dedup_visitor);
}
class PcDescriptorsKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const PcDescriptors* Key;
typedef const PcDescriptors* Value;
typedef const PcDescriptors* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) { return Utils::WordHash(key->Length()); }
static inline bool IsKeyEqual(Pair pair, Key key) {
return pair->Equals(*key);
}
};
void ProgramVisitor::DedupPcDescriptors(Zone* zone,
IsolateGroup* isolate_group) {
class DedupPcDescriptorsVisitor
: public CodeVisitor,
public Dedupper<PcDescriptors, PcDescriptorsKeyValueTrait> {
public:
explicit DedupPcDescriptorsVisitor(Zone* zone)
: Dedupper(zone),
pc_descriptor_(PcDescriptors::Handle(zone)) {
if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
// Prefer existing objects in the VM isolate.
AddVMBaseObjects();
}
}
void VisitCode(const Code& code) {
pc_descriptor_ = code.pc_descriptors();
pc_descriptor_ = Dedup(pc_descriptor_);
code.set_pc_descriptors(pc_descriptor_);
}
private:
PcDescriptors& pc_descriptor_;
};
DedupPcDescriptorsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
class TypedDataKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const TypedData* Key;
typedef const TypedData* Value;
typedef const TypedData* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) { return key->CanonicalizeHash(); }
static inline bool IsKeyEqual(Pair pair, Key key) {
return pair->CanonicalizeEquals(*key);
}
};
class TypedDataDedupper : public Dedupper<TypedData, TypedDataKeyValueTrait> {
public:
explicit TypedDataDedupper(Zone* zone) : Dedupper(zone) {}
private:
bool IsCorrectType(const Object& obj) const { return obj.IsTypedData(); }
};
void ProgramVisitor::DedupDeoptEntries(Zone* zone,
IsolateGroup* isolate_group) {
class DedupDeoptEntriesVisitor : public CodeVisitor,
public TypedDataDedupper {
public:
explicit DedupDeoptEntriesVisitor(Zone* zone)
: TypedDataDedupper(zone),
deopt_table_(Array::Handle(zone)),
deopt_entry_(TypedData::Handle(zone)),
offset_(Smi::Handle(zone)),
reason_and_flags_(Smi::Handle(zone)) {}
void VisitCode(const Code& code) {
deopt_table_ = code.deopt_info_array();
if (deopt_table_.IsNull()) return;
intptr_t length = DeoptTable::GetLength(deopt_table_);
for (intptr_t i = 0; i < length; i++) {
DeoptTable::GetEntry(deopt_table_, i, &offset_, &deopt_entry_,
&reason_and_flags_);
ASSERT(!deopt_entry_.IsNull());
deopt_entry_ = Dedup(deopt_entry_);
ASSERT(!deopt_entry_.IsNull());
DeoptTable::SetEntry(deopt_table_, i, offset_, deopt_entry_,
reason_and_flags_);
}
}
private:
Array& deopt_table_;
TypedData& deopt_entry_;
Smi& offset_;
Smi& reason_and_flags_;
};
if (FLAG_precompiled_mode) return;
DedupDeoptEntriesVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
#if defined(DART_PRECOMPILER)
void ProgramVisitor::DedupCatchEntryMovesMaps(Zone* zone,
IsolateGroup* isolate_group) {
class DedupCatchEntryMovesMapsVisitor : public CodeVisitor,
public TypedDataDedupper {
public:
explicit DedupCatchEntryMovesMapsVisitor(Zone* zone)
: TypedDataDedupper(zone),
catch_entry_moves_maps_(TypedData::Handle(zone)) {}
void VisitCode(const Code& code) {
catch_entry_moves_maps_ = code.catch_entry_moves_maps();
catch_entry_moves_maps_ = Dedup(catch_entry_moves_maps_);
code.set_catch_entry_moves_maps(catch_entry_moves_maps_);
}
private:
TypedData& catch_entry_moves_maps_;
};
if (!FLAG_precompiled_mode) return;
DedupCatchEntryMovesMapsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
class UnlinkedCallKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const UnlinkedCall* Key;
typedef const UnlinkedCall* Value;
typedef const UnlinkedCall* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) { return key->Hash(); }
static inline bool IsKeyEqual(Pair pair, Key key) {
return pair->Equals(*key);
}
};
void ProgramVisitor::DedupUnlinkedCalls(Zone* zone,
IsolateGroup* isolate_group) {
class DedupUnlinkedCallsVisitor
: public CodeVisitor,
public Dedupper<UnlinkedCall, UnlinkedCallKeyValueTrait> {
public:
explicit DedupUnlinkedCallsVisitor(Zone* zone, IsolateGroup* isolate_group)
: Dedupper(zone),
entry_(Object::Handle(zone)),
pool_(ObjectPool::Handle(zone)) {
auto& gop = ObjectPool::Handle(
zone, isolate_group->object_store()->global_object_pool());
ASSERT_EQUAL(!gop.IsNull(), FLAG_use_bare_instructions);
DedupPool(gop);
}
void DedupPool(const ObjectPool& pool) {
if (pool.IsNull()) return;
for (intptr_t i = 0; i < pool.Length(); i++) {
if (pool.TypeAt(i) != ObjectPool::EntryType::kTaggedObject) {
continue;
}
entry_ = pool.ObjectAt(i);
if (!entry_.IsUnlinkedCall()) continue;
entry_ = Dedup(UnlinkedCall::Cast(entry_));
pool.SetObjectAt(i, entry_);
}
}
void VisitCode(const Code& code) {
pool_ = code.object_pool();
DedupPool(pool_);
}
private:
Object& entry_;
ObjectPool& pool_;
};
if (!FLAG_precompiled_mode) return;
DedupUnlinkedCallsVisitor deduper(zone, isolate_group);
// Note: in bare instructions mode we can still have object pools attached
// to code objects and these pools need to be deduplicated.
// We use these pools to carry information about references between code
// objects and other objects in the snapshots (these references are otherwise
// implicit and go through global object pool). This information is needed
// to produce more informative snapshot profile.
if (!FLAG_use_bare_instructions ||
FLAG_write_v8_snapshot_profile_to != nullptr ||
FLAG_trace_precompiler_to != nullptr) {
WalkProgram(zone, isolate_group, &deduper);
}
}
void ProgramVisitor::PruneSubclasses(Zone* zone, IsolateGroup* isolate_group) {
class PruneSubclassesVisitor : public ClassVisitor {
public:
explicit PruneSubclassesVisitor(Zone* zone)
: ClassVisitor(),
old_implementors_(GrowableObjectArray::Handle(zone)),
new_implementors_(GrowableObjectArray::Handle(zone)),
implementor_(Class::Handle(zone)),
old_subclasses_(GrowableObjectArray::Handle(zone)),
new_subclasses_(GrowableObjectArray::Handle(zone)),
subclass_(Class::Handle(zone)),
null_list_(GrowableObjectArray::Handle(zone)) {}
void VisitClass(const Class& klass) {
old_implementors_ = klass.direct_implementors_unsafe();
if (!old_implementors_.IsNull()) {
new_implementors_ = GrowableObjectArray::New();
for (intptr_t i = 0; i < old_implementors_.Length(); i++) {
implementor_ ^= old_implementors_.At(i);
if (implementor_.id() != kIllegalCid) {
new_implementors_.Add(implementor_);
}
}
if (new_implementors_.Length() == 0) {
klass.set_direct_implementors(null_list_);
} else {
klass.set_direct_implementors(new_implementors_);
}
}
old_subclasses_ = klass.direct_subclasses_unsafe();
if (!old_subclasses_.IsNull()) {
new_subclasses_ = GrowableObjectArray::New();
for (intptr_t i = 0; i < old_subclasses_.Length(); i++) {
subclass_ ^= old_subclasses_.At(i);
if (subclass_.id() != kIllegalCid) {
new_subclasses_.Add(subclass_);
}
}
if (new_subclasses_.Length() == 0) {
klass.set_direct_subclasses(null_list_);
} else {
klass.set_direct_subclasses(new_subclasses_);
}
}
}
private:
GrowableObjectArray& old_implementors_;
GrowableObjectArray& new_implementors_;
Class& implementor_;
GrowableObjectArray& old_subclasses_;
GrowableObjectArray& new_subclasses_;
Class& subclass_;
GrowableObjectArray& null_list_;
};
PruneSubclassesVisitor visitor(zone);
SafepointWriteRwLocker ml(Thread::Current(), isolate_group->program_lock());
WalkProgram(zone, isolate_group, &visitor);
}
#endif // defined(DART_PRECOMPILER)
class CodeSourceMapKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const CodeSourceMap* Key;
typedef const CodeSourceMap* Value;
typedef const CodeSourceMap* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) {
ASSERT(!key->IsNull());
return Utils::WordHash(key->Length());
}
static inline bool IsKeyEqual(Pair pair, Key key) {
ASSERT(!pair->IsNull() && !key->IsNull());
return pair->Equals(*key);
}
};
void ProgramVisitor::DedupCodeSourceMaps(Zone* zone,
IsolateGroup* isolate_group) {
class DedupCodeSourceMapsVisitor
: public CodeVisitor,
public Dedupper<CodeSourceMap, CodeSourceMapKeyValueTrait> {
public:
explicit DedupCodeSourceMapsVisitor(Zone* zone)
: Dedupper(zone), code_source_map_(CodeSourceMap::Handle(zone)) {
if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
// Prefer existing objects in the VM isolate.
AddVMBaseObjects();
}
}
void VisitCode(const Code& code) {
code_source_map_ = code.code_source_map();
code_source_map_ = Dedup(code_source_map_);
code.set_code_source_map(code_source_map_);
}
private:
CodeSourceMap& code_source_map_;
};
DedupCodeSourceMapsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
class ArrayKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const Array* Key;
typedef const Array* Value;
typedef const Array* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) {
ASSERT(!key->IsNull());
return Utils::WordHash(key->Length());
}
static inline bool IsKeyEqual(Pair pair, Key key) {
ASSERT(!pair->IsNull() && !key->IsNull());
if (pair->Length() != key->Length()) return false;
for (intptr_t i = 0; i < pair->Length(); i++) {
if (pair->At(i) != key->At(i)) return false;
}
return true;
}
};
void ProgramVisitor::DedupLists(Zone* zone, IsolateGroup* isolate_group) {
class DedupListsVisitor : public CodeVisitor,
public Dedupper<Array, ArrayKeyValueTrait> {
public:
explicit DedupListsVisitor(Zone* zone)
: Dedupper(zone),
list_(Array::Handle(zone)),
field_(Field::Handle(zone)) {}
void VisitCode(const Code& code) {
if (!code.IsFunctionCode()) return;
list_ = code.inlined_id_to_function();
list_ = Dedup(list_);
code.set_inlined_id_to_function(list_);
list_ = code.deopt_info_array();
list_ = Dedup(list_);
code.set_deopt_info_array(list_);
list_ = code.static_calls_target_table();
list_ = Dedup(list_);
code.set_static_calls_target_table(list_);
}
void VisitFunction(const Function& function) {
list_ = PrepareParameterNames(function);
list_ = Dedup(list_);
function.set_parameter_names(list_);
// No need to dedup parameter types, as they are stored in the
// canonicalized function type of the function.
// However, the function type of the function is only needed in case of
// recompilation or if available to mirrors, or for copied types
// to lazily generated tear offs. Also avoid attempting to change
// read-only VM objects for de-duplication.
// We cannot check precisely if a function is an entry point here,
// because the metadata has been dropped already. However, we use the
// has_pragma flag on the function as a conservative approximation.
// Resolution requires the number of parameters (no signature needed) and
// their names if any named parameter is required (signature needed).
if (FLAG_precompiled_mode && !function.InVMIsolateHeap() &&
!function.IsClosureFunction() && !function.IsFfiTrampoline() &&
function.name() != Symbols::Call().ptr() && !function.is_native() &&
!function.HasRequiredNamedParameters() &&
!MayBeEntryPoint(function)) {
// Function type not needed for function type tests or resolution.
function.set_signature(Object::null_function_type());
}
}
private:
bool IsCorrectType(const Object& obj) const { return obj.IsArray(); }
ArrayPtr PrepareParameterNames(const Function& function) {
list_ = function.parameter_names();
// Preserve parameter names in case of recompilation for the JIT. Also
// avoid attempting to change read-only VM objects for de-duplication.
if (FLAG_precompiled_mode && !list_.IsNull() &&
!list_.InVMIsolateHeap() && !function.HasOptionalNamedParameters()) {
// Parameter names not needed for resolution.
ASSERT(list_.Length() == function.NumParameters());
for (intptr_t i = 0; i < list_.Length(); i++) {
list_.SetAt(i, Symbols::OptimizedOut());
}
}
return list_.ptr();
}
bool MayBeEntryPoint(const Function& function) {
// Metadata has been dropped already.
// Use presence of pragma as conservative approximation.
if (function.has_pragma()) return true;
auto kind = function.kind();
if ((kind == UntaggedFunction::kImplicitGetter) ||
(kind == UntaggedFunction::kImplicitSetter) ||
(kind == UntaggedFunction::kImplicitStaticGetter) ||
(kind == UntaggedFunction::kFieldInitializer)) {
field_ = function.accessor_field();
if (!field_.IsNull() && field_.has_pragma()) return true;
}
return false;
}
Array& list_;
Field& field_;
};
DedupListsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
// Traits for comparing two [Instructions] objects for equality, which is
// implemented as bit-wise equality.
//
// This considers two instruction objects to be equal even if they have
// different static call targets. Since the static call targets are called via
// the object pool this is ok.
class InstructionsKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const Instructions* Key;
typedef const Instructions* Value;
typedef const Instructions* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) { return key->Hash(); }
static inline bool IsKeyEqual(Pair pair, Key key) {
return pair->Equals(*key);
}
};
// Traits for comparing two [Code] objects for equality.
//
// The instruction deduplication naturally causes us to have a one-to-many
// relationship between Instructions and Code objects.
//
// In AOT bare instructions mode frames only have PCs. However, the runtime
// needs e.g. stack maps from the [Code] to scan such a frame. So we ensure that
// instructions of code objects are only deduplicated if the metadata in the
// code is the same. The runtime can then pick any code object corresponding to
// the PC in the frame and use the metadata.
//
// In AOT non-bare instructions mode frames are expanded, like in JIT, and
// contain the unique code object.
#if defined(DART_PRECOMPILER)
class CodeKeyValueTrait {
public:
// Typedefs needed for the DirectChainedHashMap template.
typedef const Code* Key;
typedef const Code* Value;
typedef const Code* Pair;
static Key KeyOf(Pair kv) { return kv; }
static Value ValueOf(Pair kv) { return kv; }
static inline uword Hash(Key key) { return Utils::WordHash(key->Size()); }
static inline bool IsKeyEqual(Pair pair, Key key) {
// In AOT, disabled code objects should not be considered for deduplication.
ASSERT(!pair->IsDisabled() && !key->IsDisabled());
if (pair->ptr() == key->ptr()) return true;
// Notice we assume that these entries have already been de-duped, so we
// can use pointer equality.
if (pair->static_calls_target_table() != key->static_calls_target_table()) {
return false;
}
if (pair->pc_descriptors() != key->pc_descriptors()) {
return false;
}
if (pair->compressed_stackmaps() != key->compressed_stackmaps()) {
return false;
}
if (pair->catch_entry_moves_maps() != key->catch_entry_moves_maps()) {
return false;
}
if (pair->exception_handlers() != key->exception_handlers()) {
return false;
}
if (pair->UncheckedEntryPointOffset() != key->UncheckedEntryPointOffset()) {
return false;
}
return Instructions::Equals(pair->instructions(), key->instructions());
}
};
#endif
void ProgramVisitor::DedupInstructions(Zone* zone,
IsolateGroup* isolate_group) {
class DedupInstructionsVisitor
: public CodeVisitor,
public Dedupper<Instructions, InstructionsKeyValueTrait>,
public ObjectVisitor {
public:
explicit DedupInstructionsVisitor(Zone* zone)
: Dedupper(zone),
code_(Code::Handle(zone)),
instructions_(Instructions::Handle(zone)) {
if (Snapshot::IncludesCode(Dart::vm_snapshot_kind())) {
// Prefer existing objects in the VM isolate.
Dart::vm_isolate_group()->heap()->VisitObjectsImagePages(this);
}
}
void VisitObject(ObjectPtr obj) {
if (!obj->IsInstructions()) return;
instructions_ = Instructions::RawCast(obj);
AddCanonical(instructions_);
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) return;
code_ = function.CurrentCode();
// This causes the code to be visited once here and once directly in the
// ProgramWalker, but as long as the deduplication process is idempotent,
// the cached entry points won't change during the second visit.
VisitCode(code_);
function.SetInstructionsSafe(code_); // Update cached entry point.
}
void VisitCode(const Code& code) {
instructions_ = code.instructions();
instructions_ = Dedup(instructions_);
code.set_instructions(instructions_);
if (code.IsDisabled()) {
instructions_ = code.active_instructions();
instructions_ = Dedup(instructions_);
}
code.SetActiveInstructionsSafe(instructions_,
code.UncheckedEntryPointOffset());
}
private:
Code& code_;
Instructions& instructions_;
};
#if defined(DART_PRECOMPILER)
class DedupInstructionsWithSameMetadataVisitor
: public CodeVisitor,
public Dedupper<Code, CodeKeyValueTrait> {
public:
explicit DedupInstructionsWithSameMetadataVisitor(Zone* zone)
: Dedupper(zone),
canonical_(Code::Handle(zone)),
code_(Code::Handle(zone)),
instructions_(Instructions::Handle(zone)) {}
void VisitFunction(const Function& function) {
if (!function.HasCode()) return;
code_ = function.CurrentCode();
// This causes the code to be visited once here and once directly in the
// ProgramWalker, but as long as the deduplication process is idempotent,
// the cached entry points won't change during the second visit.
VisitCode(code_);
function.SetInstructionsSafe(code_); // Update cached entry point.
}
void VisitCode(const Code& code) {
if (code.IsDisabled()) return;
canonical_ = Dedup(code);
instructions_ = canonical_.instructions();
code.SetActiveInstructionsSafe(instructions_,
code.UncheckedEntryPointOffset());
code.set_instructions(instructions_);
}
private:
bool CanCanonicalize(const Code& code) const { return !code.IsDisabled(); }
Code& canonical_;
Code& code_;
Instructions& instructions_;
};
if (FLAG_precompiled_mode && FLAG_use_bare_instructions) {
DedupInstructionsWithSameMetadataVisitor visitor(zone);
return WalkProgram(zone, isolate_group, &visitor);
}
#endif // defined(DART_PRECOMPILER)
DedupInstructionsVisitor visitor(zone);
WalkProgram(zone, isolate_group, &visitor);
}
void ProgramVisitor::Dedup(Thread* thread) {
auto const isolate_group = thread->isolate_group();
StackZone stack_zone(thread);
HANDLESCOPE(thread);
auto const zone = thread->zone();
BindStaticCalls(zone, isolate_group);
ShareMegamorphicBuckets(zone, isolate_group);
NormalizeAndDedupCompressedStackMaps(zone, isolate_group);
DedupPcDescriptors(zone, isolate_group);
DedupDeoptEntries(zone, isolate_group);
#if defined(DART_PRECOMPILER)
DedupCatchEntryMovesMaps(zone, isolate_group);
DedupUnlinkedCalls(zone, isolate_group);
PruneSubclasses(zone, isolate_group);
#endif
DedupCodeSourceMaps(zone, isolate_group);
DedupLists(zone, isolate_group);
// Reduces binary size but obfuscates profiler results.
if (FLAG_dedup_instructions) {
// In non-bare mode (unused atm) dedupping instructions would cause us to
// loose the ability to uniquely map a PC to a given UnlinkedCall object,
// since two code objects might point to the same deduped instructions
// object but might have two different UnlinkedCall objects in their pool.
//
// In bare mode this cannot happen because different UnlinkedCall objects
// would get different indices into the (global) object pool, therefore
// making the instructions different.
//
// (When transitioning the switchable call site we loose track of the args
// descriptor. Since we need it for further transitions we currently save it
// via a PC -> UnlinkedCall mapping).
//
// We therfore disable the instruction deduplication in product-non-bare
// mode (which is unused atm).
#if defined(PRODUCT)
if (FLAG_precompiled_mode && !FLAG_use_bare_instructions) return;
#endif
DedupInstructions(zone, isolate_group);
}
}
#if defined(DART_PRECOMPILER)
class AssignLoadingUnitsCodeVisitor : public CodeVisitor {
public:
explicit AssignLoadingUnitsCodeVisitor(Zone* zone)
: heap_(Thread::Current()->heap()),
func_(Function::Handle(zone)),
cls_(Class::Handle(zone)),
lib_(Library::Handle(zone)),
unit_(LoadingUnit::Handle(zone)),
obj_(Object::Handle(zone)) {}
void VisitCode(const Code& code) {
intptr_t id;
if (code.IsFunctionCode()) {
func_ ^= code.function();
cls_ = func_.Owner();
lib_ = cls_.library();
unit_ = lib_.loading_unit();
id = unit_.id();
} else if (code.IsAllocationStubCode()) {
cls_ ^= code.owner();
lib_ = cls_.library();
unit_ = lib_.loading_unit();
id = unit_.id();
} else if (code.IsStubCode()) {
id = LoadingUnit::kRootId;
} else {
UNREACHABLE();
}
ASSERT(heap_->GetLoadingUnit(code.ptr()) == WeakTable::kNoValue);
heap_->SetLoadingUnit(code.ptr(), id);
obj_ = code.code_source_map();
MergeAssignment(obj_, id);
obj_ = code.compressed_stackmaps();
MergeAssignment(obj_, id);
if (!FLAG_use_bare_instructions) {
obj_ = code.object_pool();
MergeAssignment(obj_, id);
}
}
void MergeAssignment(const Object& obj, intptr_t id) {
if (obj.IsNull()) return;
intptr_t old_id = heap_->GetLoadingUnit(obj_.ptr());
if (old_id == WeakTable::kNoValue) {
heap_->SetLoadingUnit(obj_.ptr(), id);
} else if (old_id == id) {
// Shared with another code in the same loading unit.
} else {
// Shared with another code in a different loading unit.
// Could assign to dominating loading unit.
heap_->SetLoadingUnit(obj_.ptr(), LoadingUnit::kRootId);
}
}
private:
Heap* heap_;
Function& func_;
Class& cls_;
Library& lib_;
LoadingUnit& unit_;
Object& obj_;
};
void ProgramVisitor::AssignUnits(Thread* thread) {
StackZone stack_zone(thread);
HANDLESCOPE(thread);
Zone* zone = thread->zone();
// VM stubs.
Instructions& inst = Instructions::Handle(zone);
Code& code = Code::Handle(zone);
for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
inst = StubCode::EntryAt(i).instructions();
thread->heap()->SetLoadingUnit(inst.ptr(), LoadingUnit::kRootId);
}
// Isolate stubs.
ObjectStore* object_store = thread->isolate_group()->object_store();
ObjectPtr* from = object_store->from();
ObjectPtr* to = object_store->to_snapshot(Snapshot::kFullAOT);
for (ObjectPtr* p = from; p <= to; p++) {
if ((*p)->IsCode()) {
code ^= *p;
inst = code.instructions();
thread->heap()->SetLoadingUnit(inst.ptr(), LoadingUnit::kRootId);
}
}
// Function code / allocation stubs.
AssignLoadingUnitsCodeVisitor visitor(zone);
WalkProgram(zone, thread->isolate_group(), &visitor);
}
class ProgramHashVisitor : public CodeVisitor {
public:
explicit ProgramHashVisitor(Zone* zone)
: str_(String::Handle(zone)),
pool_(ObjectPool::Handle(zone)),
obj_(Object::Handle(zone)),
instr_(Instructions::Handle(zone)),
hash_(0) {}
void VisitClass(const Class& cls) {
str_ = cls.Name();
VisitInstance(str_);
}
void VisitFunction(const Function& function) {
str_ = function.name();
VisitInstance(str_);
}
void VisitCode(const Code& code) {
pool_ = code.object_pool();
VisitPool(pool_);
instr_ = code.instructions();
hash_ = CombineHashes(hash_, instr_.Hash());
}
void VisitPool(const ObjectPool& pool) {
if (pool.IsNull()) return;
for (intptr_t i = 0; i < pool.Length(); i++) {
if (pool.TypeAt(i) == ObjectPool::EntryType::kTaggedObject) {
obj_ = pool.ObjectAt(i);
if (obj_.IsInstance()) {
VisitInstance(Instance::Cast(obj_));
}
}
}
}
void VisitInstance(const Instance& instance) {
hash_ = CombineHashes(hash_, instance.CanonicalizeHash());
}
uint32_t hash() const { return FinalizeHash(hash_, String::kHashBits); }
private:
String& str_;
ObjectPool& pool_;
Object& obj_;
Instructions& instr_;
uint32_t hash_;
};
uint32_t ProgramVisitor::Hash(Thread* thread) {
StackZone stack_zone(thread);
HANDLESCOPE(thread);
Zone* zone = thread->zone();
ProgramHashVisitor visitor(zone);
WalkProgram(zone, thread->isolate_group(), &visitor);
visitor.VisitPool(ObjectPool::Handle(
zone, thread->isolate_group()->object_store()->global_object_pool()));
return visitor.hash();
}
#endif // defined(DART_PRECOMPILER)
} // namespace dart
#endif // defined(DART_PRECOMPILED_RUNTIME)