Merge bleeding_edge revision (5922, 5934] to isolates branch....

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 295 matching lines @@
     base = data->lazy_deoptimization_entry_code_;
   }
   if (base == NULL ||
       addr < base->GetStartAddress() ||
       addr >= base->GetStartAddress() +
           (kNumberOfEntries * table_entry_size_)) {
     return kNotDeoptimizationEntry;
   }
   ASSERT_EQ(0,
       static_cast<int>(addr - base->GetStartAddress()) % table_entry_size_);
-  return (addr - base->GetStartAddress()) / table_entry_size_;
+  return static_cast<int>(addr - base->GetStartAddress()) / table_entry_size_;
 }
 
 
 unsigned Deoptimizer::GetOutputInfo(DeoptimizationOutputData* data,
                                     unsigned id,
                                     SharedFunctionInfo* shared) {
   // TODO(kasperl): For now, we do a simple linear search for the PC
   // offset associated with the given node id. This should probably be
   // changed to a binary search.
   int length = data->DeoptPoints();
@@ skipping 80 matching lines @@
   }
 
   // Print some helpful diagnostic information.
   if (FLAG_trace_deopt) {
     double ms = static_cast<double>(OS::Ticks() - start) / 1000;
     int index = output_count_ - 1;  // Index of the topmost frame.
     JSFunction* function = output_[index]->GetFunction();
     PrintF("[deoptimizing: end 0x%08" V8PRIxPTR " ",
            reinterpret_cast<intptr_t>(function));
     function->PrintName();
-    PrintF(" => node=%u, pc=0x%08x, state=%s, took %0.3f ms]\n",
+    PrintF(" => node=%u, pc=0x%08" V8PRIxPTR ", state=%s, took %0.3f ms]\n",
            node_id,
            output_[index]->GetPc(),
            FullCodeGenerator::State2String(
                static_cast<FullCodeGenerator::State>(
                    output_[index]->GetState()->value())),
            ms);
   }
 }
 
 
@@ skipping 49 matching lines @@
 
   switch (opcode) {
     case Translation::BEGIN:
     case Translation::FRAME:
     case Translation::DUPLICATE:
       UNREACHABLE();
       return;
 
     case Translation::REGISTER: {
       int input_reg = iterator->Next();
-      uint32_t input_value = input_->GetRegister(input_reg);
+      intptr_t input_value = input_->GetRegister(input_reg);
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- 0x%08x ; %s\n",
-               output_[frame_index]->GetTop() + output_offset,
-               output_offset,
-               input_value,
-               converter.NameOfCPURegister(input_reg));
+        PrintF(
+            "    0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" V8PRIxPTR " ; %s\n",
+            output_[frame_index]->GetTop() + output_offset,
+            output_offset,
+            input_value,
+            converter.NameOfCPURegister(input_reg));
       }
       output_[frame_index]->SetFrameSlot(output_offset, input_value);
       return;
     }
 
     case Translation::INT32_REGISTER: {
       int input_reg = iterator->Next();
-      uint32_t value = input_->GetRegister(input_reg);
+      intptr_t value = input_->GetRegister(input_reg);
       bool is_smi = Smi::IsValid(value);
       unsigned output_index = output_offset / kPointerSize;
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- %d ; %s (%s)\n",
-               output_[frame_index]->GetTop() + output_offset,
-               output_offset,
-               value,
-               converter.NameOfCPURegister(input_reg),
-               is_smi ? "smi" : "heap number");
+        PrintF(
+            "    0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIdPTR " ; %s (%s)\n",
+            output_[frame_index]->GetTop() + output_offset,
+            output_offset,
+            value,
+            converter.NameOfCPURegister(input_reg),
+            is_smi ? "smi" : "heap number");
       }
       if (is_smi) {
         intptr_t tagged_value =
-            reinterpret_cast<intptr_t>(Smi::FromInt(value));
+            reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
-        AddInteger32Value(frame_index, output_index, value);
+        AddInteger32Value(frame_index,
+                          output_index,
+                          static_cast<int32_t>(value));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
 
     case Translation::DOUBLE_REGISTER: {
       int input_reg = iterator->Next();
       double value = input_->GetDoubleRegister(input_reg);
       unsigned output_index = output_offset / kPointerSize;
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- %e ; %s\n",
+        PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- %e ; %s\n",
                output_[frame_index]->GetTop() + output_offset,
                output_offset,
                value,
                DoubleRegister::AllocationIndexToString(input_reg));
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(frame_index, output_index, value);
       output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       return;
     }
 
     case Translation::STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset =
           input_->GetOffsetFromSlotIndex(this, input_slot_index);
-      uint32_t input_value = input_->GetFrameSlot(input_offset);
+      intptr_t input_value = input_->GetFrameSlot(input_offset);
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- 0x%08x ; [esp + %d]\n",
-               output_[frame_index]->GetTop() + output_offset,
+        PrintF("    0x%08" V8PRIxPTR ": ",
+               output_[frame_index]->GetTop() + output_offset);
+        PrintF("[top + %d] <- 0x%08" V8PRIxPTR " ; [esp + %d]\n",
                output_offset,
                input_value,
                input_offset);
       }
       output_[frame_index]->SetFrameSlot(output_offset, input_value);
       return;
     }
 
     case Translation::INT32_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset =
           input_->GetOffsetFromSlotIndex(this, input_slot_index);
-      int32_t value = input_->GetFrameSlot(input_offset);
+      intptr_t value = input_->GetFrameSlot(input_offset);
       bool is_smi = Smi::IsValid(value);
       unsigned output_index = output_offset / kPointerSize;
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- %d ; [esp + %d] (%s)\n",
-               output_[frame_index]->GetTop() + output_offset,
+        PrintF("    0x%08" V8PRIxPTR ": ",
+               output_[frame_index]->GetTop() + output_offset);
+        PrintF("[top + %d] <- %" V8PRIdPTR " ; [esp + %d] (%s)\n",
                output_offset,
                value,
                input_offset,
                is_smi ? "smi" : "heap number");
       }
       if (is_smi) {
         intptr_t tagged_value =
-            reinterpret_cast<intptr_t>(Smi::FromInt(value));
+            reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value)));
         output_[frame_index]->SetFrameSlot(output_offset, tagged_value);
       } else {
         // We save the untagged value on the side and store a GC-safe
         // temporary placeholder in the frame.
-        AddInteger32Value(frame_index, output_index, value);
+        AddInteger32Value(frame_index,
+                          output_index,
+                          static_cast<int32_t>(value));
         output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       }
       return;
     }
 
     case Translation::DOUBLE_STACK_SLOT: {
       int input_slot_index = iterator->Next();
       unsigned input_offset =
           input_->GetOffsetFromSlotIndex(this, input_slot_index);
       double value = input_->GetDoubleFrameSlot(input_offset);
       unsigned output_index = output_offset / kPointerSize;
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- %e ; [esp + %d]\n",
+        PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- %e ; [esp + %d]\n",
                output_[frame_index]->GetTop() + output_offset,
                output_offset,
                value,
                input_offset);
       }
       // We save the untagged value on the side and store a GC-safe
       // temporary placeholder in the frame.
       AddDoubleValue(frame_index, output_index, value);
       output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder);
       return;
     }
 
     case Translation::LITERAL: {
       Object* literal = ComputeLiteral(iterator->Next());
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- ",
+        PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         literal->ShortPrint();
         PrintF(" ; literal\n");
       }
       intptr_t value = reinterpret_cast<intptr_t>(literal);
       output_[frame_index]->SetFrameSlot(output_offset, value);
       return;
     }
 
     case Translation::ARGUMENTS_OBJECT: {
       // Use the hole value as a sentinel and fill in the arguments object
       // after the deoptimized frame is built.
       ASSERT(frame_index == 0);  // Only supported for first frame.
       if (FLAG_trace_deopt) {
-        PrintF("    0x%08x: [top + %d] <- ",
+        PrintF("    0x%08" V8PRIxPTR ": [top + %d] <- ",
                output_[frame_index]->GetTop() + output_offset,
                output_offset);
         isolate_->heap()->the_hole_value()->ShortPrint();
         PrintF(" ; arguments object\n");
       }
       intptr_t value = reinterpret_cast<intptr_t>(
           isolate_->heap()->the_hole_value());
       output_[frame_index]->SetFrameSlot(output_offset, value);
       return;
     }
   }
 }
 
 
 bool Deoptimizer::DoOsrTranslateCommand(TranslationIterator* iterator,
                                         int* input_offset) {
   disasm::NameConverter converter;
   FrameDescription* output = output_[0];
 
   // The input values are all part of the unoptimized frame so they
   // are all tagged pointers.
-  uint32_t input_value = input_->GetFrameSlot(*input_offset);
+  uintptr_t input_value = input_->GetFrameSlot(*input_offset);
   Object* input_object = reinterpret_cast<Object*>(input_value);
 
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
   bool duplicate = (opcode == Translation::DUPLICATE);
   if (duplicate) {
     opcode = static_cast<Translation::Opcode>(iterator->Next());
   }
 
   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%08x ; [esp + %d]\n",
+         PrintF("    %s <- 0x%08" V8PRIxPTR " ; [esp + %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.
@@ skipping 36 matching lines @@
       }
       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%08x ; [esp + %d]\n",
+        PrintF("    [esp + %d] <- 0x%08" V8PRIxPTR " ; [esp + %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.
@@ skipping 228 matching lines @@
     SetFrameSlot(o, kZapUint32);
   }
 }
 
 
 unsigned FrameDescription::GetOffsetFromSlotIndex(Deoptimizer* deoptimizer,
                                                   int slot_index) {
   if (slot_index >= 0) {
     // Local or spill slots. Skip the fixed part of the frame
     // including all arguments.
-    unsigned base =
-        GetFrameSize() - deoptimizer->ComputeFixedSize(GetFunction());
+    unsigned base = static_cast<unsigned>(
+        GetFrameSize() - deoptimizer->ComputeFixedSize(GetFunction()));
     return base - ((slot_index + 1) * kPointerSize);
   } else {
     // Incoming parameter.
-    unsigned base = GetFrameSize() -
-        deoptimizer->ComputeIncomingArgumentSize(GetFunction());
+    unsigned base = static_cast<unsigned>(GetFrameSize() -
+        deoptimizer->ComputeIncomingArgumentSize(GetFunction()));
     return base - ((slot_index + 1) * kPointerSize);
   }
 }
 
 
 void TranslationBuffer::Add(int32_t value) {
   // Encode the sign bit in the least significant bit.
   bool is_negative = (value < 0);
   uint32_t bits = ((is_negative ? -value : value) << 1) |
       static_cast<int32_t>(is_negative);
@@ skipping 159 matching lines @@
 }
 
 
 DeoptimizingCodeListNode::~DeoptimizingCodeListNode() {
   GlobalHandles* global_handles = Isolate::Current()->global_handles();
   global_handles->Destroy(reinterpret_cast<Object**>(code_.location()));
 }
 
 
 } }  // namespace v8::internal