fix -Wunused-but-set-variable for gcc-4.6 on x64

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 641 matching lines @@
   }
   __ bind(&done);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64