Make deoptimization architecture dependent (it depends on the frame layout).

runtime/vm/deopt_instructions.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/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 18 matching lines @@
       from_frame_size_(0),
       registers_copy_(NULL),
       fpu_registers_copy_(NULL),
       num_args_(num_args),
       deopt_reason_(deopt_reason),
       isolate_(Isolate::Current()) {
   from_frame_ = isolate_->deopt_frame_copy();
   from_frame_size_ = isolate_->deopt_frame_copy_size();
   registers_copy_ = isolate_->deopt_cpu_registers_copy();
   fpu_registers_copy_ = isolate_->deopt_fpu_registers_copy();
+  // The deoptimized frame is filled starting just below the sp of its caller
+  // down to kDartFrameFixedSize words below its own sp.
+  // The chain of frame pointers is recreated from the fp of the caller.
   caller_fp_ = GetFromFp();
 }
 
 
 intptr_t DeoptimizationContext::GetFromFp() const {
-  return from_frame_[from_frame_size_ - num_args_ - 1 - kParamEndSlotFromFp];
+  return from_frame_[from_frame_size_ - 1 - num_args_ - kParamEndSlotFromFp];
+}
+
+
+intptr_t DeoptimizationContext::GetFromPp() const {
+  return from_frame_[from_frame_size_ - 1 - num_args_ - kParamEndSlotFromFp +
+      StackFrame::SavedCallerPpSlotFromFp()];
 }
 
 
 intptr_t DeoptimizationContext::GetFromPc() const {
   return from_frame_[from_frame_size_ - num_args_ + kSavedPcSlotFromSp];
 }
 
+
 intptr_t DeoptimizationContext::GetCallerFp() const {
   return caller_fp_;
 }
 
+
 void DeoptimizationContext::SetCallerFp(intptr_t caller_fp) {
   caller_fp_ = caller_fp;
 }
 
+
 // Deoptimization instruction moving value from optimized frame at
 // 'from_index' to specified slots in the unoptimized frame.
 // 'from_index' represents the slot index of the frame (0 being first argument)
 // and accounts for saved return address, frame pointer and pc marker.
 class DeoptStackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptStackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
@@ skipping 399 matching lines @@
   virtual DeoptInstr::Kind kind() const { return kPcMarker; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "pcmark oti:%"Pd"", object_table_index_);
   }
 
   void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
+    if (function.IsNull()) {
+      // Callee's PC marker is not used (pc of Deoptimize stub). Set to 0.
+      *to_addr = 0;
+      return;
+    }
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
     const intptr_t pc_marker =
         code.EntryPoint() + Assembler::kEntryPointToPcMarkerOffset;
     *to_addr = pc_marker;
     // Increment the deoptimization counter. This effectively increments each
     // function occurring in the optimized frame.
     function.set_deoptimization_counter(function.deoptimization_counter() + 1);
     if (FLAG_trace_deoptimization) {
       OS::PrintErr("Deoptimizing %s (count %d)\n",
           function.ToFullyQualifiedCString(),
           function.deoptimization_counter());
     }
     // Clear invocation counter so that hopefully the function gets reoptimized
     // only after more feedback has been collected.
     function.set_usage_counter(0);
     if (function.HasOptimizedCode()) function.SwitchToUnoptimizedCode();
   }
 
  private:
   intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptPcMarkerInstr);
 };
 
 
+// Deoptimization instruction creating a pool pointer for the code of
+// function at 'object_table_index'.
+class DeoptPpInstr : public DeoptInstr {
+ public:
+  explicit DeoptPpInstr(intptr_t object_table_index)
+      : object_table_index_(object_table_index) {
+    ASSERT(object_table_index >= 0);
+  }
+
+  virtual intptr_t from_index() const { return object_table_index_; }
+  virtual DeoptInstr::Kind kind() const { return kPp; }
+
+  virtual const char* ToCString() const {
+    return Isolate::Current()->current_zone()->PrintToString(
+        "pp oti:%"Pd"", object_table_index_);
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    Function& function = Function::Handle(deopt_context->isolate());
+    function ^= deopt_context->ObjectAt(object_table_index_);
+    const Code& code =
+        Code::Handle(deopt_context->isolate(), function.unoptimized_code());
+    ASSERT(!code.IsNull());
+    const intptr_t pp = reinterpret_cast<intptr_t>(code.ObjectPool());
+    *to_addr = pp;
+  }
+
+ private:
+  intptr_t object_table_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptPpInstr);
+};
+
+
 // Deoptimization instruction copying the caller saved FP from optimized frame.
 class DeoptCallerFpInstr : public DeoptInstr {
  public:
   DeoptCallerFpInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerFp; }
 
   virtual const char* ToCString() const {
     return "callerfp";
   }
 
   void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     *to_addr = deopt_context->GetCallerFp();
-    deopt_context->SetCallerFp(reinterpret_cast<intptr_t>(to_addr));
+    deopt_context->SetCallerFp(reinterpret_cast<intptr_t>(
+        to_addr - (kSavedCallerFpSlotFromFp * kWordSize)));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerFpInstr);
 };
 
 
+// Deoptimization instruction copying the caller saved PP from optimized frame.
+class DeoptCallerPpInstr : public DeoptInstr {
+ public:
+  DeoptCallerPpInstr() {}
+
+  virtual intptr_t from_index() const { return 0; }
+  virtual DeoptInstr::Kind kind() const { return kCallerPp; }
+
+  virtual const char* ToCString() const {
+    return "callerpp";
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    *to_addr = deopt_context->GetFromPp();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeoptCallerPpInstr);
+};
+
+
 // Deoptimization instruction copying the caller return address from optimized
 // frame.
 class DeoptCallerPcInstr : public DeoptInstr {
  public:
   DeoptCallerPcInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerPc; }
 
   virtual const char* ToCString() const {
@@ skipping 157 matching lines @@
     case kRetAddress: return new DeoptRetAddressInstr(from_index);
     case kConstant: return new DeoptConstantInstr(from_index);
     case kRegister: return new DeoptRegisterInstr(from_index);
     case kFpuRegister: return new DeoptFpuRegisterInstr(from_index);
     case kInt64FpuRegister: return new DeoptInt64FpuRegisterInstr(from_index);
     case kFloat32x4FpuRegister:
         return new DeoptFloat32x4FpuRegisterInstr(from_index);
     case kUint32x4FpuRegister:
         return new DeoptUint32x4FpuRegisterInstr(from_index);
     case kPcMarker: return new DeoptPcMarkerInstr(from_index);
+    case kPp: return new DeoptPpInstr(from_index);
     case kCallerFp: return new DeoptCallerFpInstr();
+    case kCallerPp: return new DeoptCallerPpInstr();
     case kCallerPc: return new DeoptCallerPcInstr();
     case kSuffix: return new DeoptSuffixInstr(from_index);
     case kMaterializedObjectRef:
         return new DeoptMaterializedObjectRefInstr(from_index);
     case kMaterializeObject: return new DeoptMaterializeObjectInstr(from_index);
   }
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 72 matching lines @@
       (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
 #endif
   const intptr_t object_table_index = FindOrAddObjectInTable(function);
   ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
 void DeoptInfoBuilder::AddPcMarker(const Function& function,
                                    intptr_t to_index) {
-  // Function object was already added by AddReturnAddress, find it.
-  intptr_t from_index = FindOrAddObjectInTable(function);
+  intptr_t object_table_index = FindOrAddObjectInTable(function);
   ASSERT(to_index == FrameSize());
-  instructions_.Add(new DeoptPcMarkerInstr(from_index));
+  instructions_.Add(new DeoptPcMarkerInstr(object_table_index));
+}
+
+
+void DeoptInfoBuilder::AddPp(const Function& function, intptr_t to_index) {
+  intptr_t object_table_index = FindOrAddObjectInTable(function);
+  ASSERT(to_index == FrameSize());
+  instructions_.Add(new DeoptPpInstr(object_table_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& from_loc,
                                const intptr_t to_index) {
   DeoptInstr* deopt_instr = NULL;
   if (from_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(from_loc.constant());
     deopt_instr = new DeoptConstantInstr(object_table_index);
@@ skipping 45 matching lines @@
   instructions_.Add(deopt_instr);
 }
 
 
 void DeoptInfoBuilder::AddCallerFp(intptr_t to_index) {
   ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptCallerFpInstr());
 }
 
 
+void DeoptInfoBuilder::AddCallerPp(intptr_t to_index) {
+  ASSERT(to_index == FrameSize());
+  instructions_.Add(new DeoptCallerPpInstr());
+}
+
+
 void DeoptInfoBuilder::AddCallerPc(intptr_t to_index) {
   ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptCallerPcInstr());
 }
 
 
 void DeoptInfoBuilder::AddConstant(const Object& obj, intptr_t to_index) {
   ASSERT(to_index == FrameSize());
   intptr_t object_table_index = FindOrAddObjectInTable(obj);
   instructions_.Add(new DeoptConstantInstr(object_table_index));
@@ skipping 14 matching lines @@
   for (intptr_t i = 0; i < mat->InputCount(); i++) {
     if (!mat->InputAt(i)->BindsToConstantNull()) {
       non_null_fields++;
     }
   }
 
   instructions_.Add(new DeoptMaterializeObjectInstr(non_null_fields));
 }
 
 
-intptr_t DeoptInfoBuilder::EmitMaterializationArguments() {
-  intptr_t slot_idx = 1;  // Return address is emitted at 0.
+intptr_t DeoptInfoBuilder::EmitMaterializationArguments(intptr_t to_index) {
+  ASSERT(to_index == kDartFrameFixedSize);
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     MaterializeObjectInstr* mat = materializations_[i];
-    AddConstant(mat->cls(), slot_idx++);  // Class of the instance to allocate.
+    AddConstant(mat->cls(), to_index++);  // Class of the instance to allocate.
     for (intptr_t i = 0; i < mat->InputCount(); i++) {
       if (!mat->InputAt(i)->BindsToConstantNull()) {
         // Emit field-value pair.
-        AddConstant(mat->FieldAt(i), slot_idx++);
-        AddCopy(mat->InputAt(i), mat->LocationAt(i), slot_idx++);
+        AddConstant(mat->FieldAt(i), to_index++);
+        AddCopy(mat->InputAt(i), mat->LocationAt(i), to_index++);
       }
     }
   }
-  return slot_idx;
+  return to_index;
 }
 
 
 intptr_t DeoptInfoBuilder::FindMaterialization(
     MaterializeObjectInstr* mat) const {
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     if (materializations_[i] == mat) {
       return i;
     }
   }
@@ skipping 82 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart