Remove stack_frame_<arch>.cc files.

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/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1464 matching lines @@
 // copied frame buffer.
 static void CopyFrame(const Code& optimized_code, const StackFrame& frame) {
   const Function& function = Function::Handle(optimized_code.function());
   // Do not copy incoming arguments if there are optional arguments (they
   // are copied into local space at method entry).
   const intptr_t num_args =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   // FP, PC-marker and return-address will be copied as well.
   const intptr_t frame_copy_size =
       // Deoptimized function's return address: caller_frame->pc().
-      - kPcSlotIndexFromSp
+      - kSavedPcSlotFromSp
       + ((frame.fp() - frame.sp()) / kWordSize)
-      + kLastParamSlotIndex
+      + 1  // For fp.
+      + kParamEndSlotFromFp
       + num_args;
   intptr_t* frame_copy = new intptr_t[frame_copy_size];
   ASSERT(frame_copy != NULL);
   // Include the return address of optimized code.
   intptr_t* start = reinterpret_cast<intptr_t*>(
-      frame.sp() + (kPcSlotIndexFromSp * kWordSize));
+      frame.sp() + (kSavedPcSlotFromSp * kWordSize));
   for (intptr_t i = 0; i < frame_copy_size; i++) {
     frame_copy[i] = *(start + i);
   }
   Isolate::Current()->SetDeoptFrameCopy(frame_copy, frame_copy_size);
 }
 
 
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimized frame.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
@@ skipping 34 matching lines @@
         function.deoptimization_counter());
   }
 
   // Compute the stack size of the unoptimized frame.  For functions with
   // optional arguments the deoptimization info does not describe the
   // incoming arguments.
   const Function& function = Function::Handle(optimized_code.function());
   const intptr_t num_args =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   intptr_t unoptimized_stack_size =
-      + deopt_info.TranslationLength() - num_args
-      - kLastParamSlotIndex;  // Subtract caller FP and PC (possibly pc marker).
+      + deopt_info.TranslationLength()
+      - num_args
+      - kParamEndSlotFromFp
+      - 1;  // For fp.
   return unoptimized_stack_size * kWordSize;
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 static intptr_t DeoptimizeWithDeoptInfo(const Code& code,
                                         const DeoptInfo& deopt_info,
                                         const StackFrame& caller_frame,
                                         intptr_t deopt_reason) {
   const intptr_t len = deopt_info.TranslationLength();
   GrowableArray<DeoptInstr*> deopt_instructions(len);
   const Array& deopt_table = Array::Handle(code.deopt_info_array());
   ASSERT(!deopt_table.IsNull());
   deopt_info.ToInstructions(deopt_table, &deopt_instructions);
 
   intptr_t* start = reinterpret_cast<intptr_t*>(
-      caller_frame.sp() + (kPcSlotIndexFromSp * kWordSize));
+      caller_frame.sp() + (kSavedPcSlotFromSp * kWordSize));
   const Function& function = Function::Handle(code.function());
   const intptr_t num_args =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   const intptr_t to_frame_size =
-      - kPcSlotIndexFromSp  // Deoptimized function's return address.
+      - kSavedPcSlotFromSp  // Deoptimized function's return address.
       + (caller_frame.fp() - caller_frame.sp()) / kWordSize
-      + kLastParamSlotIndex
+      + 1  // For fp.
+      + kParamEndSlotFromFp
       + num_args;
   DeoptimizationContext deopt_context(start,
                                       to_frame_size,
                                       Array::Handle(code.object_table()),
                                       num_args,
                                       static_cast<DeoptReasonId>(deopt_reason));
   for (intptr_t to_index = len - 1; to_index >= 0; to_index--) {
     deopt_instructions[to_index]->Execute(&deopt_context, to_index);
   }
   if (FLAG_trace_deoptimization_verbose) {
@@ skipping 120 matching lines @@
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   ASSERT(arguments.ArgCount() == kUpdateFieldCidRuntimeEntry.argument_count());
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
 
   field.UpdateCid(Class::Handle(value.clazz()).id());
 }
 
 }  // namespace dart