ARM Deoptimizer: fix TODO from r13484

src/arm/deoptimizer-arm.cc

 // Copyright 2012 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 1110 matching lines @@
   // r0: deoptimizer object; r1: scratch.
   __ PrepareCallCFunction(1, r1);
   // Call Deoptimizer::ComputeOutputFrames().
   {
     AllowExternalCallThatCantCauseGC scope(masm());
     __ CallCFunction(
         ExternalReference::compute_output_frames_function(isolate), 1);
   }
   __ pop(r0);  // Restore deoptimizer object (class Deoptimizer).
 
-  // TODO(hans): Change the code below to not clobber r0, so that it can be
-  // used in the "restore the d registers" code further down, making this mov
-  // redundant.
-  __ mov(r4, r0);
-
   // Replace the current (input) frame with the output frames.
   Label outer_push_loop, inner_push_loop,
       outer_loop_header, inner_loop_header;
-  // Outer loop state: r0 = current "FrameDescription** output_",
+  // Outer loop state: r4 = current "FrameDescription** output_",
   // r1 = one past the last FrameDescription**.
   __ ldr(r1, MemOperand(r0, Deoptimizer::output_count_offset()));
-  __ ldr(r0, MemOperand(r0, Deoptimizer::output_offset()));  // r0 is output_.
-  __ add(r1, r0, Operand(r1, LSL, 2));
+  __ ldr(r4, MemOperand(r0, Deoptimizer::output_offset()));  // r4 is output_.
+  __ add(r1, r4, Operand(r1, LSL, 2));
   __ jmp(&outer_loop_header);
   __ bind(&outer_push_loop);
   // Inner loop state: r2 = current FrameDescription*, r3 = loop index.
-  __ ldr(r2, MemOperand(r0, 0));  // output_[ix]
+  __ ldr(r2, MemOperand(r4, 0));  // output_[ix]
   __ ldr(r3, MemOperand(r2, FrameDescription::frame_size_offset()));
   __ jmp(&inner_loop_header);
   __ bind(&inner_push_loop);
   __ sub(r3, r3, Operand(sizeof(uint32_t)));
   __ add(r6, r2, Operand(r3));
   __ ldr(r7, MemOperand(r6, FrameDescription::frame_content_offset()));
   __ push(r7);
   __ bind(&inner_loop_header);
   __ cmp(r3, Operand::Zero());
   __ b(ne, &inner_push_loop);  // test for gt?
-  __ add(r0, r0, Operand(kPointerSize));
+  __ add(r4, r4, Operand(kPointerSize));
   __ bind(&outer_loop_header);
-  __ cmp(r0, r1);
+  __ cmp(r4, r1);
   __ b(lt, &outer_push_loop);
 
   if (CpuFeatures::IsSupported(VFP2)) {
     CpuFeatures::Scope scope(VFP2);
     // In case of OSR, we have to restore the d registers.
     if (type() == OSR) {
       // Check CPU flags for number of registers, setting the Z condition flag.
       __ CheckFor32DRegs(ip);
 
-      __ ldr(r1, MemOperand(r4, Deoptimizer::input_offset()));
+      __ ldr(r1, MemOperand(r0, Deoptimizer::input_offset()));
       int src_offset = FrameDescription::double_registers_offset();
       for (int i = 0; i < DwVfpRegister::kNumRegisters; ++i) {
         if (i == kDoubleRegZero.code()) continue;
         if (i == kScratchDoubleReg.code()) continue;
 
         const DwVfpRegister reg = DwVfpRegister::from_code(i);
         __ vldr(reg, r1, src_offset, i < 16 ? al : ne);
         src_offset += kDoubleSize;
       }
     }
@@ skipping 49 matching lines @@
     __ push(ip);
     __ b(&done);
     ASSERT(masm()->pc_offset() - start == table_entry_size_);
   }
   __ bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal