MIPS64: Fix bugs after hole-nan value change.

src/mips64/lithium-codegen-mips64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/hydrogen-osr.h"
 #include "src/ic/ic.h"
@@ skipping 2319 matching lines @@
     __ li(at, Operand(factory()->the_hole_value()));
     EmitBranch(instr, eq, input_reg, Operand(at));
     return;
   }
 
   DoubleRegister input_reg = ToDoubleRegister(instr->object());
   EmitFalseBranchF(instr, eq, input_reg, input_reg);
 
   Register scratch = scratch0();
   __ FmoveHigh(scratch, input_reg);
+  __ dsll32(scratch, scratch, 0);  // FmoveHigh (mfhc1) sign-extends.
+  __ dsrl32(scratch, scratch, 0);  // Use only low 32-bits.
   EmitBranch(instr, eq, scratch, Operand(kHoleNanUpper32));
 }
 
 
 void LCodeGen::DoCompareMinusZeroAndBranch(LCompareMinusZeroAndBranch* instr) {
   Representation rep = instr->hydrogen()->value()->representation();
   DCHECK(!rep.IsInteger32());
   Register scratch = ToRegister(instr->temp());
 
   if (rep.IsDouble()) {
@@ skipping 891 matching lines @@
       __ dsra32(at, key, 0);
     } else {
       __ dsra(at, key, -shift_size);
     }
     __ Daddu(scratch, scratch, at);
   }
 
   __ ldc1(result, MemOperand(scratch));
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
-    __ lw(scratch, MemOperand(scratch, sizeof(kHoleNanLower32)));
+    __ lwu(scratch, MemOperand(scratch, sizeof(kHoleNanLower32)));
     DeoptimizeIf(eq, instr, "hole", scratch, Operand(kHoleNanUpper32));
   }
 }
 
 
 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
   HLoadKeyed* hinstr = instr->hydrogen();
   Register elements = ToRegister(instr->elements());
   Register result = ToRegister(instr->result());
   Register scratch = scratch0();
@@ skipping 920 matching lines @@
   }
 }
 
 
 void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
   Representation representation = instr->representation();
 
   Register object = ToRegister(instr->object());
   Register scratch2 = scratch1();
   Register scratch1 = scratch0();
+
   HObjectAccess access = instr->hydrogen()->access();
   int offset = access.offset();
   if (access.IsExternalMemory()) {
     Register value = ToRegister(instr->value());
     MemOperand operand = MemOperand(object, offset);
     __ Store(value, operand, representation);
     return;
   }
 
   __ AssertNotSmi(object);
 
   DCHECK(!representation.IsSmi() ||
          !instr->value()->IsConstantOperand() ||
          IsSmi(LConstantOperand::cast(instr->value())));
-  if (representation.IsDouble()) {
+  if (!FLAG_unbox_double_fields && representation.IsDouble()) {
     DCHECK(access.IsInobject());
     DCHECK(!instr->hydrogen()->has_transition());
     DCHECK(!instr->hydrogen()->NeedsWriteBarrier());
     DoubleRegister value = ToDoubleRegister(instr->value());
     __ sdc1(value, FieldMemOperand(object, offset));
     return;
   }
 
   if (instr->hydrogen()->has_transition()) {
     Handle<Map> transition = instr->hydrogen()->transition_map();
@@ skipping 10 matching lines @@
                            kSaveFPRegs);
     }
   }
 
   // Do the store.
   Register destination = object;
   if (!access.IsInobject()) {
        destination = scratch1;
     __ ld(destination, FieldMemOperand(object, JSObject::kPropertiesOffset));
   }
-  Register value = ToRegister(instr->value());
+
   if (representation.IsSmi() && SmiValuesAre32Bits() &&
       instr->hydrogen()->value()->representation().IsInteger32()) {
     DCHECK(instr->hydrogen()->store_mode() == STORE_TO_INITIALIZED_ENTRY);
     if (FLAG_debug_code) {
       __ Load(scratch2, FieldMemOperand(destination, offset), representation);
       __ AssertSmi(scratch2);
     }
-
     // Store int value directly to upper half of the smi.
     offset += kPointerSize / 2;
     representation = Representation::Integer32();
   }
+  MemOperand operand = FieldMemOperand(destination, offset);
 
-  MemOperand operand = FieldMemOperand(destination, offset);
-  __ Store(value, operand, representation);
+  if (FLAG_unbox_double_fields && representation.IsDouble()) {
+    DCHECK(access.IsInobject());
+    DoubleRegister value = ToDoubleRegister(instr->value());
+    __ sdc1(value, operand);
+  } else {
+    DCHECK(instr->value()->IsRegister());
+    Register value = ToRegister(instr->value());
+    __ Store(value, operand, representation);
+  }
+
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     // Update the write barrier for the object for in-object properties.
+    Register value = ToRegister(instr->value());
     __ RecordWriteField(destination,
                         offset,
                         value,
                         scratch2,
                         GetRAState(),
                         kSaveFPRegs,
                         EMIT_REMEMBERED_SET,
                         instr->hydrogen()->SmiCheckForWriteBarrier(),
                         instr->hydrogen()->PointersToHereCheckForValue());
   }
@@ skipping 1741 matching lines @@
   __ li(at, scope_info);
   __ Push(at, ToRegister(instr->function()));
   CallRuntime(Runtime::kPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal