ARM: Implement OSR infrastructure.

src/deoptimizer.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 645 matching lines @@
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::FRAME:
     case Translation::DUPLICATE:
       UNREACHABLE();  // Malformed input.
        return false;
 
      case Translation::REGISTER: {
        int output_reg = iterator->Next();
        if (FLAG_trace_osr) {
-         PrintF("    %s <- 0x%08" V8PRIxPTR " ; [esp + %d]\n",
+         PrintF("    %s <- 0x%08" V8PRIxPTR " ; [sp + %d]\n",
                 converter.NameOfCPURegister(output_reg),
                 input_value,
                 *input_offset);
        }
        output->SetRegister(output_reg, input_value);
        break;
      }
 
     case Translation::INT32_REGISTER: {
       // Abort OSR if we don't have a number.
       if (!input_object->IsNumber()) return false;
 
       int output_reg = iterator->Next();
       int int32_value = input_object->IsSmi()
           ? Smi::cast(input_object)->value()
           : FastD2I(input_object->Number());
       // Abort the translation if the conversion lost information.
       if (!input_object->IsSmi() &&
           FastI2D(int32_value) != input_object->Number()) {
         if (FLAG_trace_osr) {
           PrintF("**** %g could not be converted to int32 ****\n",
                  input_object->Number());
         }
         return false;
       }
       if (FLAG_trace_osr) {
-        PrintF("    %s <- %d (int32) ; [esp + %d]\n",
+        PrintF("    %s <- %d (int32) ; [sp + %d]\n",
                converter.NameOfCPURegister(output_reg),
                int32_value,
                *input_offset);
       }
       output->SetRegister(output_reg, int32_value);
       break;
     }
 
     case Translation::DOUBLE_REGISTER: {
       // Abort OSR if we don't have a number.
       if (!input_object->IsNumber()) return false;
 
       int output_reg = iterator->Next();
       double double_value = input_object->Number();
       if (FLAG_trace_osr) {
-        PrintF("    %s <- %g (double) ; [esp + %d]\n",
+        PrintF("    %s <- %g (double) ; [sp + %d]\n",
                DoubleRegister::AllocationIndexToString(output_reg),
                double_value,
                *input_offset);
       }
       output->SetDoubleRegister(output_reg, double_value);
       break;
     }
 
     case Translation::STACK_SLOT: {
       int output_index = iterator->Next();
       unsigned output_offset =
           output->GetOffsetFromSlotIndex(this, output_index);
       if (FLAG_trace_osr) {
-        PrintF("    [esp + %d] <- 0x%08" V8PRIxPTR " ; [esp + %d]\n",
+        PrintF("    [sp + %d] <- 0x%08" V8PRIxPTR " ; [sp + %d]\n",
                output_offset,
                input_value,
                *input_offset);
       }
       output->SetFrameSlot(output_offset, input_value);
       break;
     }
 
     case Translation::INT32_STACK_SLOT: {
       // Abort OSR if we don't have a number.
       if (!input_object->IsNumber()) return false;
 
       int output_index = iterator->Next();
       unsigned output_offset =
           output->GetOffsetFromSlotIndex(this, output_index);
       int int32_value = input_object->IsSmi()
           ? Smi::cast(input_object)->value()
           : DoubleToInt32(input_object->Number());
       // Abort the translation if the conversion lost information.
       if (!input_object->IsSmi() &&
           FastI2D(int32_value) != input_object->Number()) {
         if (FLAG_trace_osr) {
           PrintF("**** %g could not be converted to int32 ****\n",
                  input_object->Number());
         }
         return false;
       }
       if (FLAG_trace_osr) {
-        PrintF("    [esp + %d] <- %d (int32) ; [esp + %d]\n",
+        PrintF("    [sp + %d] <- %d (int32) ; [sp + %d]\n",
                output_offset,
                int32_value,
                *input_offset);
       }
       output->SetFrameSlot(output_offset, int32_value);
       break;
     }
 
     case Translation::DOUBLE_STACK_SLOT: {
       static const int kLowerOffset = 0 * kPointerSize;
       static const int kUpperOffset = 1 * kPointerSize;
 
       // Abort OSR if we don't have a number.
       if (!input_object->IsNumber()) return false;
 
       int output_index = iterator->Next();
       unsigned output_offset =
           output->GetOffsetFromSlotIndex(this, output_index);
       double double_value = input_object->Number();
       uint64_t int_value = BitCast<uint64_t, double>(double_value);
       int32_t lower = static_cast<int32_t>(int_value);
       int32_t upper = static_cast<int32_t>(int_value >> kBitsPerInt);
       if (FLAG_trace_osr) {
-        PrintF("    [esp + %d] <- 0x%08x (upper bits of %g) ; [esp + %d]\n",
+        PrintF("    [sp + %d] <- 0x%08x (upper bits of %g) ; [sp + %d]\n",
                output_offset + kUpperOffset,
                upper,
                double_value,
                *input_offset);
-        PrintF("    [esp + %d] <- 0x%08x (lower bits of %g) ; [esp + %d]\n",
+        PrintF("    [sp + %d] <- 0x%08x (lower bits of %g) ; [sp + %d]\n",
                output_offset + kLowerOffset,
                lower,
                double_value,
                *input_offset);
       }
       output->SetFrameSlot(output_offset + kLowerOffset, lower);
       output->SetFrameSlot(output_offset + kUpperOffset, upper);
       break;
     }
 
@@ skipping 384 matching lines @@
                           Deoptimizer::HandleWeakDeoptimizedCode);
 }
 
 
 DeoptimizingCodeListNode::~DeoptimizingCodeListNode() {
   GlobalHandles::Destroy(reinterpret_cast<Object**>(code_.location()));
 }
 
 
 } }  // namespace v8::internal