dart::NativeEntry Class Reference

#include <native_entry.h>

Inheritance diagram for dart::NativeEntry:

Static Public Member Functions
static NativeFunction	ResolveNative (const Library &library, const String &function_name, int number_of_arguments, bool *auto_setup_scope)
static const uint8_t *	ResolveSymbolInLibrary (const Library &library, uword pc)
static const uint8_t *	ResolveSymbol (uword pc)
static uword	BootstrapNativeCallWrapperEntry ()
static void	BootstrapNativeCallWrapper (Dart_NativeArguments args, Dart_NativeFunction func)
static uword	NoScopeNativeCallWrapperEntry ()
static void	NoScopeNativeCallWrapper (Dart_NativeArguments args, Dart_NativeFunction func)
static uword	AutoScopeNativeCallWrapperEntry ()
static void	AutoScopeNativeCallWrapper (Dart_NativeArguments args, Dart_NativeFunction func)
static uword	LinkNativeCallEntry ()
static void	LinkNativeCall (Dart_NativeArguments args)

Static Public Attributes
static constexpr intptr_t	kNumArguments = 1
static constexpr intptr_t	kNumCallWrapperArguments = 2

Detailed Description

Definition at line 96 of file native_entry.h.

Member Function Documentation

AutoScopeNativeCallWrapper()

void dart::NativeEntry::AutoScopeNativeCallWrapper ( Dart_NativeArguments  args, Dart_NativeFunction  func  )

static

Definition at line 197 of file native_entry.cc.

                                                                       {
  CHECK_STACK_ALIGNMENT;
  AutoScopeNativeCallWrapperNoStackCheck(args, func);
}

AutoScopeNativeCallWrapperEntry()

uword dart::NativeEntry::AutoScopeNativeCallWrapperEntry ( )

static

Definition at line 186 of file native_entry.cc.

                                                   {
  uword entry =
      reinterpret_cast<uword>(NativeEntry::AutoScopeNativeCallWrapper);
#if defined(USING_SIMULATOR)
  entry = Simulator::RedirectExternalReference(
      entry, Simulator::kNativeCallWrapper,
      NativeEntry::kNumCallWrapperArguments);
#endif
  return entry;
}

BootstrapNativeCallWrapper()

void dart::NativeEntry::BootstrapNativeCallWrapper ( Dart_NativeArguments  args, Dart_NativeFunction  func  )

static

Definition at line 125 of file native_entry.cc.

                                                                       {
  CHECK_STACK_ALIGNMENT;
  if (func == LinkNativeCall) {
    func(args);
    return;
  }
 
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  // Tell MemorySanitizer 'arguments' is initialized by generated code.
  MSAN_UNPOISON(arguments, sizeof(*arguments));
  {
    Thread* thread = arguments->thread();
    ASSERT(thread == Thread::Current());
    TransitionGeneratedToVM transition(thread);
    StackZone zone(thread);
    // Be careful holding return_value_unsafe without a handle here.
    // A return of Object::sentinel means the return value has already
    // been set.
    ObjectPtr return_value_unsafe = reinterpret_cast<BootstrapNativeFunction>(
        reinterpret_cast<void*>(func))(thread, zone.GetZone(), arguments);
    if (return_value_unsafe != Object::sentinel().ptr()) {
      ASSERT(return_value_unsafe->IsDartInstance());
      arguments->SetReturnUnsafe(return_value_unsafe);
    }
    DEOPTIMIZE_ALOT;
  }
}

BootstrapNativeCallWrapperEntry()

uword dart::NativeEntry::BootstrapNativeCallWrapperEntry ( )

static

Definition at line 114 of file native_entry.cc.

                                                   {
  uword entry =
      reinterpret_cast<uword>(NativeEntry::BootstrapNativeCallWrapper);
#if defined(USING_SIMULATOR)
  entry = Simulator::RedirectExternalReference(
      entry, Simulator::kNativeCallWrapper,
      NativeEntry::kNumCallWrapperArguments);
#endif
  return entry;
}

LinkNativeCall()

void dart::NativeEntry::LinkNativeCall ( Dart_NativeArguments  args )

static

Definition at line 256 of file native_entry.cc.

                                                          {
  CHECK_STACK_ALIGNMENT;
  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
  // Tell MemorySanitizer 'arguments' is initialized by generated code.
  MSAN_UNPOISON(arguments, sizeof(*arguments));
  TRACE_NATIVE_CALL("%s", "LinkNative");
 
  NativeFunction target_function = nullptr;
  bool is_bootstrap_native = false;
  bool is_auto_scope = true;
 
  {
    TransitionGeneratedToVM transition(arguments->thread());
    StackZone stack_zone(arguments->thread());
    Zone* zone = stack_zone.GetZone();
 
    DartFrameIterator iterator(arguments->thread(),
                               StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* caller_frame = iterator.NextFrame();
 
    Code& code = Code::Handle(zone, caller_frame->LookupDartCode());
    Function& func = Function::Handle(zone, code.function());
 
    if (FLAG_trace_natives) {
      THR_Print("Resolving native target for %s\n", func.ToCString());
    }
 
    target_function =
        ResolveNativeFunction(arguments->thread()->zone(), func,
                              &is_bootstrap_native, &is_auto_scope);
    ASSERT(target_function != nullptr);
 
#if defined(DEBUG)
    NativeFunction current_function = nullptr;
    const Code& current_trampoline =
        Code::Handle(zone, CodePatcher::GetNativeCallAt(
                               caller_frame->pc(), code, &current_function));
    // Some other isolate(with code being shared in AOT) might have updated
    // target function/trampoline already.
    ASSERT(current_function ==
               reinterpret_cast<NativeFunction>(LinkNativeCall) ||
           current_function == target_function);
    ASSERT(current_trampoline.ptr() == StubCode::CallBootstrapNative().ptr() ||
           current_function == target_function);
#endif
 
    NativeFunction patch_target_function = target_function;
    Code& trampoline = Code::Handle(zone);
    if (is_bootstrap_native) {
      trampoline = StubCode::CallBootstrapNative().ptr();
    } else if (is_auto_scope) {
      trampoline = StubCode::CallAutoScopeNative().ptr();
    } else {
      trampoline = StubCode::CallNoScopeNative().ptr();
    }
    CodePatcher::PatchNativeCallAt(caller_frame->pc(), code,
                                   patch_target_function, trampoline);
 
    if (FLAG_trace_natives) {
      THR_Print("    -> %p (%s)\n", target_function,
                is_bootstrap_native ? "bootstrap" : "non-bootstrap");
    }
  }
 
  // Tail-call resolved target.
  if (is_bootstrap_native) {
    NativeEntry::BootstrapNativeCallWrapper(
        args, reinterpret_cast<Dart_NativeFunction>(target_function));
  } else if (is_auto_scope) {
    // Because this call is within a compilation unit, Clang doesn't respect
    // the ABI alignment here.
    NativeEntry::AutoScopeNativeCallWrapperNoStackCheck(
        args, reinterpret_cast<Dart_NativeFunction>(target_function));
  } else {
    // Because this call is within a compilation unit, Clang doesn't respect
    // the ABI alignment here.
    NativeEntry::NoScopeNativeCallWrapperNoStackCheck(
        args, reinterpret_cast<Dart_NativeFunction>(target_function));
  }
}

LinkNativeCallEntry()

uword dart::NativeEntry::LinkNativeCallEntry ( )

static

Definition at line 251 of file native_entry.cc.

                                       {
  uword entry = reinterpret_cast<uword>(NativeEntry::LinkNativeCall);
  return entry;
}

NoScopeNativeCallWrapper()

void dart::NativeEntry::NoScopeNativeCallWrapper ( Dart_NativeArguments  args, Dart_NativeFunction  func  )

static

Definition at line 164 of file native_entry.cc.

                                                                     {
  CHECK_STACK_ALIGNMENT;
  NoScopeNativeCallWrapperNoStackCheck(args, func);
}

NoScopeNativeCallWrapperEntry()

uword dart::NativeEntry::NoScopeNativeCallWrapperEntry ( )

static

Definition at line 154 of file native_entry.cc.

                                                 {
  uword entry = reinterpret_cast<uword>(NativeEntry::NoScopeNativeCallWrapper);
#if defined(USING_SIMULATOR)
  entry = Simulator::RedirectExternalReference(
      entry, Simulator::kNativeCallWrapper,
      NativeEntry::kNumCallWrapperArguments);
#endif
  return entry;
}

ResolveNative()

NativeFunction dart::NativeEntry::ResolveNative ( const Library &  library, const String &  function_name, int  number_of_arguments, bool *  auto_setup_scope  )

static

Definition at line 37 of file native_entry.cc.

                                                                  {
  // Now resolve the native function to the corresponding native entrypoint.
  if (library.native_entry_resolver() == nullptr) {
    // Native methods are not allowed in the library to which this
    // class belongs in.
    return nullptr;
  }
  Dart_NativeFunction native_function = nullptr;
  {
    Thread* T = Thread::Current();
    Api::Scope api_scope(T);
    Dart_Handle api_function_name = Api::NewHandle(T, function_name.ptr());
    {
      Dart_NativeEntryResolver resolver = library.native_entry_resolver();
      TransitionVMToNative transition(T);
      native_function =
          resolver(api_function_name, number_of_arguments, auto_setup_scope);
    }
  }
  return reinterpret_cast<NativeFunction>(native_function);
}

ResolveSymbol()

const uint8_t * dart::NativeEntry::ResolveSymbol ( uword  pc )

static

Definition at line 73 of file native_entry.cc.

                                                  {
  Thread* thread = Thread::Current();
  REUSABLE_GROWABLE_OBJECT_ARRAY_HANDLESCOPE(thread);
  GrowableObjectArray& libs = reused_growable_object_array_handle.Handle();
  libs = thread->isolate_group()->object_store()->libraries();
  ASSERT(!libs.IsNull());
  intptr_t num_libs = libs.Length();
  for (intptr_t i = 0; i < num_libs; i++) {
    REUSABLE_LIBRARY_HANDLESCOPE(thread);
    Library& lib = reused_library_handle.Handle();
    lib ^= libs.At(i);
    ASSERT(!lib.IsNull());
    const uint8_t* r = ResolveSymbolInLibrary(lib, pc);
    if (r != nullptr) {
      return r;
    }
  }
  return nullptr;
}

ResolveSymbolInLibrary()

const uint8_t * dart::NativeEntry::ResolveSymbolInLibrary ( const Library &  library, uword  pc  )

static

Definition at line 62 of file native_entry.cc.

                                                             {
  Dart_NativeEntrySymbol symbol_resolver =
      library.native_entry_symbol_resolver();
  if (symbol_resolver == nullptr) {
    // Cannot reverse lookup native entries.
    return nullptr;
  }
  return symbol_resolver(reinterpret_cast<Dart_NativeFunction>(pc));
}

Member Data Documentation

kNumArguments

constexpr intptr_t dart::NativeEntry::kNumArguments = 1

staticconstexpr

Definition at line 98 of file native_entry.h.

kNumCallWrapperArguments

constexpr intptr_t dart::NativeEntry::kNumCallWrapperArguments = 2

staticconstexpr

Definition at line 99 of file native_entry.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/native_entry.h
• third_party/dart-lang/sdk/runtime/vm/native_entry.cc