[vm/ffi] Cleanup FFI call trampolines
After [1], FFI call sequence is generated inside a Dart closure
function and separate FFI call trampolines are no longer used.
This change removes all code related to FFI call trampolines.
[1] https://dart-review.googlesource.com/c/sdk/+/339662
TEST=existing
Change-Id: I0af0be6441009fb4db885ee172b0487f4796fd18
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/340302
Commit-Queue: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Daco Harkes <dacoharkes@google.com>
diff --git a/runtime/lib/ffi.cc b/runtime/lib/ffi.cc
index 7464031..0d06325 100644
--- a/runtime/lib/ffi.cc
+++ b/runtime/lib/ffi.cc
@@ -20,7 +20,6 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
#include "vm/compiler/assembler/assembler.h"
-#include "vm/compiler/ffi/call.h"
#include "vm/compiler/ffi/callback.h"
#include "vm/compiler/ffi/marshaller.h"
#include "vm/compiler/jit/compiler.h"
diff --git a/runtime/vm/canonical_tables.h b/runtime/vm/canonical_tables.h
index 70e4618..0b0f5ef 100644
--- a/runtime/vm/canonical_tables.h
+++ b/runtime/vm/canonical_tables.h
@@ -425,7 +425,7 @@
f1.FfiCSignature() == f2.FfiCSignature() &&
f1.FfiCallbackExceptionalReturn() ==
f2.FfiCallbackExceptionalReturn() &&
- f1.GetFfiFunctionKind() == f2.GetFfiFunctionKind());
+ f1.GetFfiCallbackKind() == f2.GetFfiCallbackKind());
}
static bool ReportStats() { return false; }
};
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index b98a9c4..2a28718 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -1044,7 +1044,7 @@
// Local closure function.
const auto& target = Function::Cast(entry);
AddFunction(target, RetainReasons::kLocalClosure);
- if (target.IsFfiTrampoline()) {
+ if (target.IsFfiCallbackTrampoline()) {
const auto& callback_target =
Function::Handle(Z, target.FfiCallbackTarget());
if (!callback_target.IsNull()) {
@@ -1117,7 +1117,7 @@
const Class& owner = Class::Handle(Z, function.Owner());
AddTypesOf(owner);
- if (function.IsFfiTrampoline()) {
+ if (function.IsFfiCallbackTrampoline()) {
AddType(FunctionType::Handle(Z, function.FfiCSignature()));
}
@@ -2030,7 +2030,7 @@
// Ffi trampoline functions are not reachable from program structure,
// they are referenced only from code (object pool).
if (!functions_to_retain_.ContainsKey(function) &&
- !function.IsFfiTrampoline()) {
+ !function.IsFfiCallbackTrampoline()) {
FATAL("Function %s was not traced in TraceForRetainedFunctions\n",
function.ToFullyQualifiedCString());
}
@@ -2189,7 +2189,7 @@
// which need the signature.
return AddRetainReason(sig, RetainReasons::kClosureSignature);
}
- if (function.IsFfiTrampoline()) {
+ if (function.IsFfiCallbackTrampoline()) {
// FFI trampolines may be dynamically called.
return AddRetainReason(sig, RetainReasons::kFfiTrampolineSignature);
}
@@ -3015,7 +3015,7 @@
}
// Retain Code objects corresponding to FFI trampolines.
- if (function_.IsFfiTrampoline()) {
+ if (function_.IsFfiCallbackTrampoline()) {
++codes_with_ffi_trampoline_function_;
return;
}
@@ -3455,8 +3455,7 @@
function.AttachCode(code);
}
- if (function.IsFfiTrampoline() &&
- function.GetFfiFunctionKind() != FfiFunctionKind::kCall) {
+ if (function.IsFfiCallbackTrampoline()) {
compiler::ffi::SetFfiCallbackCode(thread(), function, code);
}
}
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index 1688efe..b208aac 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -167,7 +167,7 @@
bool FlowGraph::ShouldReorderBlocks(const Function& function,
bool is_optimized) {
return is_optimized && FLAG_reorder_basic_blocks &&
- !function.is_intrinsic() && !function.IsFfiTrampoline();
+ !function.is_intrinsic() && !function.IsFfiCallbackTrampoline();
}
GrowableArray<BlockEntryInstr*>* FlowGraph::CodegenBlockOrder(
diff --git a/runtime/vm/compiler/backend/il_serializer.cc b/runtime/vm/compiler/backend/il_serializer.cc
index b2d5dfc..d3cbf79 100644
--- a/runtime/vm/compiler/backend/il_serializer.cc
+++ b/runtime/vm/compiler/backend/il_serializer.cc
@@ -11,7 +11,6 @@
#include "vm/compiler/backend/flow_graph.h"
#include "vm/compiler/backend/il.h"
#include "vm/compiler/backend/range_analysis.h"
-#include "vm/compiler/ffi/call.h"
#include "vm/compiler/frontend/flow_graph_builder.h"
#include "vm/object_store.h"
#include "vm/parser.h"
@@ -837,20 +836,12 @@
return;
}
case UntaggedFunction::kFfiTrampoline: {
- s->Write<uint8_t>(static_cast<uint8_t>(x.GetFfiFunctionKind()));
+ s->Write<uint8_t>(static_cast<uint8_t>(x.GetFfiCallbackKind()));
s->Write<const FunctionType&>(
FunctionType::Handle(zone, x.FfiCSignature()));
- if (x.GetFfiFunctionKind() != FfiFunctionKind::kCall) {
- s->Write<const Function&>(
- Function::Handle(zone, x.FfiCallbackTarget()));
- s->Write<const Instance&>(
- Instance::Handle(zone, x.FfiCallbackExceptionalReturn()));
- } else {
- s->Write<const String&>(String::Handle(zone, x.name()));
- s->Write<const FunctionType&>(
- FunctionType::Handle(zone, x.signature()));
- s->Write<bool>(x.FfiIsLeaf());
- }
+ s->Write<const Function&>(Function::Handle(zone, x.FfiCallbackTarget()));
+ s->Write<const Instance&>(
+ Instance::Handle(zone, x.FfiCallbackExceptionalReturn()));
return;
}
default:
@@ -927,23 +918,14 @@
target.GetDynamicInvocationForwarder(name));
}
case UntaggedFunction::kFfiTrampoline: {
- const FfiFunctionKind kind =
- static_cast<FfiFunctionKind>(d->Read<uint8_t>());
+ const FfiCallbackKind kind =
+ static_cast<FfiCallbackKind>(d->Read<uint8_t>());
const FunctionType& c_signature = d->Read<const FunctionType&>();
- if (kind != FfiFunctionKind::kCall) {
- const Function& callback_target = d->Read<const Function&>();
- const Instance& exceptional_return = d->Read<const Instance&>();
- return Function::ZoneHandle(
- zone, compiler::ffi::NativeCallbackFunction(
- c_signature, callback_target, exceptional_return, kind));
- } else {
- const String& name = d->Read<const String&>();
- const FunctionType& signature = d->Read<const FunctionType&>();
- const bool is_leaf = d->Read<bool>();
- return Function::ZoneHandle(
- zone, compiler::ffi::TrampolineFunction(name, signature,
- c_signature, is_leaf));
- }
+ const Function& callback_target = d->Read<const Function&>();
+ const Instance& exceptional_return = d->Read<const Instance&>();
+ return Function::ZoneHandle(
+ zone, compiler::ffi::NativeCallbackFunction(
+ c_signature, callback_target, exceptional_return, kind));
}
default:
UNIMPLEMENTED();
diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni
index 9a051b6e..997bb8d 100644
--- a/runtime/vm/compiler/compiler_sources.gni
+++ b/runtime/vm/compiler/compiler_sources.gni
@@ -100,8 +100,6 @@
"compiler_timings.h",
"ffi/abi.cc",
"ffi/abi.h",
- "ffi/call.cc",
- "ffi/call.h",
"ffi/callback.cc",
"ffi/callback.h",
"ffi/frame_rebase.cc",
diff --git a/runtime/vm/compiler/ffi/call.cc b/runtime/vm/compiler/ffi/call.cc
deleted file mode 100644
index faf6936..0000000
--- a/runtime/vm/compiler/ffi/call.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-// 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/compiler/ffi/call.h"
-
-#include "vm/class_finalizer.h"
-#include "vm/symbols.h"
-
-namespace dart {
-
-namespace compiler {
-
-namespace ffi {
-
-// TODO(dartbug.com/36607): Cache the trampolines.
-FunctionPtr TrampolineFunction(const String& name,
- const FunctionType& signature,
- const FunctionType& c_signature,
- bool is_leaf) {
- ASSERT(signature.num_implicit_parameters() == 1);
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- const Library& lib = Library::Handle(zone, Library::FfiLibrary());
- const Class& owner_class = Class::Handle(zone, lib.toplevel_class());
- Function& function = Function::Handle(
- zone, Function::New(signature, name, UntaggedFunction::kFfiTrampoline,
- /*is_static=*/true,
- /*is_const=*/false,
- /*is_abstract=*/false,
- /*is_external=*/false,
- /*is_native=*/false, owner_class,
- TokenPosition::kMinSource));
- function.set_is_debuggable(false);
-
- // Create unique names for the parameters, as they are used in scope building
- // and error messages.
- if (signature.num_fixed_parameters() > 0) {
- function.CreateNameArray();
- function.SetParameterNameAt(0, Symbols::ClosureParameter());
- auto& param_name = String::Handle(zone);
- for (intptr_t i = 1, n = signature.num_fixed_parameters(); i < n; ++i) {
- param_name = Symbols::NewFormatted(thread, ":ffi_param%" Pd, i);
- function.SetParameterNameAt(i, param_name);
- }
- }
-
- function.SetFfiCSignature(c_signature);
- function.SetFfiIsLeaf(is_leaf);
- function.SetFfiFunctionKind(FfiFunctionKind::kCall);
-
- return function.ptr();
-}
-
-FunctionPtr TrampolineFunction(const FunctionType& dart_signature,
- const FunctionType& c_signature,
- bool is_leaf,
- const String& function_name) {
- Thread* thread = Thread::Current();
- Zone* zone = thread->zone();
- String& name =
- String::Handle(zone, Symbols::NewFormatted(thread, "FfiTrampoline_%s",
- function_name.ToCString()));
-
- // Trampolines have no optional arguments.
- FunctionType& signature = FunctionType::Handle(zone, FunctionType::New());
- const intptr_t num_fixed = dart_signature.num_fixed_parameters();
- signature.set_num_implicit_parameters(1);
- signature.set_num_fixed_parameters(num_fixed);
- signature.set_result_type(
- AbstractType::Handle(zone, dart_signature.result_type()));
- signature.set_parameter_types(
- Array::Handle(zone, dart_signature.parameter_types()));
- signature ^= ClassFinalizer::FinalizeType(signature);
-
- return TrampolineFunction(name, signature, c_signature, is_leaf);
-}
-
-} // namespace ffi
-
-} // namespace compiler
-
-} // namespace dart
diff --git a/runtime/vm/compiler/ffi/call.h b/runtime/vm/compiler/ffi/call.h
deleted file mode 100644
index 11c328a..0000000
--- a/runtime/vm/compiler/ffi/call.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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.
-
-#ifndef RUNTIME_VM_COMPILER_FFI_CALL_H_
-#define RUNTIME_VM_COMPILER_FFI_CALL_H_
-
-#if defined(DART_PRECOMPILED_RUNTIME)
-#error "AOT runtime should not use compiler sources (including header files)"
-#endif // defined(DART_PRECOMPILED_RUNTIME)
-
-#include <platform/globals.h>
-
-#include "vm/raw_object.h"
-
-namespace dart {
-
-namespace compiler {
-
-namespace ffi {
-
-FunctionPtr TrampolineFunction(const String& name,
- const FunctionType& signature,
- const FunctionType& c_signature,
- bool is_leaf);
-
-FunctionPtr TrampolineFunction(const FunctionType& dart_signature,
- const FunctionType& c_signature,
- bool is_leaf,
- const String& function_name);
-
-} // namespace ffi
-
-} // namespace compiler
-
-} // namespace dart
-
-#endif // RUNTIME_VM_COMPILER_FFI_CALL_H_
diff --git a/runtime/vm/compiler/ffi/callback.cc b/runtime/vm/compiler/ffi/callback.cc
index 7a9ea1c..984b2a0 100644
--- a/runtime/vm/compiler/ffi/callback.cc
+++ b/runtime/vm/compiler/ffi/callback.cc
@@ -18,13 +18,13 @@
const String& NativeCallbackFunctionName(Thread* thread,
Zone* zone,
const Function& dart_target,
- FfiFunctionKind kind) {
+ FfiCallbackKind kind) {
switch (kind) {
- case FfiFunctionKind::kAsyncCallback:
+ case FfiCallbackKind::kAsyncCallback:
return Symbols::FfiAsyncCallback();
- case FfiFunctionKind::kIsolateLocalClosureCallback:
+ case FfiCallbackKind::kIsolateLocalClosureCallback:
return Symbols::FfiIsolateLocalCallback();
- case FfiFunctionKind::kIsolateLocalStaticCallback:
+ case FfiCallbackKind::kIsolateLocalStaticCallback:
return String::Handle(
zone, Symbols::FromConcat(thread, Symbols::FfiCallback(),
String::Handle(zone, dart_target.name())));
@@ -36,7 +36,7 @@
FunctionPtr NativeCallbackFunction(const FunctionType& c_signature,
const Function& dart_target,
const Instance& exceptional_return,
- FfiFunctionKind kind) {
+ FfiCallbackKind kind) {
Thread* const thread = Thread::Current();
Zone* const zone = thread->zone();
Function& function = Function::Handle(zone);
@@ -64,7 +64,7 @@
// the body.
function.SetFfiCSignature(c_signature);
function.SetFfiCallbackTarget(dart_target);
- function.SetFfiFunctionKind(kind);
+ function.SetFfiCallbackKind(kind);
// We need to load the exceptional return value as a constant in the generated
// function. Even though the FE ensures that it is a constant, it could still
diff --git a/runtime/vm/compiler/ffi/callback.h b/runtime/vm/compiler/ffi/callback.h
index 88af9a99..02b4294 100644
--- a/runtime/vm/compiler/ffi/callback.h
+++ b/runtime/vm/compiler/ffi/callback.h
@@ -23,7 +23,7 @@
FunctionPtr NativeCallbackFunction(const FunctionType& c_signature,
const Function& dart_target,
const Instance& exceptional_return,
- FfiFunctionKind kind);
+ FfiCallbackKind kind);
// Builds a mapping from `callback-id` to code object / ...
//
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index 5e57d1c..8b78359 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -7,7 +7,6 @@
#include <utility>
#include "vm/compiler/backend/range_analysis.h" // For Range.
-#include "vm/compiler/ffi/call.h"
#include "vm/compiler/frontend/flow_graph_builder.h" // For InlineExitCollector.
#include "vm/compiler/jit/compiler.h" // For Compiler::IsBackgroundCompilation().
#include "vm/compiler/runtime_api.h"
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index 5fb0834..ee5c2be 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -3352,14 +3352,14 @@
return BuildFfiCall();
case MethodRecognizer::kFfiNativeCallbackFunction:
return BuildFfiNativeCallbackFunction(
- FfiFunctionKind::kIsolateLocalStaticCallback);
+ FfiCallbackKind::kIsolateLocalStaticCallback);
case MethodRecognizer::kFfiNativeAddressOf:
return BuildFfiNativeAddressOf();
case MethodRecognizer::kFfiNativeIsolateLocalCallbackFunction:
return BuildFfiNativeCallbackFunction(
- FfiFunctionKind::kIsolateLocalClosureCallback);
+ FfiCallbackKind::kIsolateLocalClosureCallback);
case MethodRecognizer::kFfiNativeAsyncCallbackFunction:
- return BuildFfiNativeCallbackFunction(FfiFunctionKind::kAsyncCallback);
+ return BuildFfiNativeCallbackFunction(FfiCallbackKind::kAsyncCallback);
case MethodRecognizer::kFfiLoadAbiSpecificInt:
return BuildLoadAbiSpecificInt(/*at_index=*/false);
case MethodRecognizer::kFfiLoadAbiSpecificIntAtIndex:
@@ -6325,23 +6325,23 @@
}
Fragment StreamingFlowGraphBuilder::BuildFfiNativeCallbackFunction(
- FfiFunctionKind kind) {
+ FfiCallbackKind kind) {
// The call-site must look like this (guaranteed by the FE which inserts it):
//
- // FfiFunctionKind::kIsolateLocalStaticCallback:
+ // FfiCallbackKind::kIsolateLocalStaticCallback:
// _nativeCallbackFunction<NativeSignatureType>(target, exceptionalReturn)
//
- // FfiFunctionKind::kAsyncCallback:
+ // FfiCallbackKind::kAsyncCallback:
// _nativeAsyncCallbackFunction<NativeSignatureType>()
//
- // FfiFunctionKind::kIsolateLocalClosureCallback:
+ // FfiCallbackKind::kIsolateLocalClosureCallback:
// _nativeIsolateLocalCallbackFunction<NativeSignatureType>(
// exceptionalReturn)
//
// The FE also guarantees that the arguments are constants.
- const bool has_target = kind == FfiFunctionKind::kIsolateLocalStaticCallback;
- const bool has_exceptional_return = kind != FfiFunctionKind::kAsyncCallback;
+ const bool has_target = kind == FfiCallbackKind::kIsolateLocalStaticCallback;
+ const bool has_exceptional_return = kind != FfiCallbackKind::kAsyncCallback;
const intptr_t expected_argc =
static_cast<int>(has_target) + static_cast<int>(has_exceptional_return);
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
index 75811a2..475d660 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
@@ -392,7 +392,7 @@
// Build FG for '_nativeCallbackFunction'. Reads an Arguments from the
// Kernel buffer and pushes the resulting Function object.
- Fragment BuildFfiNativeCallbackFunction(FfiFunctionKind kind);
+ Fragment BuildFfiNativeCallbackFunction(FfiCallbackKind kind);
Fragment BuildFfiNativeAddressOf();
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index add8438..1c18201 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -5031,15 +5031,12 @@
FlowGraph* FlowGraphBuilder::BuildGraphOfFfiTrampoline(
const Function& function) {
- switch (function.GetFfiFunctionKind()) {
- case FfiFunctionKind::kIsolateLocalStaticCallback:
- case FfiFunctionKind::kIsolateLocalClosureCallback:
+ switch (function.GetFfiCallbackKind()) {
+ case FfiCallbackKind::kIsolateLocalStaticCallback:
+ case FfiCallbackKind::kIsolateLocalClosureCallback:
return BuildGraphOfSyncFfiCallback(function);
- case FfiFunctionKind::kAsyncCallback:
+ case FfiCallbackKind::kAsyncCallback:
return BuildGraphOfAsyncFfiCallback(function);
- case FfiFunctionKind::kCall:
- UNREACHABLE();
- return nullptr;
}
UNREACHABLE();
return nullptr;
@@ -5330,8 +5327,8 @@
RELEASE_ASSERT(error == nullptr);
RELEASE_ASSERT(marshaller_ptr != nullptr);
const auto& marshaller = *marshaller_ptr;
- const bool is_closure = function.GetFfiFunctionKind() ==
- FfiFunctionKind::kIsolateLocalClosureCallback;
+ const bool is_closure = function.GetFfiCallbackKind() ==
+ FfiCallbackKind::kIsolateLocalClosureCallback;
graph_entry_ =
new (Z) GraphEntryInstr(*parsed_function_, Compiler::kNoOSRDeoptId);
diff --git a/runtime/vm/compiler/frontend/scope_builder.cc b/runtime/vm/compiler/frontend/scope_builder.cc
index fa148b5..435d92f 100644
--- a/runtime/vm/compiler/frontend/scope_builder.cc
+++ b/runtime/vm/compiler/frontend/scope_builder.cc
@@ -407,17 +407,14 @@
}
case UntaggedFunction::kFfiTrampoline: {
needs_expr_temp_ = true;
- // Callbacks and calls with handles need try/catch variables.
- if ((function.GetFfiFunctionKind() != FfiFunctionKind::kCall ||
- function.FfiCSignatureContainsHandles())) {
- ++depth_.try_;
- AddTryVariables();
- --depth_.try_;
- ++depth_.catch_;
- AddCatchVariables();
- FinalizeCatchVariables();
- --depth_.catch_;
- }
+ // Callbacks need try/catch variables.
+ ++depth_.try_;
+ AddTryVariables();
+ --depth_.try_;
+ ++depth_.catch_;
+ AddCatchVariables();
+ FinalizeCatchVariables();
+ --depth_.catch_;
FALL_THROUGH;
}
case UntaggedFunction::kInvokeFieldDispatcher: {
@@ -438,7 +435,7 @@
LocalVariable* variable = MakeVariable(
TokenPosition::kNoSource, TokenPosition::kNoSource,
String::ZoneHandle(Z, function.ParameterNameAt(i)),
- AbstractType::ZoneHandle(Z, function.IsFfiTrampoline()
+ AbstractType::ZoneHandle(Z, function.IsFfiCallbackTrampoline()
? function.ParameterTypeAt(i)
: Object::dynamic_type().ptr()));
bool added = scope_->InsertParameterAt(i, variable);
diff --git a/runtime/vm/compiler/jit/compiler.cc b/runtime/vm/compiler/jit/compiler.cc
index ff2122f..46b07a2 100644
--- a/runtime/vm/compiler/jit/compiler.cc
+++ b/runtime/vm/compiler/jit/compiler.cc
@@ -476,8 +476,7 @@
}
}
- if (function.IsFfiTrampoline() &&
- function.GetFfiFunctionKind() != FfiFunctionKind::kCall) {
+ if (function.IsFfiCallbackTrampoline()) {
compiler::ffi::SetFfiCallbackCode(thread(), function, code);
}
diff --git a/runtime/vm/ffi_callback_metadata.cc b/runtime/vm/ffi_callback_metadata.cc
index c8d5f3c..93febd1 100644
--- a/runtime/vm/ffi_callback_metadata.cc
+++ b/runtime/vm/ffi_callback_metadata.cc
@@ -275,13 +275,13 @@
if (closure.IsNull()) {
// If the closure is null, it means the target is a static function, so is
// baked into the trampoline and is an ordinary sync callback.
- ASSERT(function.GetFfiFunctionKind() ==
- FfiFunctionKind::kIsolateLocalStaticCallback);
+ ASSERT(function.GetFfiCallbackKind() ==
+ FfiCallbackKind::kIsolateLocalStaticCallback);
return CreateSyncFfiCallbackImpl(isolate, zone, function, nullptr,
list_head);
} else {
- ASSERT(function.GetFfiFunctionKind() ==
- FfiFunctionKind::kIsolateLocalClosureCallback);
+ ASSERT(function.GetFfiCallbackKind() ==
+ FfiCallbackKind::kIsolateLocalClosureCallback);
return CreateSyncFfiCallbackImpl(isolate, zone, function,
CreatePersistentHandle(isolate, closure),
list_head);
@@ -319,7 +319,7 @@
const Function& send_function,
Dart_Port send_port,
Metadata** list_head) {
- ASSERT(send_function.GetFfiFunctionKind() == FfiFunctionKind::kAsyncCallback);
+ ASSERT(send_function.GetFfiCallbackKind() == FfiCallbackKind::kAsyncCallback);
return CreateMetadataEntry(isolate, TrampolineType::kAsync,
GetEntryPoint(zone, send_function),
static_cast<uint64_t>(send_port), list_head);
diff --git a/runtime/vm/ffi_callback_metadata_test.cc b/runtime/vm/ffi_callback_metadata_test.cc
index 2040e1d..b09896b 100644
--- a/runtime/vm/ffi_callback_metadata_test.cc
+++ b/runtime/vm/ffi_callback_metadata_test.cc
@@ -22,7 +22,7 @@
namespace dart {
-FunctionPtr CreateTestFunction(FfiFunctionKind kind) {
+FunctionPtr CreateTestFunction(FfiCallbackKind kind) {
const auto& ffi_lib = Library::Handle(Library::FfiLibrary());
const auto& ffi_void = Class::Handle(ffi_lib.LookupClass(Symbols::FfiVoid()));
const auto& ffi_void_type =
@@ -92,7 +92,7 @@
auto* zone = thread->zone();
const auto& func = Function::Handle(
- CreateTestFunction(FfiFunctionKind::kIsolateLocalStaticCallback));
+ CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
const auto& code = Code::Handle(func.EnsureHasCode());
EXPECT(!code.IsNull());
@@ -185,7 +185,7 @@
auto* zone = thread->zone();
const Function& func =
- Function::Handle(CreateTestFunction(FfiFunctionKind::kAsyncCallback));
+ Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
const Code& code = Code::Handle(func.EnsureHasCode());
EXPECT(!code.IsNull());
@@ -280,13 +280,13 @@
auto* zone = thread->zone();
const Function& func = Function::Handle(
- CreateTestFunction(FfiFunctionKind::kIsolateLocalClosureCallback));
+ CreateTestFunction(FfiCallbackKind::kIsolateLocalClosureCallback));
const Code& code = Code::Handle(func.EnsureHasCode());
EXPECT(!code.IsNull());
- // Using a FfiFunctionKind::kSync function as a dummy closure.
+ // Using a FfiCallbackKind::kSync function as a dummy closure.
const Function& closure_func = Function::Handle(
- CreateTestFunction(FfiFunctionKind::kIsolateLocalStaticCallback));
+ CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
const Context& context = Context::Handle(Context::null());
const Closure& closure1 = Closure::Handle(
Closure::New(Object::null_type_arguments(),
@@ -373,7 +373,7 @@
auto* fcm = FfiCallbackMetadata::Instance();
const Function& func =
- Function::Handle(CreateTestFunction(FfiFunctionKind::kAsyncCallback));
+ Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
const Code& code = Code::Handle(func.EnsureHasCode());
EXPECT(!code.IsNull());
@@ -440,7 +440,7 @@
FfiCallbackMetadata::Metadata* list_head = nullptr;
const auto& sync_func = Function::Handle(
- CreateTestFunction(FfiFunctionKind::kIsolateLocalStaticCallback));
+ CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
const auto& sync_code = Code::Handle(sync_func.EnsureHasCode());
EXPECT(!sync_code.IsNull());
@@ -521,11 +521,11 @@
FfiCallbackMetadata::Metadata* list_head = nullptr;
const Function& async_func =
- Function::Handle(CreateTestFunction(FfiFunctionKind::kAsyncCallback));
+ Function::Handle(CreateTestFunction(FfiCallbackKind::kAsyncCallback));
const Code& async_code = Code::Handle(async_func.EnsureHasCode());
EXPECT(!async_code.IsNull());
const Function& sync_func = Function::Handle(
- CreateTestFunction(FfiFunctionKind::kIsolateLocalStaticCallback));
+ CreateTestFunction(FfiCallbackKind::kIsolateLocalStaticCallback));
const auto& sync_code = Code::Handle(sync_func.EnsureHasCode());
EXPECT(!sync_code.IsNull());
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index f4ed6f2..dbee5e74 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -8336,7 +8336,8 @@
FunctionPtr Function::implicit_closure_function() const {
if (IsClosureFunction() || IsDispatcherOrImplicitAccessor() ||
- IsFieldInitializer() || IsFfiTrampoline() || IsMethodExtractor()) {
+ IsFieldInitializer() || IsFfiCallbackTrampoline() ||
+ IsMethodExtractor()) {
return Function::null();
}
const Object& obj = Object::Handle(data());
@@ -8371,7 +8372,7 @@
}
void Function::SetFfiCSignature(const FunctionType& sig) const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
FfiTrampolineData::Cast(obj).set_c_signature(sig);
@@ -8379,7 +8380,7 @@
FunctionTypePtr Function::FfiCSignature() const {
auto* const zone = Thread::Current()->zone();
- if (IsFfiTrampoline()) {
+ if (IsFfiCallbackTrampoline()) {
const Object& obj = Object::Handle(zone, data());
ASSERT(!obj.IsNull());
return FfiTrampolineData::Cast(obj).c_signature();
@@ -8420,7 +8421,7 @@
// Keep consistent with BaseMarshaller::IsCompound.
bool Function::FfiCSignatureReturnsStruct() const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
Zone* zone = Thread::Current()->zone();
const auto& c_signature = FunctionType::Handle(zone, FfiCSignature());
const auto& type = AbstractType::Handle(zone, c_signature.result_type());
@@ -8446,8 +8447,7 @@
}
int32_t Function::FfiCallbackId() const {
- ASSERT(IsFfiTrampoline());
- ASSERT(GetFfiFunctionKind() != FfiFunctionKind::kCall);
+ ASSERT(IsFfiCallbackTrampoline());
const auto& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
@@ -8459,8 +8459,7 @@
}
void Function::AssignFfiCallbackId(int32_t callback_id) const {
- ASSERT(IsFfiTrampoline());
- ASSERT(GetFfiFunctionKind() != FfiFunctionKind::kCall);
+ ASSERT(IsFfiCallbackTrampoline());
const auto& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
@@ -8472,11 +8471,6 @@
bool Function::FfiIsLeaf() const {
Zone* zone = Thread::Current()->zone();
- if (IsFfiTrampoline()) {
- const Object& obj = Object::Handle(untag()->data());
- ASSERT(!obj.IsNull());
- return FfiTrampolineData::Cast(obj).is_leaf();
- }
auto& pragma_value = Instance::Handle(zone);
if (is_ffi_native()) {
pragma_value = GetNativeAnnotation();
@@ -8497,50 +8491,43 @@
.value();
}
-void Function::SetFfiIsLeaf(bool is_leaf) const {
- ASSERT(IsFfiTrampoline());
- const Object& obj = Object::Handle(untag()->data());
- ASSERT(!obj.IsNull());
- FfiTrampolineData::Cast(obj).set_is_leaf(is_leaf);
-}
-
FunctionPtr Function::FfiCallbackTarget() const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
return FfiTrampolineData::Cast(obj).callback_target();
}
void Function::SetFfiCallbackTarget(const Function& target) const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
FfiTrampolineData::Cast(obj).set_callback_target(target);
}
InstancePtr Function::FfiCallbackExceptionalReturn() const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
return FfiTrampolineData::Cast(obj).callback_exceptional_return();
}
void Function::SetFfiCallbackExceptionalReturn(const Instance& value) const {
- ASSERT(IsFfiTrampoline());
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
FfiTrampolineData::Cast(obj).set_callback_exceptional_return(value);
}
-FfiFunctionKind Function::GetFfiFunctionKind() const {
- ASSERT(IsFfiTrampoline());
+FfiCallbackKind Function::GetFfiCallbackKind() const {
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
return FfiTrampolineData::Cast(obj).ffi_function_kind();
}
-void Function::SetFfiFunctionKind(FfiFunctionKind value) const {
- ASSERT(IsFfiTrampoline());
+void Function::SetFfiCallbackKind(FfiCallbackKind value) const {
+ ASSERT(IsFfiCallbackTrampoline());
const Object& obj = Object::Handle(data());
ASSERT(!obj.IsNull());
FfiTrampolineData::Cast(obj).set_ffi_function_kind(value);
@@ -9146,8 +9133,8 @@
bool Function::ForceOptimize() const {
if (RecognizedKindForceOptimize() || IsFfiCallClosure() ||
- IsFfiTrampoline() || is_ffi_native() || IsTypedDataViewFactory() ||
- IsUnmodifiableTypedDataViewFactory()) {
+ IsFfiCallbackTrampoline() || is_ffi_native() ||
+ IsTypedDataViewFactory() || IsUnmodifiableTypedDataViewFactory()) {
return true;
}
@@ -9280,7 +9267,7 @@
#if !defined(DART_PRECOMPILED_RUNTIME)
bool Function::CanBeInlined() const {
if (ForceOptimize()) {
- if (IsFfiCallClosure() || IsFfiTrampoline() || is_ffi_native()) {
+ if (IsFfiCallClosure() || IsFfiCallbackTrampoline() || is_ffi_native()) {
// We currently don't support inlining FFI trampolines. Some of them
// are naturally non-inlinable because they contain a try/catch block,
// but this condition is broader than strictly necessary.
@@ -11032,7 +11019,7 @@
intptr_t Function::KernelLibraryIndex() const {
if (IsNoSuchMethodDispatcher() || IsInvokeFieldDispatcher() ||
- IsFfiTrampoline()) {
+ IsFfiCallbackTrampoline()) {
return -1;
}
if (is_eval_function()) {
@@ -11795,16 +11782,12 @@
StoreNonPointer(&untag()->callback_id_, callback_id);
}
-void FfiTrampolineData::set_is_leaf(bool is_leaf) const {
- StoreNonPointer(&untag()->is_leaf_, is_leaf);
-}
-
void FfiTrampolineData::set_callback_exceptional_return(
const Instance& value) const {
untag()->set_callback_exceptional_return(value.ptr());
}
-void FfiTrampolineData::set_ffi_function_kind(FfiFunctionKind kind) const {
+void FfiTrampolineData::set_ffi_function_kind(FfiCallbackKind kind) const {
StoreNonPointer(&untag()->ffi_function_kind_, static_cast<uint8_t>(kind));
}
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index a97f89f..255cab4 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -2949,8 +2949,7 @@
}
};
-enum class FfiFunctionKind : uint8_t {
- kCall,
+enum class FfiCallbackKind : uint8_t {
kIsolateLocalStaticCallback,
kIsolateLocalClosureCallback,
kAsyncCallback,
@@ -2986,37 +2985,31 @@
bool FfiCSignatureReturnsStruct() const;
// Can only be called on FFI trampolines.
- // -1 for Dart -> native calls.
int32_t FfiCallbackId() const;
// Should be called when ffi trampoline function object is created.
void AssignFfiCallbackId(int32_t callback_id) const;
- // Can only be called on FFI trampolines.
+ // Can only be called on FFI natives and FFI call closures.
bool FfiIsLeaf() const;
// Can only be called on FFI trampolines.
- void SetFfiIsLeaf(bool is_leaf) const;
-
- // Can only be called on FFI trampolines.
- // Null for Dart -> native calls.
FunctionPtr FfiCallbackTarget() const;
// Can only be called on FFI trampolines.
void SetFfiCallbackTarget(const Function& target) const;
// Can only be called on FFI trampolines.
- // Null for Dart -> native calls.
InstancePtr FfiCallbackExceptionalReturn() const;
// Can only be called on FFI trampolines.
void SetFfiCallbackExceptionalReturn(const Instance& value) const;
// Can only be called on FFI trampolines.
- FfiFunctionKind GetFfiFunctionKind() const;
+ FfiCallbackKind GetFfiCallbackKind() const;
// Can only be called on FFI trampolines.
- void SetFfiFunctionKind(FfiFunctionKind value) const;
+ void SetFfiCallbackKind(FfiCallbackKind value) const;
// Return the signature of this function.
PRECOMPILER_WSR_FIELD_DECLARATION(FunctionType, signature);
@@ -3902,10 +3895,10 @@
}
// Returns true if this function represents an ffi trampoline.
- bool IsFfiTrampoline() const {
+ bool IsFfiCallbackTrampoline() const {
return kind() == UntaggedFunction::kFfiTrampoline;
}
- static bool IsFfiTrampoline(FunctionPtr function) {
+ static bool IsFfiCallbackTrampoline(FunctionPtr function) {
NoSafepointScope no_safepoint;
return function->untag()->kind_tag_.Read<KindBits>() ==
UntaggedFunction::kFfiTrampoline;
@@ -4354,17 +4347,14 @@
}
void set_callback_exceptional_return(const Instance& value) const;
- FfiFunctionKind ffi_function_kind() const {
- return static_cast<FfiFunctionKind>(untag()->ffi_function_kind_);
+ FfiCallbackKind ffi_function_kind() const {
+ return static_cast<FfiCallbackKind>(untag()->ffi_function_kind_);
}
- void set_ffi_function_kind(FfiFunctionKind kind) const;
+ void set_ffi_function_kind(FfiCallbackKind kind) const;
int32_t callback_id() const { return untag()->callback_id_; }
void set_callback_id(int32_t value) const;
- bool is_leaf() const { return untag()->is_leaf_; }
- void set_is_leaf(bool value) const;
-
static FfiTrampolineDataPtr New();
FINAL_HEAP_OBJECT_IMPLEMENTATION(FfiTrampolineData, Object);
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index 291d46e..15e8b7f 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -1501,10 +1501,7 @@
// Check 'callback_target_' to determine if this is a callback or not.
int32_t callback_id_;
- // Whether this is a leaf call - i.e. one that doesn't call back into Dart.
- bool is_leaf_;
-
- // The kind of trampoline this is. See FfiFunctionKind.
+ // The kind of trampoline this is. See FfiCallbackKind.
uint8_t ffi_function_kind_;
};
diff --git a/runtime/vm/resolver.cc b/runtime/vm/resolver.cc
index 1d1b196..1947035 100644
--- a/runtime/vm/resolver.cc
+++ b/runtime/vm/resolver.cc
@@ -129,7 +129,7 @@
// FfiTrampolines are the only functions that can still be called
// dynamically without going through a dynamic invocation forwarder.
RELEASE_ASSERT(!Function::IsDynamicInvocationForwarderName(function_name) &&
- !function.IsFfiTrampoline());
+ !function.IsFfiCallbackTrampoline());
// The signature for this function was dropped in the precompiler, which
// means it is not a possible target for a dynamic call in the program.
// That means we're resolving an UnlinkedCall for an InstanceCall to
