A64: Synchronize with r16249.

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 197 matching lines @@
 
   virtual void EmitInverted(Label* label) const {
     __ JumpIfNotHeapNumber(value_, label);
   }
 
  private:
   const Register& value_;
 };
 
 
+// Test the input and branch if it is the specified root value.
+class BranchIfRoot : public BranchGenerator {
+ public:
+  BranchIfRoot(LCodeGen* codegen, const Register& value,
+               Heap::RootListIndex index)
+      : BranchGenerator(codegen), value_(value), index_(index) { }
+
+  virtual void Emit(Label* label) const {
+    __ JumpIfRoot(value_, index_, label);
+  }
+
+  virtual void EmitInverted(Label* label) const {
+    __ JumpIfNotRoot(value_, index_, label);
+  }
+
+ private:
+  const Register& value_;
+  const Heap::RootListIndex index_;
+};
+
+
 void LCodeGen::WriteTranslation(LEnvironment* environment,
                                 Translation* translation) {
   if (environment == NULL) return;
 
   // The translation includes one command per value in the environment.
   int translation_size = environment->translation_size();
   // The output frame height does not include the parameters.
   int height = translation_size - environment->parameter_count();
 
   WriteTranslation(environment->outer(), translation);
@@ skipping 334 matching lines @@
 
 void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
   LPointerMap empty_pointers(RelocInfo::kNoPosition, zone());
   RecordSafepoint(&empty_pointers, deopt_mode);
 }
 
 
 void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
                                             int arguments,
                                             Safepoint::DeoptMode deopt_mode) {
-  RecordSafepoint(
-      pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
+  RecordSafepoint(pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
 }
 
 
+void LCodeGen::RecordSafepointWithRegistersAndDoubles(
+    LPointerMap* pointers, int arguments, Safepoint::DeoptMode deopt_mode) {
+  RecordSafepoint(
+      pointers, Safepoint::kWithRegistersAndDoubles, arguments, deopt_mode);
+}
+
+
 bool LCodeGen::GenerateCode() {
   LPhase phase("Z_Code generation", chunk());
   ASSERT(is_unused());
   status_ = GENERATING;
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // NONE indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in GeneratePrologue).
   FrameScope frame_scope(masm_, StackFrame::NONE);
 
@@ skipping 699 matching lines @@
 
 
 template<class InstrType>
 void LCodeGen::EmitBranchIfHeapNumber(InstrType instr,
                                       const Register& value) {
   BranchIfHeapNumber branch(this, value);
   EmitBranchGeneric(instr, branch);
 }
 
 
+template<class InstrType>
+void LCodeGen::EmitBranchIfRoot(InstrType instr,
+                                const Register& value,
+                                Heap::RootListIndex index) {
+  BranchIfRoot branch(this, value, index);
+  EmitBranchGeneric(instr, branch);
+}
+
+
 void LCodeGen::DoGap(LGap* gap) {
   for (int i = LGap::FIRST_INNER_POSITION;
        i <= LGap::LAST_INNER_POSITION;
        i++) {
     LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
     LParallelMove* move = gap->GetParallelMove(inner_pos);
     if (move != NULL) {
       resolver_.Resolve(move);
     }
   }
@@ skipping 913 matching lines @@
   // The class name we are testing against is internalized since it's a literal.
   // The name in the constructor is internalized because of the way the context
   // is booted. This routine isn't expected to work for random API-created
   // classes and it doesn't have to because you can't access it with natives
   // syntax. Since both sides are internalized it is sufficient to use an
   // identity comparison.
   EmitCompareAndBranch(instr, eq, scratch1, Operand(class_name));
 }
 
 
+void LCodeGen::DoCmpHoleAndBranchD(LCmpHoleAndBranchD* instr) {
+  ASSERT(instr->hydrogen()->representation().IsDouble());
+  FPRegister object = ToDoubleRegister(instr->object());
+  Register temp = ToRegister(instr->temp());
+
+  // If we don't have a NaN, we don't have the hole, so branch now to avoid the
+  // (relatively expensive) hole-NaN check.
+  __ Fcmp(object, object);
+  __ B(vc, instr->FalseLabel(chunk_));
+
+  // We have a NaN, but is it the hole?
+  __ Fmov(temp, object);
+  EmitCompareAndBranch(instr, eq, temp, kHoleNanInt64);
+}
+
+
+void LCodeGen::DoCmpHoleAndBranchT(LCmpHoleAndBranchT* instr) {
+  ASSERT(instr->hydrogen()->representation().IsTagged());
+  Register object = ToRegister(instr->object());
+
+  EmitBranchIfRoot(instr, object, Heap::kTheHoleValueRootIndex);
+}
+
+
 void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
   Register value = ToRegister(instr->value());
   Register map = ToRegister(instr->temp());
 
   __ Ldr(map, FieldMemOperand(value, HeapObject::kMapOffset));
   EmitCompareAndBranch(instr, eq, map, Operand(instr->map()));
 }
 
 
 void LCodeGen::DoCompareNumericAndBranch(LCompareNumericAndBranch* instr) {
@@ skipping 136 matching lines @@
   }
 }
 
 
 void LCodeGen::DoCheckFunction(LCheckFunction* instr) {
   Register reg = ToRegister(instr->value());
   Handle<JSFunction> target = instr->hydrogen()->target();
   AllowDeferredHandleDereference smi_check;
   if (isolate()->heap()->InNewSpace(*target)) {
     Register temp = ToRegister(instr->temp());
-    Handle<Cell> cell = isolate()->factory()->NewPropertyCell(target);
+    Handle<Cell> cell = isolate()->factory()->NewCell(target);
     __ Mov(temp, Operand(Handle<Object>(cell)));
     __ Ldr(temp, FieldMemOperand(temp, Cell::kValueOffset));
     __ Cmp(reg, temp);
   } else {
     __ Cmp(reg, Operand(target));
   }
   DeoptimizeIf(ne, instr->environment());
 }
 
 
@@ skipping 52 matching lines @@
 
 void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
   Deoptimizer::BailoutType type = instr->hydrogen()->type();
   // TODO(danno): Stubs expect all deopts to be lazy for historical reasons (the
   // needed return address), even though the implementation of LAZY and EAGER is
   // now identical. When LAZY is eventually completely folded into EAGER, remove
   // the special case below.
   if (info()->IsStub() && (type == Deoptimizer::EAGER)) {
     type = Deoptimizer::LAZY;
   }
+
+  Comment(";;; deoptimize: %s", instr->hydrogen()->reason());
   Deoptimize(instr->environment(), type);
 }
 
 
 void LCodeGen::DoDivI(LDivI* instr) {
   Register dividend = ToRegister32(instr->left());
   Register result = ToRegister32(instr->result());
 
   bool has_power_of_2_divisor = instr->hydrogen()->HasPowerOf2Divisor();
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
@@ skipping 1008 matching lines @@
     if (access.IsInobject()) {
       __ Ldr(result, FieldMemOperand(object, offset));
     } else {
       __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
       __ Ldr(result, FieldMemOperand(result, offset));
     }
   }
 }
 
 
-void LCodeGen::EmitLoadFieldOrConstantFunction(Register result,
-                                               Register object,
-                                               Handle<Map> type,
-                                               Handle<String> name,
-                                               LEnvironment* env) {
-  LookupResult lookup(isolate());
-  type->LookupDescriptor(NULL, *name, &lookup);
-  ASSERT(lookup.IsFound() || lookup.IsCacheable());
-
-  if (lookup.IsField()) {
-    int index = lookup.GetLocalFieldIndexFromMap(*type);
-    int offset = index * kPointerSize;
-    if (index < 0) {
-      // Negative property indices are in-object properties, indexed from the
-      // end of the fixed part of the object.
-      __ Ldr(result, FieldMemOperand(object, offset + type->instance_size()));
-    } else {
-      // Non-negative property indices are in the properties array.
-      __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
-      __ Ldr(result, FieldMemOperand(result, offset + FixedArray::kHeaderSize));
-    }
-  } else if (lookup.IsConstant()) {
-    Handle<Object> constant(lookup.GetConstantFromMap(*type), isolate());
-    __ LoadObject(result, constant);
-  } else {
-    // Negative lookup. Check prototypes.
-    Handle<HeapObject> current(HeapObject::cast((*type)->prototype()));
-    Heap* heap = type->GetHeap();
-    while (*current != heap->null_value()) {
-      __ LoadHeapObject(result, current);
-      __ CompareMap(result, result, Handle<Map>(current->map()));
-      DeoptimizeIf(ne, env);
-      current =
-          Handle<HeapObject>(HeapObject::cast(current->map()->prototype()));
-    }
-    __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
-  }
-}
-
-
-void LCodeGen::DoLoadNamedFieldPolymorphic(LLoadNamedFieldPolymorphic* instr) {
-  Register object = ToRegister(instr->object());
-  Register result = ToRegister(instr->result());
-  // The result register is loaded with its value when the object's map has been
-  // found. At this point we don't need to hold the map in object_map anymore,
-  // so both values can share the same register.
-  // However when we need to go through the generic code path, the instruction
-  // is MarkedAsCall and both object and result registers will be allocated to
-  // x0. Object should not be clobbered until the call to LoadIC. We choose a
-  // different arbitrary register for object_map in this case.
-  Register object_map = instr->IsMarkedAsCall()
-      ? x10
-      : result;
-
-  int map_count = instr->hydrogen()->types()->length();
-  bool need_generic = instr->hydrogen()->need_generic();
-
-  if ((map_count == 0) && !need_generic) {
-    Deoptimize(instr->environment());
-    return;
-  }
-
-  Handle<String> name = instr->hydrogen()->name();
-  Label done;
-  __ Ldr(object_map, FieldMemOperand(object, HeapObject::kMapOffset));
-  for (int i = 0; i < map_count; i++) {
-    bool last = (i == (map_count - 1));
-    Handle<Map> map = instr->hydrogen()->types()->at(i);
-    Label check_passed;
-    __ CompareMap(object_map, map, &check_passed);
-    if (last && !need_generic) {
-      DeoptimizeIf(ne, instr->environment());
-      __ Bind(&check_passed);
-      EmitLoadFieldOrConstantFunction(result, object, map, name,
-                                      instr->environment());
-    } else {
-      Label next;
-      __ B(ne, &next);
-      __ Bind(&check_passed);
-      EmitLoadFieldOrConstantFunction(result, object, map, name,
-                                      instr->environment());
-      __ B(&done);
-      __ Bind(&next);
-    }
-  }
-  if (need_generic) {
-    ASSERT(instr->IsMarkedAsCall());
-    // LoadIC expects x2 to hold the name, and x0 to hold the receiver.
-    ASSERT(object.Is(x0));
-    __ Mov(x2, Operand(name));
-    Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
-    CallCode(ic, RelocInfo::CODE_TARGET, instr);
-  }
-  __ Bind(&done);
-}
-
-
 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
   // LoadIC expects x2 to hold the name, and x0 to hold the receiver.
   ASSERT(ToRegister(instr->object()).is(x0));
   __ Mov(x2, Operand(instr->name()));
 
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
 
   ASSERT(ToRegister(instr->result()).is(x0));
 }
@@ skipping 738 matching lines @@
     virtual void Generate() { codegen()->DoDeferredNumberTagD(instr_); }
     virtual LInstruction* instr() { return instr_; }
    private:
     LNumberTagD* instr_;
   };
 
   DoubleRegister input = ToDoubleRegister(instr->value());
   Register result = ToRegister(instr->result());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
-  Label done;
-
-  bool convert_hole = false;
-  HValue* change_input = instr->hydrogen()->value();
-  if (change_input->IsLoadKeyed()) {
-    HLoadKeyed* load = HLoadKeyed::cast(change_input);
-    convert_hole = load->UsesMustHandleHole();
-  }
-
-  if (convert_hole) {
-    Label no_special_nan_handling, canonicalize;
-    // TODO(jbramley): This special case does not exist in bleeding_edge.
-    // * Non-NaN inputs are handled as usual.
-    // * If the input is the hole, the output is the hole.
-    // * If the input is any other NaN, the output is the canonical NaN.
-    __ Fcmp(input, 0.0);
-    __ B(vc, &no_special_nan_handling);
-    __ Fmov(temp1, input);
-    __ Cmp(temp1, kHoleNanInt64);
-    __ B(ne, &canonicalize);
-    __ Mov(result, Operand(factory()->the_hole_value()));
-    __ B(&done);
-    __ Bind(&canonicalize);
-    // TODO(jbramley): Overwriting the input is probably a mistake, but this
-    // code is removed in bleeding_edge anyway so it won't be here for long.
-    TODO_UNIMPLEMENTED("DoNumberTagD: Fix NaN canonicalization logic.");
-    __ Fmov(input, FixedDoubleArray::canonical_not_the_hole_nan_as_double());
-    __ Bind(&no_special_nan_handling);
-  }
 
   DeferredNumberTagD* deferred = new(zone()) DeferredNumberTagD(this, instr);
   if (FLAG_inline_new) {
     __ AllocateHeapNumber(result, deferred->entry(), temp1, temp2);
   } else {
     __ B(deferred->entry());
   }
 
   __ Bind(deferred->exit());
   __ Str(input, FieldMemOperand(result, HeapNumber::kValueOffset));
-  __ Bind(&done);
 }
 
 
 void LCodeGen::DoDeferredNumberTagU(LInstruction* instr,
                                     LOperand* value,
                                     LOperand* temp1,
                                     LOperand* temp2) {
   Label slow, convert_and_store;
   Register src = ToRegister32(value);
   Register dst = ToRegister(instr->result());
@@ skipping 62 matching lines @@
   __ B(hi, deferred->entry());
   __ SmiTag(result, value);
   __ Bind(deferred->exit());
 }
 
 
 void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
   Register input = ToRegister(instr->value());
   Register scratch = ToRegister(instr->temp());
   DoubleRegister result = ToDoubleRegister(instr->result());
-  bool allow_undefined_as_nan = instr->hydrogen()->allow_undefined_as_nan();
+  bool can_convert_undefined_to_nan =
+      instr->hydrogen()->can_convert_undefined_to_nan();
 
   Label done, load_smi;
 
   // Work out what untag mode we're working with.
-  NumberUntagDMode mode = NUMBER_CANDIDATE_IS_ANY_TAGGED;
   HValue* value = instr->hydrogen()->value();
-  if (value->type().IsSmi()) {
-    mode = NUMBER_CANDIDATE_IS_SMI;
-  } else if (value->IsLoadKeyed()) {
-    HLoadKeyed* load = HLoadKeyed::cast(value);
-    if (load->UsesMustHandleHole()) {
-      if (load->hole_mode() == ALLOW_RETURN_HOLE) {
-        mode = NUMBER_CANDIDATE_IS_ANY_TAGGED_CONVERT_HOLE;
-      }
-    }
-  }
+  NumberUntagDMode mode = value->representation().IsSmi()
+      ? NUMBER_CANDIDATE_IS_SMI : NUMBER_CANDIDATE_IS_ANY_TAGGED;
 
-  STATIC_ASSERT(NUMBER_CANDIDATE_IS_ANY_TAGGED_CONVERT_HOLE >
-                NUMBER_CANDIDATE_IS_ANY_TAGGED);
-  if (mode >= NUMBER_CANDIDATE_IS_ANY_TAGGED) {
+  if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
     __ JumpIfSmi(input, &load_smi);
 
     Label convert_undefined, deopt;
 
     // Heap number map check.
-    Label* not_heap_number = allow_undefined_as_nan ? &convert_undefined
-                                                    : &deopt;
+    Label* not_heap_number = can_convert_undefined_to_nan ? &convert_undefined
+                                                          : &deopt;
     __ Ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
     __ JumpIfNotRoot(scratch, Heap::kHeapNumberMapRootIndex, not_heap_number);
 
     // Load heap number.
     __ Ldr(result, FieldMemOperand(input, HeapNumber::kValueOffset));
     if (instr->hydrogen()->deoptimize_on_minus_zero()) {
       __ JumpIfMinusZero(result, &deopt);
     }
     __ B(&done);
 
-    if (allow_undefined_as_nan) {
-      Label load_nan;
+    if (can_convert_undefined_to_nan) {
+      __ Bind(&convert_undefined);
+      __ JumpIfNotRoot(input, Heap::kUndefinedValueRootIndex, &deopt);
 
-      __ Bind(&convert_undefined);
-      // Convert undefined (and hole) to NaN.
-      if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED_CONVERT_HOLE) {
-        __ JumpIfRoot(input, Heap::kUndefinedValueRootIndex, &load_nan);
-        __ JumpIfNotRoot(input, Heap::kTheHoleValueRootIndex, &deopt);
-      } else {
-        ASSERT(mode == NUMBER_CANDIDATE_IS_ANY_TAGGED);
-        __ JumpIfNotRoot(input, Heap::kUndefinedValueRootIndex, &deopt);
-      }
-
-      __ Bind(&load_nan);
       __ LoadRoot(scratch, Heap::kNanValueRootIndex);
       __ Ldr(result, FieldMemOperand(scratch, HeapNumber::kValueOffset));
       __ B(&done);
     }
 
     __ Bind(&deopt);
     Deoptimize(instr->environment());
   } else {
     ASSERT(mode == NUMBER_CANDIDATE_IS_SMI);
     // Fall through to load_smi.
@@ skipping 895 matching lines @@
   __ CheckMap(object, temp1, from_map, &not_applicable, DONT_DO_SMI_CHECK);
 
   if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
     Register new_map = ToRegister(instr->temp2());
     __ Mov(new_map, Operand(to_map));
     __ Str(new_map, FieldMemOperand(object, HeapObject::kMapOffset));
     // Write barrier.
     __ RecordWriteField(object, HeapObject::kMapOffset, new_map, temp1,
                         GetLinkRegisterState(), kDontSaveFPRegs);
   } else {
-    PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
+    PushSafepointRegistersScope scope(
+        this, Safepoint::kWithRegistersAndDoubles);
     __ Mov(x0, object);
     __ Mov(x1, Operand(to_map));
     TransitionElementsKindStub stub(from_kind, to_kind);
     __ CallStub(&stub);
-    RecordSafepointWithRegisters(
+    RecordSafepointWithRegistersAndDoubles(
         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
   }
   __ Bind(&not_applicable);
 }
 
 
 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
   Register object = ToRegister(instr->object());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
@@ skipping 216 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