A64: Synchronize with r15922.

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 927 matching lines @@
 }
 
 
 void LCodeGen::Deoptimize(LEnvironment* environment) {
   Deoptimizer::BailoutType bailout_type = info()->IsStub() ? Deoptimizer::LAZY
                                                            : Deoptimizer::EAGER;
   Deoptimize(environment, bailout_type);
 }
 
 
-void LCodeGen::SoftDeoptimize(LEnvironment* environment) {
-  ASSERT(!info()->IsStub());
-  Deoptimize(environment, Deoptimizer::SOFT);
-}
-
-
 void LCodeGen::DeoptimizeIf(Condition cond, LEnvironment* environment) {
   Label dont_deopt;
   __ B(InvertCondition(cond), &dont_deopt);
   Deoptimize(environment);
   __ Bind(&dont_deopt);
 }
 
 
 void LCodeGen::DeoptimizeIfZero(Register rt, LEnvironment* environment) {
   Label dont_deopt;
@@ skipping 99 matching lines @@
   return DoubleRegister::FromAllocationIndex(op->index());
 }
 
 
 Operand LCodeGen::ToOperand(LOperand* op) {
   ASSERT(op != NULL);
   if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
-    if (r.IsInteger32()) {
+    if (r.IsSmi()) {
+      ASSERT(constant->HasSmiValue());
+      return Operand(Smi::FromInt(constant->Integer32Value()));
+    } else if (r.IsInteger32()) {
       ASSERT(constant->HasInteger32Value());
       return Operand(constant->Integer32Value());
     } else if (r.IsDouble()) {
       Abort("ToOperand unsupported double immediate.");
     }
     ASSERT(r.IsTagged());
     return Operand(constant->handle());
   } else if (op->IsRegister()) {
     return Operand(ToRegister(op));
   } else if (op->IsDoubleRegister()) {
@@ skipping 209 matching lines @@
   Operand right = ToOperand32(instr->right());
   if (can_overflow) {
     __ Adds(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Add(result, left, right);
   }
 }
 
 
+void LCodeGen::DoAddS(LAddS* instr) {
+  bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+  Register result = ToRegister(instr->result());
+  Register left = ToRegister(instr->left());
+  Operand right = ToOperand(instr->right());
+  if (can_overflow) {
+    __ Adds(result, left, right);
+    DeoptimizeIf(vs, instr->environment());
+  } else {
+    __ Add(result, left, right);
+  }
+}
+
+
 void LCodeGen::DoAllocate(LAllocate* instr) {
   class DeferredAllocate: public LDeferredCode {
    public:
     DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredAllocate(instr_); }
     virtual LInstruction* instr() { return instr_; }
    private:
     LAllocate* instr_;
   };
@@ skipping 219 matching lines @@
   ASSERT(ToRegister(instr->left()).is(x1));
   ASSERT(ToRegister(instr->right()).is(x0));
   ASSERT(ToRegister(instr->result()).is(x0));
 
   BinaryOpStub stub(instr->op(), NO_OVERWRITE);
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
 }
 
 
 void LCodeGen::DoBitI(LBitI* instr) {
-  LOperand* left_op = instr->left();
-  LOperand* right_op = instr->right();
-  Register left = ToRegister(left_op);
-  Register result = ToRegister(instr->result());
-
-  ASSERT(right_op->IsRegister() || right_op->IsConstantOperand());
-  Operand right = ToOperand(right_op);
+  Register result = ToRegister32(instr->result());
+  Register left = ToRegister32(instr->left());
+  Operand right = ToOperand32(instr->right());
 
   switch (instr->op()) {
     case Token::BIT_AND: __ And(result, left, right); break;
+    case Token::BIT_OR:  __ Orr(result, left, right); break;
+    case Token::BIT_XOR: __ Eor(result, left, right); break;
+    default:
+      UNREACHABLE();
+      break;
+  }
+}
+
+
+void LCodeGen::DoBitS(LBitS* instr) {
+  Register result = ToRegister(instr->result());
+  Register left = ToRegister(instr->left());
+  Operand right = ToOperand(instr->right());
+
+  switch (instr->op()) {
+    case Token::BIT_AND: __ And(result, left, right); break;
     case Token::BIT_OR:  __ Orr(result, left, right); break;
     case Token::BIT_XOR: __ Eor(result, left, right); break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void LCodeGen::DoBitNotI(LBitNotI* instr) {
   Register input = ToRegister(instr->value()).W();
   Register result = ToRegister(instr->result()).W();
   __ Mvn(result, input);
 }
 
 
+void LCodeGen::ApplyCheckIf(Condition cc, LBoundsCheck* check) {
+  if (FLAG_debug_code && check->hydrogen()->skip_check()) {
+    __ Assert(InvertCondition(cc), "eliminated bounds check failed");
+  } else {
+    DeoptimizeIf(cc, check->environment());
+  }
+}
+
+
 void LCodeGen::DoBoundsCheck(LBoundsCheck *instr) {
   if (instr->hydrogen()->skip_check()) return;
 
   Register length = ToRegister(instr->length());
 
   if (instr->index()->IsConstantOperand()) {
     int constant_index =
         ToInteger32(LConstantOperand::cast(instr->index()));
 
     if (instr->hydrogen()->length()->representation().IsSmi()) {
       __ Cmp(length, Operand(Smi::FromInt(constant_index)));
     } else {
       __ Cmp(length, Operand(constant_index));
     }
   } else {
     __ Cmp(length, ToRegister(instr->index()));
   }
-  DeoptimizeIf(ls, instr->environment());
+  Condition condition = instr->hydrogen()->allow_equality() ? lo : ls;
+  ApplyCheckIf(condition, instr);
 }
 
 
 void LCodeGen::DoBranch(LBranch* instr) {
   Representation r = instr->hydrogen()->value()->representation();
   Label* true_label = instr->TrueLabel(chunk_);
   Label* false_label = instr->FalseLabel(chunk_);
 
   if (r.IsInteger32()) {
     ASSERT(!info()->IsStub());
@@ skipping 298 matching lines @@
 }
 
 
 void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
   // Record the address of the first unknown OSR value as the place to enter.
   if (osr_pc_offset_ == -1) osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
+  if (instr->hydrogen()->CanOmitMapChecks()) {
+    ASSERT(instr->temp() == NULL);
+    return;
+  }
+
   Register object = ToRegister(instr->value());
   Register map_reg = ToRegister(instr->temp());
 
   Label success;
   SmallMapList* map_set = instr->hydrogen()->map_set();
   __ Ldr(map_reg, FieldMemOperand(object, HeapObject::kMapOffset));
   for (int i = 0; i < map_set->length(); i++) {
     Handle<Map> map = map_set->at(i);
     __ CompareMap(map_reg, map, &success);
     __ B(eq, &success);
@@ skipping 10 matching lines @@
   if (!instr->hydrogen()->value()->IsHeapObject()) {
     // TODO(all): Depending of how we chose to implement the deopt, if we could
     // guarantee that we have a deopt handler reachable by a tbz instruction,
     // we could use tbz here and produce less code to support this instruction.
     DeoptimizeIfSmi(ToRegister(instr->value()), instr->environment());
   }
 }
 
 
 void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) {
+  if (instr->hydrogen()->CanOmitPrototypeChecks()) {
+    ASSERT(instr->temp1() == NULL);
+    ASSERT(instr->temp2() == NULL);
+    return;
+  }
+
   ZoneList<Handle<JSObject> >* prototypes = instr->prototypes();
   ZoneList<Handle<Map> >* maps = instr->maps();
   ASSERT(prototypes->length() == maps->length());
 
-  if (!instr->hydrogen()->CanOmitPrototypeChecks()) {
-    // TODO(jbramley): The temp registers are only needed in this case.
-    Label success, deopt;
-    Register temp1 = ToRegister(instr->temp1());
-    Register temp2 = ToRegister(instr->temp2());
-    for (int i = 0; i < prototypes->length(); i++) {
-      __ LoadHeapObject(temp1, prototypes->at(i));
-      __ Ldr(temp2, FieldMemOperand(temp1, HeapObject::kMapOffset));
-      __ CompareMap(temp2, maps->at(i), &success);
-      __ B(eq, &success);
-    }
-    // If we didn't match a map, deoptimize.
-    Deoptimize(instr->environment());
-    __ Bind(&success);
+  Label success, deopt;
+  Register temp1 = ToRegister(instr->temp1());
+  Register temp2 = ToRegister(instr->temp2());
+  for (int i = 0; i < prototypes->length(); i++) {
+    __ LoadHeapObject(temp1, prototypes->at(i));
+    __ Ldr(temp2, FieldMemOperand(temp1, HeapObject::kMapOffset));
+    __ CompareMap(temp2, maps->at(i), &success);
+    __ B(eq, &success);
   }
+  // If we didn't match a map, deoptimize.
+  Deoptimize(instr->environment());
+  __ Bind(&success);
 }
 
 
 void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
   Register value = ToRegister(instr->value());
   ASSERT(ToRegister(instr->result()).Is(value));
   // TODO(all): See DoCheckNonSmi for comments on use of tbz.
   DeoptimizeIfNotSmi(value, instr->environment());
 }
 
@@ skipping 278 matching lines @@
 
 
 void LCodeGen::DoConstantS(LConstantS* instr) {
   __ Mov(ToRegister(instr->result()), Operand(instr->value()));
 }
 
 
 void LCodeGen::DoConstantT(LConstantT* instr) {
   Handle<Object> value = instr->value();
   AllowDeferredHandleDereference smi_check;
-  if (value->IsSmi()) {
-    __ Mov(ToRegister(instr->result()), Operand(value));
-  } else {
-    __ LoadHeapObject(ToRegister(instr->result()),
-                      Handle<HeapObject>::cast(value));
-  }
+  __ LoadObject(ToRegister(instr->result()), value);
 }
 
 
 void LCodeGen::DoContext(LContext* instr) {
   // If there is a non-return use, the context must be moved to a register.
   Register result = ToRegister(instr->result());
   // TODO(jbramley): LContext is only generated if it meets this condition, so
   // why not move cp unconditionally?
   for (HUseIterator it(instr->hydrogen()->uses()); !it.Done(); it.Advance()) {
     if (!it.value()->IsReturn()) {
@@ skipping 68 matching lines @@
     __ Bind(&runtime);
     __ Mov(x1, Operand(index));
     __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
   }
 
   __ Bind(&done);
 }
 
 
 void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
-  if (instr->hydrogen_value()->IsSoftDeoptimize()) {
-    SoftDeoptimize(instr->environment());
-  } else {
-    Deoptimize(instr->environment());
+  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;
   }
+  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);
   bool bailout_on_minus_zero =
@@ skipping 1037 matching lines @@
     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.IsConstantFunction()) {
-    Handle<JSFunction> function(lookup.GetConstantFunctionFromMap(*type));
-    __ LoadHeapObject(result, function);
+  } 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()));
@@ skipping 545 matching lines @@
 
 void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
   HMathMinMax::Operation op = instr->hydrogen()->operation();
   if (instr->hydrogen()->representation().IsInteger32()) {
     Register result = ToRegister32(instr->result());
     Register left = ToRegister32(instr->left());
     Operand right = ToOperand32(instr->right());
 
     __ Cmp(left, right);
     __ Csel(result, left, right, (op == HMathMinMax::kMathMax) ? ge : le);
+  } else if (instr->hydrogen()->representation().IsSmi()) {
+    Register result = ToRegister(instr->result());
+    Register left = ToRegister(instr->left());
+    Operand right = ToOperand(instr->right());
+
+    __ Cmp(left, right);
+    __ Csel(result, left, right, (op == HMathMinMax::kMathMax) ? ge : le);
   } else {
     ASSERT(instr->hydrogen()->representation().IsDouble());
     DoubleRegister result = ToDoubleRegister(instr->result());
     DoubleRegister left = ToDoubleRegister(instr->left());
     DoubleRegister right = ToDoubleRegister(instr->right());
 
     if (op == HMathMinMax::kMathMax) {
       __ Fmax(result, left, right);
     } else {
       ASSERT(op == HMathMinMax::kMathMin);
@@ skipping 55 matching lines @@
       } else {
         DeoptimizeIfNegative(dividend, instr->environment());
       }
     }
   }
   __ Bind(&done);
 }
 
 
 void LCodeGen::DoMulConstI(LMulConstI* instr) {
+  // TODO(jbramley): Support smi operations (or make a separate DoMulConstS).
+
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
   int32_t right = ToInteger32(instr->right());
 
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   bool bailout_on_minus_zero =
     instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
 
   if (bailout_on_minus_zero) {
     if (right < 0) {
@@ skipping 72 matching lines @@
         }
       }
       break;
   }
 }
 
 
 void LCodeGen::DoMulI(LMulI* instr) {
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
+  Register right = ToRegister32(instr->right());
 
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   bool bailout_on_minus_zero =
     instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
 
-  Register right = ToRegister32(instr->right());
   if (bailout_on_minus_zero) {
     // If one operand is zero and the other is negative, the result is -0.
     //  - Set Z (eq) if either left or right, or both, are 0.
     __ Cmp(left, 0);
     __ Ccmp(right, 0, ZFlag, ne);
     //  - If so (eq), set N (mi) if left + right is negative.
     //  - Otherwise, clear N.
     __ Ccmn(left, right, NoFlag, eq);
     DeoptimizeIf(mi, instr->environment());
   }
 
   if (can_overflow) {
     __ Smull(result.X(), left, right);
     __ Cmp(result.X(), Operand(result, SXTW));
     DeoptimizeIf(ne, instr->environment());
   } else {
     __ Mul(result, left, right);
   }
 }
 
 
+void LCodeGen::DoMulS(LMulS* instr) {
+  Register result = ToRegister(instr->result());
+  Register left = ToRegister(instr->left());
+  Register right = ToRegister(instr->right());
+
+  bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+  bool bailout_on_minus_zero =
+    instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
+
+  if (bailout_on_minus_zero) {
+    // If one operand is zero and the other is negative, the result is -0.
+    //  - Set Z (eq) if either left or right, or both, are 0.
+    __ Cmp(left, 0);
+    __ Ccmp(right, 0, ZFlag, ne);
+    //  - If so (eq), set N (mi) if left + right is negative.
+    //  - Otherwise, clear N.
+    __ Ccmn(left, right, NoFlag, eq);
+    DeoptimizeIf(mi, instr->environment());
+  }
+
+  STATIC_ASSERT((kSmiShift == 32) && (kSmiTag == 0));
+  if (can_overflow) {
+    __ Smulh(result, left, right);
+    __ Cmp(result, Operand(result.W(), SXTW));
+    __ SmiTag(result);
+    DeoptimizeIf(ne, instr->environment());
+  } else {
+    // TODO(jbramley): This could be rewritten to support UseRegisterAtStart.
+    ASSERT(!AreAliased(result, right));
+    __ SmiUntag(result, left);
+    __ Mul(result, result, right);
+  }
+}
+
+
 void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
   // TODO(3095996): Get rid of this. For now, we need to make the
   // result register contain a valid pointer because it is already
   // contained in the register pointer map.
   Register result = ToRegister(instr->result());
   __ Mov(result, 0);
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
   CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr);
   __ StoreToSafepointRegisterSlot(x0, result);
@@ skipping 1083 matching lines @@
   CallRuntime(Runtime::kThrow, 1, instr);
 
   if (FLAG_debug_code) {
     __ Abort("Unreachable code in Throw.");
   }
 }
 
 
 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
   Register object = ToRegister(instr->object());
+  Register temp1 = ToRegister(instr->temp1());
 
   Handle<Map> from_map = instr->original_map();
   Handle<Map> to_map = instr->transitioned_map();
   ElementsKind from_kind = instr->from_kind();
   ElementsKind to_kind = instr->to_kind();
 
-  Register scratch;
-  if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
-    scratch = ToRegister(instr->temp1());
-  } else {
-    ASSERT(FLAG_compiled_transitions || instr->IsMarkedAsCall());
-    scratch = x10;
-  }
-
   Label not_applicable;
-  __ CompareMap(object, scratch, from_map);
-  __ B(ne, &not_applicable);
+  __ 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, scratch,
+    __ RecordWriteField(object, HeapObject::kMapOffset, new_map, temp1,
                         GetLinkRegisterState(), kDontSaveFPRegs);
-  } else if (FLAG_compiled_transitions) {
+  } else {
     PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
     __ Mov(x0, object);
     __ Mov(x1, Operand(to_map));
     TransitionElementsKindStub stub(from_kind, to_kind);
     __ CallStub(&stub);
     RecordSafepointWithRegisters(
         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
-  } else if ((IsFastSmiElementsKind(from_kind) &&
-              IsFastDoubleElementsKind(to_kind)) ||
-             (IsFastDoubleElementsKind(from_kind) &&
-              IsFastObjectElementsKind(to_kind))) {
-    ASSERT((instr->temp1() == NULL) && (instr->temp2() == NULL));
-    __ Mov(x2, object);
-    __ Mov(x3, Operand(to_map));
-    if (IsFastSmiElementsKind(from_kind)) {
-      CallCode(isolate()->builtins()->TransitionElementsSmiToDouble(),
-               RelocInfo::CODE_TARGET, instr);
-    } else if (IsFastDoubleElementsKind(from_kind)) {
-      CallCode(isolate()->builtins()->TransitionElementsDoubleToObject(),
-               RelocInfo::CODE_TARGET, instr);
-    }
-  } else {
-    UNREACHABLE();
   }
   __ Bind(&not_applicable);
 }
 
 
 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
   Register object = ToRegister(instr->object());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
   __ TestJSArrayForAllocationMemento(object, temp1, temp2);
@@ skipping 215 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