Martin Kustermann
a791ecc30e
To avoid accidental code that calls stubs without emitting proper (deopt-id, deopt-env) metadata, we enforce that it's always present for stub calls and add another GenerateNonLazyDeoptableStubCall for cases where it's intentionally omitted. The environment has in many cases been still emitted before, due to the usage of `pending_deoptimization_env` though we make code pass it explicitly (just as the deopt-id). We may want to consider deprecating this `pending_deoptimization_env`. Issue https://github.com/dart-lang/sdk/issues/45213 TEST=Existing test suite. Change-Id: I93f1d5ba4d74da5f9afa4b526ad57b9d032ca99e Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/197164 Commit-Queue: Martin Kustermann <kustermann@google.com> Reviewed-by: Vyacheslav Egorov <vegorov@google.com>
195 lines
8.5 KiB
C++
195 lines
8.5 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.
|
|
|
|
#ifndef RUNTIME_VM_RUNTIME_ENTRY_H_
|
|
#define RUNTIME_VM_RUNTIME_ENTRY_H_
|
|
|
|
#include "vm/allocation.h"
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
#include "vm/compiler/runtime_api.h"
|
|
#endif
|
|
#include "vm/flags.h"
|
|
#include "vm/heap/safepoint.h"
|
|
#include "vm/log.h"
|
|
#include "vm/native_arguments.h"
|
|
#include "vm/runtime_entry_list.h"
|
|
|
|
namespace dart {
|
|
|
|
typedef void (*RuntimeFunction)(NativeArguments arguments);
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
using BaseRuntimeEntry = compiler::RuntimeEntry;
|
|
#else
|
|
using BaseRuntimeEntry = ValueObject;
|
|
#endif
|
|
|
|
// Class RuntimeEntry is used to encapsulate runtime functions, it includes
|
|
// the entry point for the runtime function and the number of arguments expected
|
|
// by the function.
|
|
class RuntimeEntry : public BaseRuntimeEntry {
|
|
public:
|
|
RuntimeEntry(const char* name,
|
|
RuntimeFunction function,
|
|
intptr_t argument_count,
|
|
bool is_leaf,
|
|
bool is_float,
|
|
bool can_lazy_deopt)
|
|
:
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
compiler::RuntimeEntry(this, &CallInternal),
|
|
#endif
|
|
name_(name),
|
|
function_(function),
|
|
argument_count_(argument_count),
|
|
is_leaf_(is_leaf),
|
|
is_float_(is_float),
|
|
can_lazy_deopt_(can_lazy_deopt) {
|
|
}
|
|
|
|
const char* name() const { return name_; }
|
|
RuntimeFunction function() const { return function_; }
|
|
intptr_t argument_count() const { return argument_count_; }
|
|
bool is_leaf() const { return is_leaf_; }
|
|
bool is_float() const { return is_float_; }
|
|
bool can_lazy_deopt() const { return can_lazy_deopt_; }
|
|
uword GetEntryPoint() const;
|
|
|
|
// Generate code to call the runtime entry.
|
|
NOT_IN_PRECOMPILED(void Call(compiler::Assembler* assembler,
|
|
intptr_t argument_count) const);
|
|
|
|
protected:
|
|
NOT_IN_PRECOMPILED(static void CallInternal(const RuntimeEntry* runtime_entry,
|
|
compiler::Assembler* assembler,
|
|
intptr_t argument_count));
|
|
|
|
private:
|
|
const char* const name_;
|
|
const RuntimeFunction function_;
|
|
const intptr_t argument_count_;
|
|
const bool is_leaf_;
|
|
const bool is_float_;
|
|
const bool can_lazy_deopt_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(RuntimeEntry);
|
|
};
|
|
|
|
#ifdef DEBUG
|
|
#define TRACE_RUNTIME_CALL(format, name) \
|
|
if (FLAG_trace_runtime_calls) { \
|
|
THR_Print("Runtime call: " format "\n", name); \
|
|
}
|
|
#else
|
|
#define TRACE_RUNTIME_CALL(format, name) \
|
|
do { \
|
|
} while (0)
|
|
#endif
|
|
|
|
#if defined(USING_SIMULATOR)
|
|
#define CHECK_SIMULATOR_STACK_OVERFLOW() \
|
|
if (!OSThread::Current()->HasStackHeadroom()) { \
|
|
Exceptions::ThrowStackOverflow(); \
|
|
}
|
|
#else
|
|
#define CHECK_SIMULATOR_STACK_OVERFLOW()
|
|
#endif // defined(USING_SIMULATOR)
|
|
|
|
// Helper macros for declaring and defining runtime entries.
|
|
|
|
#define DEFINE_RUNTIME_ENTRY_IMPL(name, argument_count, can_lazy_deopt) \
|
|
extern void DRT_##name(NativeArguments arguments); \
|
|
extern const RuntimeEntry k##name##RuntimeEntry("DRT_" #name, &DRT_##name, \
|
|
argument_count, false, \
|
|
false, can_lazy_deopt); \
|
|
static void DRT_Helper##name(Isolate* isolate, Thread* thread, Zone* zone, \
|
|
NativeArguments arguments); \
|
|
void DRT_##name(NativeArguments arguments) { \
|
|
CHECK_STACK_ALIGNMENT; \
|
|
/* Tell MemorySanitizer 'arguments' is initialized by generated code. */ \
|
|
MSAN_UNPOISON(&arguments, sizeof(arguments)); \
|
|
ASSERT(arguments.ArgCount() == argument_count); \
|
|
TRACE_RUNTIME_CALL("%s", "" #name); \
|
|
{ \
|
|
Thread* thread = arguments.thread(); \
|
|
ASSERT(thread == Thread::Current()); \
|
|
RuntimeCallDeoptScope runtime_call_deopt_scope( \
|
|
thread, can_lazy_deopt ? RuntimeCallDeoptAbility::kCanLazyDeopt \
|
|
: RuntimeCallDeoptAbility::kCannotLazyDeopt); \
|
|
Isolate* isolate = thread->isolate(); \
|
|
TransitionGeneratedToVM transition(thread); \
|
|
StackZone zone(thread); \
|
|
HANDLESCOPE(thread); \
|
|
CHECK_SIMULATOR_STACK_OVERFLOW(); \
|
|
if (FLAG_deoptimize_on_runtime_call_every > 0) { \
|
|
OnEveryRuntimeEntryCall(thread, "" #name, can_lazy_deopt); \
|
|
} \
|
|
DRT_Helper##name(isolate, thread, zone.GetZone(), arguments); \
|
|
} \
|
|
} \
|
|
static void DRT_Helper##name(Isolate* isolate, Thread* thread, Zone* zone, \
|
|
NativeArguments arguments)
|
|
|
|
#define DEFINE_RUNTIME_ENTRY(name, argument_count) \
|
|
DEFINE_RUNTIME_ENTRY_IMPL(name, argument_count, /*can_lazy_deopt=*/true)
|
|
|
|
#define DEFINE_RUNTIME_ENTRY_NO_LAZY_DEOPT(name, argument_count) \
|
|
DEFINE_RUNTIME_ENTRY_IMPL(name, argument_count, /*can_lazy_deopt=*/false)
|
|
|
|
#define DECLARE_RUNTIME_ENTRY(name) \
|
|
extern const RuntimeEntry k##name##RuntimeEntry; \
|
|
extern void DRT_##name(NativeArguments arguments);
|
|
|
|
#define DEFINE_LEAF_RUNTIME_ENTRY(type, name, argument_count, ...) \
|
|
extern "C" type DLRT_##name(__VA_ARGS__); \
|
|
extern const RuntimeEntry k##name##RuntimeEntry( \
|
|
"DLRT_" #name, reinterpret_cast<RuntimeFunction>(&DLRT_##name), \
|
|
argument_count, true, false, /*can_lazy_deopt=*/false); \
|
|
type DLRT_##name(__VA_ARGS__) { \
|
|
CHECK_STACK_ALIGNMENT; \
|
|
NoSafepointScope no_safepoint_scope;
|
|
|
|
#define END_LEAF_RUNTIME_ENTRY }
|
|
|
|
// TODO(rmacnak): Fix alignment issue on simarm and use
|
|
// DEFINE_LEAF_RUNTIME_ENTRY instead.
|
|
#define DEFINE_RAW_LEAF_RUNTIME_ENTRY(name, argument_count, is_float, func) \
|
|
extern const RuntimeEntry k##name##RuntimeEntry( \
|
|
"DFLRT_" #name, func, argument_count, true, is_float, \
|
|
/*can_lazy_deopt=*/false)
|
|
|
|
#define DECLARE_LEAF_RUNTIME_ENTRY(type, name, ...) \
|
|
extern const RuntimeEntry k##name##RuntimeEntry; \
|
|
extern "C" type DLRT_##name(__VA_ARGS__);
|
|
|
|
// Declare all runtime functions here.
|
|
RUNTIME_ENTRY_LIST(DECLARE_RUNTIME_ENTRY)
|
|
LEAF_RUNTIME_ENTRY_LIST(DECLARE_LEAF_RUNTIME_ENTRY)
|
|
|
|
// Expected to be called inside a safepoint.
|
|
extern "C" Thread* DLRT_GetThreadForNativeCallback(uword callback_id);
|
|
extern "C" Thread* DLRT_GetThreadForNativeCallbackTrampoline(uword callback_id);
|
|
|
|
// For creating scoped handles in FFI trampolines.
|
|
extern "C" ApiLocalScope* DLRT_EnterHandleScope(Thread* thread);
|
|
extern "C" void DLRT_ExitHandleScope(Thread* thread);
|
|
extern "C" LocalHandle* DLRT_AllocateHandle(ApiLocalScope* scope);
|
|
|
|
const char* DeoptReasonToCString(ICData::DeoptReasonId deopt_reason);
|
|
|
|
void OnEveryRuntimeEntryCall(Thread* thread,
|
|
const char* runtime_call_name,
|
|
bool can_lazy_deopt);
|
|
|
|
void DeoptimizeAt(Thread* mutator_thread,
|
|
const Code& optimized_code,
|
|
StackFrame* frame);
|
|
void DeoptimizeFunctionsOnStack();
|
|
|
|
double DartModulo(double a, double b);
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_RUNTIME_ENTRY_H_
|