A64: Synchronize with r18084.

src/a64/lithium-codegen-a64.cc

 // Copyright 2013 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 599 matching lines @@
   FrameScope frame_scope(masm_, StackFrame::NONE);
 
   return GeneratePrologue() &&
       GenerateBody() &&
       GenerateDeferredCode() &&
       GenerateDeoptJumpTable() &&
       GenerateSafepointTable();
 }
 
 
+void LCodeGen::SaveCallerDoubles() {
+  ASSERT(info()->saves_caller_doubles());
+  ASSERT(NeedsEagerFrame());
+  Comment(";;; Save clobbered callee double registers");
+  BitVector* doubles = chunk()->allocated_double_registers();
+  BitVector::Iterator iterator(doubles);
+  int count = 0;
+  while (!iterator.Done()) {
+    // TODO(all): Is this supposed to save just the callee-saved doubles? It
+    // looks like it's saving all of them.
+    FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
+    __ Poke(value, count * kDoubleSize);
+    iterator.Advance();
+    count++;
+  }
+}
+
+
+void LCodeGen::RestoreCallerDoubles() {
+  ASSERT(info()->saves_caller_doubles());
+  ASSERT(NeedsEagerFrame());
+  Comment(";;; Restore clobbered callee double registers");
+  BitVector* doubles = chunk()->allocated_double_registers();
+  BitVector::Iterator iterator(doubles);
+  int count = 0;
+  while (!iterator.Done()) {
+    // TODO(all): Is this supposed to restore just the callee-saved doubles? It
+    // looks like it's restoring all of them.
+    FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
+    __ Peek(value, count * kDoubleSize);
+    iterator.Advance();
+    count++;
+  }
+}
+
+
 bool LCodeGen::GeneratePrologue() {
   ASSERT(is_generating());
 
   if (info()->IsOptimizing()) {
     ProfileEntryHookStub::MaybeCallEntryHook(masm_);
 
     // TODO(all): Add support for stop_t FLAG in DEBUG mode.
 
     // Strict mode functions and builtins need to replace the receiver
     // with undefined when called as functions (without an explicit
@@ skipping 18 matching lines @@
     info_->AddNoFrameRange(0, masm_->pc_offset());
   }
 
   // Reserve space for the stack slots needed by the code.
   int slots = GetStackSlotCount();
   if (slots > 0) {
     __ Claim(slots, kPointerSize);
   }
 
   if (info()->saves_caller_doubles()) {
-    Comment(";;; Save clobbered callee double registers");
-    ASSERT(NeedsEagerFrame());
-    BitVector* doubles = chunk()->allocated_double_registers();
-    BitVector::Iterator iterator(doubles);
-    int count = 0;
-    while (!iterator.Done()) {
-      FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
-      __ Poke(value, count * kDoubleSize);
-      iterator.Advance();
-      count++;
-    }
+    SaveCallerDoubles();
   }
 
   // Allocate a local context if needed.
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
     Comment(";;; Allocate local context");
     // Argument to NewContext is the function, which is in x1.
     __ Push(x1);
     if (heap_slots <= FastNewContextStub::kMaximumSlots) {
       FastNewContextStub stub(heap_slots);
@@ skipping 117 matching lines @@
     __ Bind(&deopt_jump_table_[i].label);
     Address entry = deopt_jump_table_[i].address;
     Deoptimizer::BailoutType type = deopt_jump_table_[i].bailout_type;
     int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);
     if (id == Deoptimizer::kNotDeoptimizationEntry) {
       Comment(";;; jump table entry %d.", i);
     } else {
       Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);
     }
     if (deopt_jump_table_[i].needs_frame) {
+      ASSERT(!info()->saves_caller_doubles());
       __ Mov(__ Tmp0(), Operand(ExternalReference::ForDeoptEntry(entry)));
       if (needs_frame.is_bound()) {
         __ B(&needs_frame);
       } else {
         __ Bind(&needs_frame);
         // This variant of deopt can only be used with stubs. Since we don't
         // have a function pointer to install in the stack frame that we're
         // building, install a special marker there instead.
         // TODO(jochen): Revisit the use of TmpX().
         ASSERT(info()->IsStub());
         __ Mov(__ Tmp1(), Operand(Smi::FromInt(StackFrame::STUB)));
         __ Push(lr, fp, cp, __ Tmp1());
         __ Add(fp, __ StackPointer(), 2 * kPointerSize);
         __ Call(__ Tmp0());
       }
     } else {
+      if (info()->saves_caller_doubles()) {
+        ASSERT(info()->IsStub());
+        RestoreCallerDoubles();
+      }
       __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     }
     masm()->CheckConstPool(false, false);
   }
 
   // Force constant pool emission at the end of the deopt jump table to make
   // sure that no constant pools are emitted after.
   masm()->CheckConstPool(true, false);
 
   // The deoptimization jump table is the last part of the instruction
@@ skipping 133 matching lines @@
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     return;
   }
 
   if (info()->ShouldTrapOnDeopt()) {
     __ Debug("trap_on_deopt", __LINE__, BREAK);
   }
 
 
   ASSERT(info()->IsStub() || frame_is_built_);
-  if (frame_is_built_) {
+  // Go through jump table if we need to build frame, or restore caller doubles.
+  if (frame_is_built_ && !info()->saves_caller_doubles()) {
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
   } else {
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (deopt_jump_table_.is_empty() ||
         (deopt_jump_table_.last().address != entry) ||
         (deopt_jump_table_.last().bailout_type != bailout_type) ||
         (deopt_jump_table_.last().needs_frame != !frame_is_built_)) {
       Deoptimizer::JumpTableEntry table_entry(entry,
                                               bailout_type,
@@ skipping 2716 matching lines @@
 
 void LCodeGen::DoMathCos(LMathCos* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d0));
   TranscendentalCacheStub stub(TranscendentalCache::COS,
                                TranscendentalCacheStub::UNTAGGED);
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   ASSERT(ToDoubleRegister(instr->result()).Is(d0));
 }
 
 
-// TODO(all): This will disappear when Math.random is rewritten in JavaScript.
-void LCodeGen::DoRandom(LRandom* instr) {
-  class DeferredDoRandom: public LDeferredCode {
-   public:
-    DeferredDoRandom(LCodeGen* codegen, LRandom* instr)
-        : LDeferredCode(codegen), instr_(instr) { }
-    virtual void Generate() { codegen()->DoDeferredRandom(instr_); }
-    virtual LInstruction* instr() { return instr_; }
-
-   private:
-    LRandom* instr_;
-  };
-
-  DeferredDoRandom* deferred = new(zone()) DeferredDoRandom(this, instr);
-
-  // Having marked this instruction as a call we can use any registers.
-  ASSERT(instr->IsMarkedAsCall());
-  ASSERT(ToDoubleRegister(instr->result()).is(d7));
-  ASSERT(ToRegister(instr->global_object()).is(x0));
-
-  static const int kSeedSize = sizeof(uint32_t);
-  STATIC_ASSERT(kPointerSize == 2 * kSeedSize);
-
-  Register global_object = x0;
-  __ Ldr(global_object,
-         FieldMemOperand(global_object, GlobalObject::kNativeContextOffset));
-  static const int kRandomSeedOffset =
-      FixedArray::kHeaderSize + Context::RANDOM_SEED_INDEX * kPointerSize;
-  __ Ldr(x1, FieldMemOperand(global_object, kRandomSeedOffset));
-  // x1: FixedArray of the native context's random seeds
-
-  // Load state[0].
-  __ Ldr(w2, FieldMemOperand(x1, ByteArray::kHeaderSize));
-  // If state[0] == 0, call runtime to initialize seeds.
-  __ Cbz(w2, deferred->entry());
-  // Load state[1].
-  __ Ldr(w3, FieldMemOperand(x1, ByteArray::kHeaderSize + kSeedSize));
-
-  // state[0] = 18273 * (state[0] & 0xFFFF) + (state[0] >> 16)
-  __ And(w4, w2, 0xFFFF);
-  __ Mov(w5, 18273);
-  __ Mul(w5, w5, w4);
-  __ Add(w2, w5, Operand(w2, LSR, 16));
-  // Save state[0].
-  __ Str(w2, FieldMemOperand(x1, ByteArray::kHeaderSize));
-
-  // state[1] = 36969 * (state[1] & 0xFFFF) + (state[1] >> 16)
-  __ And(w4, w3, 0xFFFF);
-  __ Mov(w5, 36969);
-  __ Mul(w5, w5, w4);
-  __ Add(w3, w5, Operand(w3, LSR, 16));
-  // Save state[1].
-  __ Str(w3, FieldMemOperand(x1, ByteArray::kHeaderSize + kSeedSize));
-
-  // Random bit pattern = (state[0] << 14) + (state[1] & 0x3FFFF)
-  __ And(w3, w3, 0x3FFFF);
-  __ Add(w0, w3, Operand(w2, LSL, 14));
-
-  __ Bind(deferred->exit());
-  // Interpret the 32 random bits as a 0.32 fixed point number, and convert to
-  // a double in the range 0.0 <= number < 1.0.
-  __ Ucvtf(d7, w0, 32);
-}
-
-
-// TODO(all): This will disappear when Math.random is rewritten in JavaScript.
-void LCodeGen::DoDeferredRandom(LRandom* instr) {
-  __ CallCFunction(ExternalReference::random_uint32_function(isolate()), 1);
-  // Return value is in x0.
-}
-
-
 void LCodeGen::DoMathExp(LMathExp* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister result = ToDoubleRegister(instr->result());
   DoubleRegister double_temp1 = ToDoubleRegister(instr->double_temp1());
   DoubleRegister double_temp2 = double_scratch();
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
   Register temp3 = ToRegister(instr->temp3());
 
   MathExpGenerator::EmitMathExp(masm(), input, result,
@@ skipping 681 matching lines @@
 
 void LCodeGen::DoReturn(LReturn* instr) {
   if (FLAG_trace && info()->IsOptimizing()) {
     // Push the return value on the stack as the parameter.
     // Runtime::TraceExit returns its parameter in x0.
     __ Push(x0);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
 
   if (info()->saves_caller_doubles()) {
-    ASSERT(NeedsEagerFrame());
-    BitVector* doubles = chunk()->allocated_double_registers();
-    BitVector::Iterator iterator(doubles);
-    int count = 0;
-    while (!iterator.Done()) {
-      FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
-      __ Peek(value, count * kDoubleSize);
-      iterator.Advance();
-      count++;
-    }
+    RestoreCallerDoubles();
   }
 
   int no_frame_start = -1;
   if (NeedsEagerFrame()) {
     Register stack_pointer = masm()->StackPointer();
     __ Mov(stack_pointer, fp);
     no_frame_start = masm_->pc_offset();
     __ Pop(fp, lr);
   }
 
@@ skipping 1231 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal