Merge bleeding edge up to 8774 into the GC branch.

src/x64/deoptimizer-x64.cc

 // Copyright 2011 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 110 matching lines @@
 
   // For each return after a safepoint insert a absolute call to the
   // corresponding deoptimization entry, or a short call to an absolute
   // jump if space is short. The absolute jumps are put in a table just
   // before the safepoint table (space was allocated there when the Code
   // object was created, if necessary).
 
   Address instruction_start = function->code()->instruction_start();
   Address jump_table_address =
       instruction_start + function->code()->safepoint_table_offset();
+#ifdef DEBUG
   Address previous_pc = instruction_start;
+#endif
 
   SafepointTableDeoptimiztionEntryIterator deoptimizations(function->code());
   Address entry_pc = NULL;
 
   SafepointEntry current_entry = deoptimizations.Next(&entry_pc);
   while (current_entry.is_valid()) {
     int gap_code_size = current_entry.gap_code_size();
     unsigned deoptimization_index = current_entry.deoptimization_index();
 
 #ifdef DEBUG
     // Destroy the code which is not supposed to run again.
     ZapCodeRange(previous_pc, entry_pc);
 #endif
     // Position where Call will be patched in.
     Address call_address = entry_pc + gap_code_size;
     // End of call instruction, if using a direct call to a 64-bit address.
     Address call_end_address =
         call_address + MacroAssembler::kCallInstructionLength;
 
     // Find next deoptimization entry, if any.
     Address next_pc = NULL;
     SafepointEntry next_entry = deoptimizations.Next(&next_pc);
 
     if (!next_entry.is_valid() || next_pc >= call_end_address) {
       // Room enough to write a long call instruction.
       CodePatcher patcher(call_address, Assembler::kCallInstructionLength);
       patcher.masm()->Call(GetDeoptimizationEntry(deoptimization_index, LAZY),
                            RelocInfo::NONE);
+#ifdef DEBUG
       previous_pc = call_end_address;
+#endif
     } else {
       // Not room enough for a long Call instruction. Write a short call
       // instruction to a long jump placed elsewhere in the code.
+#ifdef DEBUG
       Address short_call_end_address =
           call_address + MacroAssembler::kShortCallInstructionLength;
+#endif
       ASSERT(next_pc >= short_call_end_address);
 
       // Write jump in jump-table.
       jump_table_address -= MacroAssembler::kJumpInstructionLength;
       CodePatcher jump_patcher(jump_table_address,
                                MacroAssembler::kJumpInstructionLength);
       jump_patcher.masm()->Jump(
           GetDeoptimizationEntry(deoptimization_index, LAZY),
           RelocInfo::NONE);
 
       // Write call to jump at call_offset.
       CodePatcher call_patcher(call_address,
                                MacroAssembler::kShortCallInstructionLength);
       call_patcher.masm()->call(jump_table_address);
+#ifdef DEBUG
       previous_pc = short_call_end_address;
+#endif
     }
 
     // Continue with next deoptimization entry.
     current_entry = next_entry;
     entry_pc = next_pc;
   }
 
 #ifdef DEBUG
   // Destroy the code which is not supposed to run again.
   ZapCodeRange(previous_pc, jump_table_address);
@@ skipping 446 matching lines @@
 
   for (int i = 0; i < XMMRegister::kNumAllocatableRegisters; ++i) {
     XMMRegister xmm_reg = XMMRegister::FromAllocationIndex(i);
     int offset = i * kDoubleSize;
     __ movsd(Operand(rsp, offset), xmm_reg);
   }
 
   // We push all registers onto the stack, even though we do not need
   // to restore all later.
   for (int i = 0; i < kNumberOfRegisters; i++) {
-    Register r = Register::toRegister(i);
+    Register r = Register::from_code(i);
     __ push(r);
   }
 
   const int kSavedRegistersAreaSize = kNumberOfRegisters * kPointerSize +
                                       kDoubleRegsSize;
 
   // When calling new_deoptimizer_function we need to pass the last argument
   // on the stack on windows and in r8 on linux. The remaining arguments are
   // all passed in registers (different ones on linux and windows though).
 
@@ skipping 137 matching lines @@
   __ push(Operand(rbx, FrameDescription::continuation_offset()));
 
   // Push the registers from the last output frame.
   for (int i = 0; i < kNumberOfRegisters; i++) {
     int offset = (i * kPointerSize) + FrameDescription::registers_offset();
     __ push(Operand(rbx, offset));
   }
 
   // Restore the registers from the stack.
   for (int i = kNumberOfRegisters - 1; i >= 0 ; i--) {
-    Register r = Register::toRegister(i);
+    Register r = Register::from_code(i);
     // Do not restore rsp, simply pop the value into the next register
     // and overwrite this afterwards.
     if (r.is(rsp)) {
       ASSERT(i > 0);
-      r = Register::toRegister(i - 1);
+      r = Register::from_code(i - 1);
     }
     __ pop(r);
   }
 
   // Set up the roots register.
   __ InitializeRootRegister();
   __ InitializeSmiConstantRegister();
 
   // Return to the continuation point.
   __ ret(0);
@@ skipping 12 matching lines @@
   }
   __ bind(&done);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64