blob: 49badbb4b9bf3c72420f033c2feb22f965c69cca [file] [log] [blame]
// Copyright (c) 2020, 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/closure_functions_cache.h"
#include "vm/compiler/jit/compiler.h"
#include "vm/object.h"
#include "vm/object_store.h"
namespace dart {
FunctionPtr ClosureFunctionsCache::LookupClosureFunction(
const Class& owner,
TokenPosition token_pos) {
auto thread = Thread::Current();
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
return LookupClosureFunctionLocked(owner, token_pos);
}
FunctionPtr ClosureFunctionsCache::LookupClosureFunctionLocked(
const Class& owner,
TokenPosition token_pos) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
DEBUG_ASSERT(
thread->isolate_group()->program_lock()->IsCurrentThreadReader());
const auto& closures =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
auto& closure = Function::Handle(zone);
intptr_t num_closures = closures.Length();
for (intptr_t i = 0; i < num_closures; i++) {
closure ^= closures.At(i);
if (closure.token_pos() == token_pos && closure.Owner() == owner.ptr()) {
return closure.ptr();
}
}
return Function::null();
}
FunctionPtr ClosureFunctionsCache::LookupClosureFunction(
const Function& parent,
TokenPosition token_pos) {
auto thread = Thread::Current();
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
return LookupClosureFunctionLocked(parent, token_pos);
}
FunctionPtr ClosureFunctionsCache::LookupClosureFunctionLocked(
const Function& parent,
TokenPosition token_pos) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
DEBUG_ASSERT(
thread->isolate_group()->program_lock()->IsCurrentThreadReader());
const auto& closures =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
auto& closure = Function::Handle(zone);
intptr_t num_closures = closures.Length();
for (intptr_t i = 0; i < num_closures; i++) {
closure ^= closures.At(i);
if (closure.token_pos() == token_pos &&
closure.parent_function() == parent.ptr()) {
return closure.ptr();
}
}
return Function::null();
}
void ClosureFunctionsCache::AddClosureFunctionLocked(
const Function& function,
bool allow_implicit_closure_functions /* = false */) {
ASSERT(!Compiler::IsBackgroundCompilation());
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
DEBUG_ASSERT(
thread->isolate_group()->program_lock()->IsCurrentThreadWriter());
const auto& closures =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
ASSERT(!closures.IsNull());
ASSERT(allow_implicit_closure_functions ||
function.IsNonImplicitClosureFunction());
closures.Add(function, Heap::kOld);
}
intptr_t ClosureFunctionsCache::FindClosureIndex(const Function& needle) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
const auto& closures_array =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
intptr_t num_closures = closures_array.Length();
for (intptr_t i = 0; i < num_closures; i++) {
if (closures_array.At(i) == needle.ptr()) {
return i;
}
}
return -1;
}
FunctionPtr ClosureFunctionsCache::ClosureFunctionFromIndex(intptr_t idx) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
const auto& closures_array =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
if (idx < 0 || idx >= closures_array.Length()) {
return Function::null();
}
return Function::RawCast(closures_array.At(idx));
}
FunctionPtr ClosureFunctionsCache::GetUniqueInnerClosure(
const Function& outer) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
const auto& closures =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
auto& entry = Function::Handle(zone);
for (intptr_t i = (closures.Length() - 1); i >= 0; i--) {
entry ^= closures.At(i);
if (entry.parent_function() == outer.ptr()) {
#if defined(DEBUG)
auto& other = Function::Handle(zone);
for (intptr_t j = i - 1; j >= 0; j--) {
other ^= closures.At(j);
ASSERT(other.parent_function() != outer.ptr());
}
#endif
return entry.ptr();
}
}
return Function::null();
}
void ClosureFunctionsCache::ForAllClosureFunctions(
std::function<bool(const Function&)> callback) {
auto thread = Thread::Current();
auto zone = thread->zone();
auto object_store = thread->isolate_group()->object_store();
auto& current_data = Array::Handle(zone);
auto& entry = Function::Handle(zone);
// NOTE: Inner functions may get added to the closures array while iterating -
// we guarantee that any closure functions added on this thread by a
// [callback] call will be visited as well.
//
// We avoid holding a lock while accessing the closures array, since often
// times [callback] will do very heavy things (e.g. compiling the function).
//
// This means we can possibly miss a concurrently added closure function -
// which the caller should be ok with (or it guarantees that this cannot
// happen).
const auto& closures =
GrowableObjectArray::Handle(zone, object_store->closure_functions());
if (!thread->IsInStoppedMutatorsScope()) {
// The empty read locker scope will implicitly issue an acquire memory
// fence, which means any closure functions added so far will be visible and
// iterated further down.
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
}
// We have an outer loop to ensure any new closure functions added by
// [callback] will be iterated as well.
intptr_t i = 0;
while (true) {
intptr_t current_length = closures.Length();
if (i == current_length) break;
current_data = closures.data();
if (current_data.Length() < current_length) {
current_length = current_data.Length();
}
for (; i < current_length; ++i) {
entry ^= current_data.At(i);
if (!callback(entry)) {
return; // Stop iteration.
}
}
}
}
} // namespace dart