dart::PatchableCallHandler Class Reference

Public Member Functions
	PatchableCallHandler (Thread *thread, const GrowableArray< const Instance * > &caller_arguments, MissHandler miss_handler, NativeArguments arguments, StackFrame *caller_frame, const Code &caller_code, const Function &caller_function)
void	ResolveSwitchAndReturn (const Object &data)

Detailed Description

Definition at line 1948 of file runtime_entry.cc.

Constructor & Destructor Documentation

PatchableCallHandler()

dart::PatchableCallHandler::PatchableCallHandler ( Thread *  thread, const GrowableArray< const Instance * > &  caller_arguments, MissHandler  miss_handler, NativeArguments  arguments, StackFrame *  caller_frame, const Code &  caller_code, const Function &  caller_function  )

inline

Definition at line 1950 of file runtime_entry.cc.

      : isolate_(thread->isolate()),
        thread_(thread),
        zone_(thread->zone()),
        caller_arguments_(caller_arguments),
        miss_handler_(miss_handler),
        arguments_(arguments),
        caller_frame_(caller_frame),
        caller_code_(caller_code),
        caller_function_(caller_function),
        name_(String::Handle()),
        args_descriptor_(Array::Handle()) {
    // We only have two arg IC calls in JIT mode.
    ASSERT(caller_arguments_.length() == 1 || !FLAG_precompiled_mode);
  }

Member Function Documentation

ResolveSwitchAndReturn()

void dart::PatchableCallHandler::ResolveSwitchAndReturn

(

const Object &

data

)

Definition at line 2551 of file runtime_entry.cc.

                                                                        {
  // Find out actual target (which can be time consuming) without holding any
  // locks.
  const auto& target_function =
      Function::Handle(zone_, ResolveTargetFunction(old_data));
 
  auto& data = Object::Handle(zone_);
 
  // We ensure any transition in a patchable calls are done in an atomic
  // manner, we ensure we always transition forward (e.g. Monomorphic ->
  // Polymorphic).
  //
  // Mutators are only stopped if we actually need to patch a patchable call.
  // We may not do that if we e.g. just add one more check to an ICData.
  SafepointMutexLocker ml(thread_->isolate_group()->patchable_call_mutex());
 
#if defined(DART_PRECOMPILED_RUNTIME)
  data =
      CodePatcher::GetSwitchableCallDataAt(caller_frame_->pc(), caller_code_);
  uword target_entry = 0;
  DEBUG_ONLY(target_entry = CodePatcher::GetSwitchableCallTargetEntryAt(
                 caller_frame_->pc(), caller_code_));
  HandleMissAOT(data, target_entry, target_function);
#else
  auto& code = Code::Handle(zone_);
  if (should_consider_patching()) {
    code ^= CodePatcher::GetInstanceCallAt(caller_frame_->pc(), caller_code_,
                                           &data);
  } else {
    ASSERT(old_data.IsICData() || old_data.IsMegamorphicCache());
    data = old_data.ptr();
  }
  HandleMissJIT(data, code, target_function);
#endif
}

---

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

• third_party/dart-lang/sdk/runtime/vm/runtime_entry.cc