VM: New calling convention for generated code.

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 656 matching lines @@
   if (!target_function.HasCode()) {
     const Error& error =
         Error::Handle(Compiler::CompileFunction(thread, target_function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   const Code& target_code = Code::Handle(target_function.CurrentCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
-  ASSERT(target_code.EntryPoint() !=
+  ASSERT(target_code.raw() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
   const Instructions& instrs =
       Instructions::Handle(caller_code.instructions());
   {
     WritableInstructionsScope writable(instrs.EntryPoint(), instrs.size());
-    CodePatcher::PatchStaticCallAt(caller_frame->pc(), caller_code,
-                                   target_code.EntryPoint());
+    CodePatcher::PatchStaticCallAt(caller_frame->pc(),
+                                   caller_code,
+                                   target_code);
     caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   }
   if (FLAG_trace_patching) {
     OS::PrintErr("PatchStaticCall: patching caller pc %#" Px ""
         " to '%s' new entry point %#" Px " (%s)\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         target_code.EntryPoint(),
         target_code.is_optimized() ? "optimized" : "unoptimized");
   }
   arguments.SetReturn(target_code);
 }
 
 
 // Result of an invoke may be an unhandled exception, in which case we
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
-  uword orig_stub =
-      isolate->debugger()->GetPatchedStubAddress(caller_frame->pc());
+  const Code& orig_stub = Code::Handle(
+      isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
   isolate->debugger()->SignalBpReached();
-  ASSERT((orig_stub & kSmiTagMask) == kSmiTag);
-  arguments.SetReturn(Smi::Handle(reinterpret_cast<RawSmi*>(orig_stub)));
+  arguments.SetReturn(orig_stub);
 }
 
 
 DEFINE_RUNTIME_ENTRY(SingleStepHandler, 0) {
   isolate->debugger()->DebuggerStepCallback();
 }
 
 
 // An instance call of the form o.f(...) could not be resolved.  Check if
 // there is a getter with the same name.  If so, invoke it.  If the value is
@@ skipping 703 matching lines @@
     const Code& optimized_code = Code::Handle(function.CurrentCode());
     // The current code will not be changed in the case that the compiler
     // bailed out during OSR compilation.
     if (optimized_code.raw() != original_code.raw()) {
       // The OSR code does not work for calling the function, so restore the
       // unoptimized code.  Patch the stack frame to return into the OSR
       // code.
       uword optimized_entry =
           Instructions::Handle(optimized_code.instructions()).EntryPoint();
       function.AttachCode(original_code);
+      // TODO(vegorov) figure out if it is GC safe.

[rmacnak, 2015/09/09 01:37:48]

The change to kFirstObjectSlotFromFp makes it safe, no?

[Florian Schneider, 2015/09/09 13:19:49]

I think so too. We do now visit the code object pointer in the stack frame.
Maybe it is not necessary, since code objects don't move for now,  but it can't
hurt in any case.

       frame->set_pc(optimized_entry);
+      frame->set_pc_marker(reinterpret_cast<uword>(optimized_code.raw()));
     }
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
@@ skipping 71 matching lines @@
   }
   ASSERT(target_function.HasCode());
   ASSERT(target_function.raw() == target_code.function());
 
   const Code& current_target_code = Code::Handle(
       isolate, target_function.CurrentCode());
   const Instructions& instrs = Instructions::Handle(
       isolate, caller_code.instructions());
   {
     WritableInstructionsScope writable(instrs.EntryPoint(), instrs.size());
-    CodePatcher::PatchStaticCallAt(frame->pc(), caller_code,
-                                   current_target_code.EntryPoint());
+    CodePatcher::PatchStaticCallAt(frame->pc(),
+                                   caller_code,
+                                   current_target_code);
     caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
   }
   if (FLAG_trace_patching) {
     OS::PrintErr("FixCallersTarget: caller %#" Px " "
         "target '%s' %#" Px " -> %#" Px "\n",
         frame->pc(),
         target_function.ToFullyQualifiedCString(),
         target_code.EntryPoint(),
         current_target_code.EntryPoint());
   }
@@ skipping 11 matching lines @@
     frame = iterator.NextFrame();
     ASSERT(frame != NULL);
   }
   if (frame->IsEntryFrame()) {
     // There must be a valid Dart frame.
     UNREACHABLE();
   }
   ASSERT(frame->IsDartFrame());
   const Code& caller_code = Code::Handle(isolate, frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
-  const uword target =
-      CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code);
-  const Code& stub = Code::Handle(isolate, Code::LookupCode(target));
+  const Code& stub = Code::Handle(
+      CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code));
   Class& alloc_class = Class::ZoneHandle(zone);
   alloc_class ^= stub.owner();
   Code& alloc_stub = Code::Handle(isolate, alloc_class.allocation_stub());
   if (alloc_stub.IsNull()) {
     alloc_stub = StubCode::GetAllocationStubForClass(alloc_class);
     ASSERT(!CodePatcher::IsEntryPatched(alloc_stub));
   }
   const Instructions& instrs =
       Instructions::Handle(isolate, caller_code.instructions());
   {
     WritableInstructionsScope writable(instrs.EntryPoint(), instrs.size());
     CodePatcher::PatchStaticCallAt(frame->pc(),
                                    caller_code,
-                                   alloc_stub.EntryPoint());
+                                   alloc_stub);
     caller_code.SetStubCallTargetCodeAt(frame->pc(), alloc_stub);
   }
   if (FLAG_trace_patching) {
     OS::PrintErr("FixAllocationStubTarget: caller %#" Px " alloc-class %s "
         " -> %#" Px "\n",
         frame->pc(),
         alloc_class.ToCString(),
         alloc_stub.EntryPoint());
   }
   arguments.SetReturn(alloc_stub);
@@ skipping 35 matching lines @@
     function.SwitchToUnoptimizedCode();
   }
   // Patch call site (lazy deoptimization is quite rare, patching it twice
   // is not a performance issue).
   uword lazy_deopt_jump = optimized_code.GetLazyDeoptPc();
   ASSERT(lazy_deopt_jump != 0);
   const Instructions& instrs =
       Instructions::Handle(zone, optimized_code.instructions());
   {
     WritableInstructionsScope writable(instrs.EntryPoint(), instrs.size());
-    CodePatcher::InsertCallAt(pc, lazy_deopt_jump);
+    CodePatcher::InsertDeoptimizationCallAt(pc, lazy_deopt_jump);
   }
   if (FLAG_trace_patching) {
     const String& name = String::Handle(function.name());
-    OS::PrintErr("InsertCallAt: %" Px " to %" Px " for %s\n", pc,
+    OS::PrintErr("InsertDeoptimizationCallAt: %" Px " to %" Px " for %s\n", pc,
                  lazy_deopt_jump, name.ToCString());
   }
   // Mark code as dead (do not GC its embedded objects).
   optimized_code.set_is_alive(false);
 }
 
 
 // Currently checks only that all optimized frames have kDeoptIndex
 // and unoptimized code has the kDeoptAfter.
 void DeoptimizeFunctionsOnStack() {
@@ skipping 32 matching lines @@
         *reinterpret_cast<intptr_t*>(saved_registers_address);
     saved_registers_address += kWordSize;
   }
   *cpu_registers = cpu_registers_copy;
 }
 
 
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimized frame.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
-                          1, uword saved_registers_address) {
+                          2,
+                          uword saved_registers_address,
+                          uword is_lazy_deopt) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   StackZone zone(thread);
   HANDLESCOPE(thread);
 
   // All registers have been saved below last-fp as if they were locals.
   const uword last_fp = saved_registers_address
                         + (kNumberOfCpuRegisters * kWordSize)
                         + (kNumberOfFpuRegisters * kFpuRegisterSize)
                         - ((kFirstLocalSlotFromFp + 1) * kWordSize);
 
   // Get optimized code and frame that need to be deoptimized.
   DartFrameIterator iterator(last_fp);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
 
   // Copy the saved registers from the stack.
   fpu_register_t* fpu_registers;
   intptr_t* cpu_registers;
   CopySavedRegisters(saved_registers_address, &fpu_registers, &cpu_registers);
 
   // Create the DeoptContext.
   DeoptContext* deopt_context =
-      new DeoptContext(caller_frame, optimized_code,
+      new DeoptContext(caller_frame,
+                       optimized_code,
                        DeoptContext::kDestIsOriginalFrame,
-                       fpu_registers, cpu_registers);
+                       fpu_registers,
+                       cpu_registers,
+                       is_lazy_deopt != 0);
   isolate->set_deopt_context(deopt_context);
 
   // Stack size (FP - SP) in bytes.
   return deopt_context->DestStackAdjustment() * kWordSize;
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 // The stack has been adjusted to fit all values for unoptimized frame.
 // Fill the unoptimized frame.
@@ skipping 120 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart