mirror of
https://github.com/dart-lang/sdk
synced 2024-09-19 20:41:45 +00:00
b1c09ecd8f
Currently we have things called XPtr which are not what you get from ptr().
Old world:
handle->raw() returns RawObject* (tagged)
raw_obj->ptr() returns RawObject* (untagged)
After 6fe15f6df9
:
handle->raw() returns ObjectPtr
obj_ptr->ptr() returns ObjectLayout*
New world:
handle->ptr() returns ObjectPtr
obj_ptr->untag() returns UntaggedObject*
TEST=ci
Change-Id: I6c7f34014cf20737607caaf84979838300d12df2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/149367
Commit-Queue: Ryan Macnak <rmacnak@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Reviewed-by: Siva Annamalai <asiva@google.com>
Reviewed-by: Vyacheslav Egorov <vegorov@google.com>
279 lines
11 KiB
C++
279 lines
11 KiB
C++
// Copyright (c) 2011, 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/resolver.h"
|
|
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/flags.h"
|
|
#include "vm/isolate.h"
|
|
#include "vm/log.h"
|
|
#include "vm/object.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/symbols.h"
|
|
|
|
namespace dart {
|
|
|
|
DEFINE_FLAG(bool, trace_resolving, false, "Trace resolving.");
|
|
|
|
// The actual names of named arguments are not checked by the dynamic resolver,
|
|
// but by the method entry code. It is important that the dynamic resolver
|
|
// checks that no named arguments are passed to a method that does not accept
|
|
// them, since the entry code of such a method does not check for named
|
|
// arguments. The dynamic resolver actually checks that a valid number of named
|
|
// arguments is passed in.
|
|
FunctionPtr Resolver::ResolveDynamic(const Instance& receiver,
|
|
const String& function_name,
|
|
const ArgumentsDescriptor& args_desc) {
|
|
// Figure out type of receiver first.
|
|
const Class& cls = Class::Handle(receiver.clazz());
|
|
return ResolveDynamicForReceiverClass(cls, function_name, args_desc);
|
|
}
|
|
|
|
static FunctionPtr ResolveDynamicAnyArgsWithCustomLookup(
|
|
Zone* zone,
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
bool allow_add,
|
|
std::function<FunctionPtr(Class&, const String&)> lookup) {
|
|
Class& cls = Class::Handle(zone, receiver_class.ptr());
|
|
if (FLAG_trace_resolving) {
|
|
THR_Print("ResolveDynamic '%s' for class %s\n", function_name.ToCString(),
|
|
String::Handle(zone, cls.Name()).ToCString());
|
|
}
|
|
Function& function = Function::Handle(zone);
|
|
|
|
const String& demangled = String::Handle(
|
|
zone,
|
|
Function::IsDynamicInvocationForwarderName(function_name)
|
|
? Function::DemangleDynamicInvocationForwarderName(function_name)
|
|
: function_name.ptr());
|
|
|
|
const bool is_getter = Field::IsGetterName(demangled);
|
|
String& demangled_getter_name = String::Handle();
|
|
if (is_getter) {
|
|
demangled_getter_name = Field::NameFromGetter(demangled);
|
|
}
|
|
|
|
const bool is_dyn_call = demangled.ptr() != function_name.ptr();
|
|
|
|
Thread* thread = Thread::Current();
|
|
bool need_to_create_method_extractor = false;
|
|
while (!cls.IsNull()) {
|
|
if (is_dyn_call) {
|
|
// Try to find a dyn:* forwarder & return it.
|
|
function = cls.GetInvocationDispatcher(
|
|
function_name, Array::null_array(),
|
|
UntaggedFunction::kDynamicInvocationForwarder,
|
|
/*create_if_absent=*/false);
|
|
}
|
|
if (!function.IsNull()) return function.ptr();
|
|
|
|
ASSERT(cls.is_finalized());
|
|
{
|
|
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
|
|
function = lookup(cls, demangled);
|
|
}
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// In JIT we might need to lazily create a dyn:* forwarder.
|
|
if (is_dyn_call && !function.IsNull()) {
|
|
function =
|
|
function.GetDynamicInvocationForwarder(function_name, allow_add);
|
|
}
|
|
#endif
|
|
if (!function.IsNull()) return function.ptr();
|
|
|
|
// Getter invocation might actually be a method extraction.
|
|
if (is_getter) {
|
|
SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
|
|
function = lookup(cls, demangled_getter_name);
|
|
if (!function.IsNull()) {
|
|
if (allow_add && FLAG_lazy_dispatchers) {
|
|
need_to_create_method_extractor = true;
|
|
break;
|
|
} else {
|
|
return Function::null();
|
|
}
|
|
}
|
|
}
|
|
cls = cls.SuperClass();
|
|
}
|
|
if (need_to_create_method_extractor) {
|
|
// We were looking for the getter but found a method with the same
|
|
// name. Create a method extractor and return it.
|
|
// Use GetMethodExtractor instead of CreateMethodExtractor to ensure
|
|
// nobody created method extractor since we last checked under ReadRwLocker.
|
|
function = function.GetMethodExtractor(demangled);
|
|
}
|
|
return function.ptr();
|
|
}
|
|
|
|
static FunctionPtr ResolveDynamicForReceiverClassWithCustomLookup(
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
const ArgumentsDescriptor& args_desc,
|
|
bool allow_add,
|
|
std::function<FunctionPtr(Class&, const String&)> lookup) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
|
|
Function& function = Function::Handle(
|
|
zone, ResolveDynamicAnyArgsWithCustomLookup(
|
|
zone, receiver_class, function_name, allow_add, lookup));
|
|
|
|
if (function.IsNull() || !function.AreValidArguments(args_desc, NULL)) {
|
|
// Return a null function to signal to the upper levels to dispatch to
|
|
// "noSuchMethod" function.
|
|
if (FLAG_trace_resolving) {
|
|
String& error_message =
|
|
String::Handle(zone, Symbols::New(thread, "function not found"));
|
|
if (!function.IsNull()) {
|
|
// Obtain more detailed error message.
|
|
function.AreValidArguments(args_desc, &error_message);
|
|
}
|
|
THR_Print("ResolveDynamic error '%s': %s.\n", function_name.ToCString(),
|
|
error_message.ToCString());
|
|
}
|
|
return Function::null();
|
|
}
|
|
return function.ptr();
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveDynamicForReceiverClass(
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
const ArgumentsDescriptor& args_desc,
|
|
bool allow_add) {
|
|
return ResolveDynamicForReceiverClassWithCustomLookup(
|
|
receiver_class, function_name, args_desc, allow_add,
|
|
std::mem_fn(&Class::LookupDynamicFunctionUnsafe));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveDynamicForReceiverClassAllowPrivate(
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
const ArgumentsDescriptor& args_desc,
|
|
bool allow_add) {
|
|
return ResolveDynamicForReceiverClassWithCustomLookup(
|
|
receiver_class, function_name, args_desc, allow_add,
|
|
std::mem_fn(&Class::LookupDynamicFunctionAllowPrivate));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveFunction(Zone* zone,
|
|
const Class& receiver_class,
|
|
const String& function_name) {
|
|
return ResolveDynamicAnyArgsWithCustomLookup(
|
|
zone, receiver_class, function_name, /*allow_add=*/false,
|
|
std::mem_fn(static_cast<FunctionPtr (Class::*)(const String&) const>(
|
|
&Class::LookupFunctionReadLocked)));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveDynamicFunction(Zone* zone,
|
|
const Class& receiver_class,
|
|
const String& function_name) {
|
|
return ResolveDynamicAnyArgsWithCustomLookup(
|
|
zone, receiver_class, function_name, /*allow_add=*/false,
|
|
std::mem_fn(static_cast<FunctionPtr (Class::*)(const String&) const>(
|
|
&Class::LookupDynamicFunctionUnsafe)));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveDynamicAnyArgs(Zone* zone,
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
bool allow_add) {
|
|
return ResolveDynamicAnyArgsWithCustomLookup(
|
|
zone, receiver_class, function_name, allow_add,
|
|
std::mem_fn(&Class::LookupDynamicFunctionUnsafe));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveDynamicAnyArgsAllowPrivate(
|
|
Zone* zone,
|
|
const Class& receiver_class,
|
|
const String& function_name,
|
|
bool allow_add) {
|
|
return ResolveDynamicAnyArgsWithCustomLookup(
|
|
zone, receiver_class, function_name, allow_add,
|
|
std::mem_fn(&Class::LookupDynamicFunctionAllowPrivate));
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveStatic(const Library& library,
|
|
const String& class_name,
|
|
const String& function_name,
|
|
intptr_t type_args_len,
|
|
intptr_t num_arguments,
|
|
const Array& argument_names) {
|
|
ASSERT(!library.IsNull());
|
|
Function& function = Function::Handle();
|
|
if (class_name.IsNull() || (class_name.Length() == 0)) {
|
|
// Check if we are referring to a top level function.
|
|
const Object& object = Object::Handle(library.ResolveName(function_name));
|
|
if (!object.IsNull() && object.IsFunction()) {
|
|
function ^= object.ptr();
|
|
if (!function.AreValidArguments(type_args_len, num_arguments,
|
|
argument_names, NULL)) {
|
|
if (FLAG_trace_resolving) {
|
|
String& error_message = String::Handle();
|
|
// Obtain more detailed error message.
|
|
function.AreValidArguments(type_args_len, num_arguments,
|
|
argument_names, &error_message);
|
|
THR_Print("ResolveStatic error '%s': %s.\n",
|
|
function_name.ToCString(), error_message.ToCString());
|
|
}
|
|
function = Function::null();
|
|
}
|
|
} else {
|
|
if (FLAG_trace_resolving) {
|
|
THR_Print("ResolveStatic error: function '%s' not found.\n",
|
|
function_name.ToCString());
|
|
}
|
|
}
|
|
} else {
|
|
// Lookup class_name in the library's class dictionary to get at
|
|
// the dart class object. If class_name is not found in the dictionary
|
|
// ResolveStatic will return a NULL function object.
|
|
const Class& cls = Class::Handle(library.LookupClass(class_name));
|
|
if (!cls.IsNull()) {
|
|
function = ResolveStatic(cls, function_name, type_args_len, num_arguments,
|
|
argument_names);
|
|
}
|
|
if (FLAG_trace_resolving && function.IsNull()) {
|
|
THR_Print("ResolveStatic error: function '%s.%s' not found.\n",
|
|
class_name.ToCString(), function_name.ToCString());
|
|
}
|
|
}
|
|
return function.ptr();
|
|
}
|
|
|
|
FunctionPtr Resolver::ResolveStatic(const Class& cls,
|
|
const String& function_name,
|
|
intptr_t type_args_len,
|
|
intptr_t num_arguments,
|
|
const Array& argument_names) {
|
|
ASSERT(!cls.IsNull());
|
|
if (FLAG_trace_resolving) {
|
|
THR_Print("ResolveStatic '%s'\n", function_name.ToCString());
|
|
}
|
|
const Function& function =
|
|
Function::Handle(cls.LookupStaticFunction(function_name));
|
|
if (function.IsNull() ||
|
|
!function.AreValidArguments(type_args_len, num_arguments, argument_names,
|
|
NULL)) {
|
|
// Return a null function to signal to the upper levels to throw a
|
|
// resolution error or maybe throw the error right here.
|
|
if (FLAG_trace_resolving) {
|
|
String& error_message = String::Handle(String::New("function not found"));
|
|
if (!function.IsNull()) {
|
|
// Obtain more detailed error message.
|
|
function.AreValidArguments(type_args_len, num_arguments, argument_names,
|
|
&error_message);
|
|
}
|
|
THR_Print("ResolveStatic error '%s': %s.\n", function_name.ToCString(),
|
|
error_message.ToCString());
|
|
}
|
|
return Function::null();
|
|
}
|
|
return function.ptr();
|
|
}
|
|
|
|
} // namespace dart
|