Revert "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.raw() !=
+  ASSERT(target_code.EntryPoint() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
-  CodePatcher::PatchStaticCallAt(caller_frame->pc(),
-                                 caller_code,
-                                 target_code);
-  caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_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());
+    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);
-  const Code& orig_stub = Code::Handle(
-      isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
+  uword orig_stub =
+      isolate->debugger()->GetPatchedStubAddress(caller_frame->pc());
   isolate->debugger()->SignalBpReached();
-  arguments.SetReturn(orig_stub);
+  ASSERT((orig_stub & kSmiTagMask) == kSmiTag);
+  arguments.SetReturn(Smi::Handle(reinterpret_cast<RawSmi*>(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 704 matching lines @@
     // 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);
       frame->set_pc(optimized_entry);
-      frame->set_pc_marker(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 67 matching lines @@
         isolate, Compiler::CompileFunction(thread, target_function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   ASSERT(target_function.HasCode());
   ASSERT(target_function.raw() == target_code.function());
 
   const Code& current_target_code = Code::Handle(
       isolate, target_function.CurrentCode());
-  CodePatcher::PatchStaticCallAt(frame->pc(),
-                                 caller_code,
-                                 current_target_code);
-  caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
+  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());
+    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());
   }
   arguments.SetReturn(current_target_code);
 }
 
 
 // The caller tried to allocate an instance via an invalidated allocation
 // stub.
 DEFINE_RUNTIME_ENTRY(FixAllocationStubTarget, 0) {
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     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 Code& stub = Code::Handle(
-      CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code));
+  const uword target =
+      CodePatcher::GetStaticCallTargetAt(frame->pc(), caller_code);
+  const Code& stub = Code::Handle(isolate, Code::LookupCode(target));
   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));
   }
-  CodePatcher::PatchStaticCallAt(frame->pc(),
-                                 caller_code,
-                                 alloc_stub);
-  caller_code.SetStubCallTargetCodeAt(frame->pc(), 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());
+    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 33 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::InsertDeoptimizationCallAt(pc, lazy_deopt_jump);
+    CodePatcher::InsertCallAt(pc, lazy_deopt_jump);
   }
   if (FLAG_trace_patching) {
     const String& name = String::Handle(function.name());
-    OS::PrintErr("InsertDeoptimizationCallAt: %" Px " to %" Px " for %s\n", pc,
+    OS::PrintErr("InsertCallAt: %" 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,
-                          2,
-                          uword saved_registers_address,
-                          uword is_lazy_deopt) {
+                          1, uword saved_registers_address) {
   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,
-                       is_lazy_deopt != 0);
+                       fpu_registers, cpu_registers);
   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