A64: Synchronize with r15545.

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 384 matching lines @@
 
 
 void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
   ASSERT(instr->IsMarkedAsCall());
   ASSERT(ToRegister(instr->constructor()).is(x1));
 
   __ Mov(x0, Operand(instr->arity()));
   __ Mov(x2, Operand(instr->hydrogen()->property_cell()));
 
   ElementsKind kind = instr->hydrogen()->elements_kind();
-  bool disable_allocation_sites =
-      (AllocationSiteInfo::GetMode(kind) == TRACK_ALLOCATION_SITE);
+  AllocationSiteOverrideMode override_mode =
+      (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE)
+          ? DISABLE_ALLOCATION_SITES
+          : DONT_OVERRIDE;
+  ContextCheckMode context_mode = CONTEXT_CHECK_NOT_REQUIRED;
 
   if (instr->arity() == 0) {
-    ArrayNoArgumentConstructorStub stub(kind, disable_allocation_sites);
+    ArrayNoArgumentConstructorStub stub(kind, context_mode, override_mode);
     CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
   } else if (instr->arity() == 1) {
     Label done;
     if (IsFastPackedElementsKind(kind)) {
       Label packed_case;
 
       // We might need to create a holey array; look at the first argument.
       __ Peek(x10, 0);
       __ Cbz(x10, &packed_case);
 
       ElementsKind holey_kind = GetHoleyElementsKind(kind);
-      ArraySingleArgumentConstructorStub stub(holey_kind,
-                                              disable_allocation_sites);
+      ArraySingleArgumentConstructorStub stub(holey_kind, context_mode,
+                                              override_mode);
       CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
       __ B(&done);
       __ Bind(&packed_case);
     }
 
-    ArraySingleArgumentConstructorStub stub(kind, disable_allocation_sites);
+    ArraySingleArgumentConstructorStub stub(kind, context_mode, override_mode);
     CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
     __ Bind(&done);
   } else {
-    ArrayNArgumentsConstructorStub stub(kind, disable_allocation_sites);
+    ArrayNArgumentsConstructorStub stub(kind, context_mode, override_mode);
     CallCode(stub.GetCode(isolate()), RelocInfo::CONSTRUCT_CALL, instr);
   }
 
   ASSERT(ToRegister(instr->result()).is(x0));
 }
 
 
 void LCodeGen::CallRuntime(const Runtime::Function* function,
                            int num_arguments,
                            LInstruction* instr) {
@@ skipping 725 matching lines @@
     branch.Emit(chunk_->GetAssemblyLabel(left_block));
   } else {
     branch.Emit(chunk_->GetAssemblyLabel(left_block));
     __ B(chunk_->GetAssemblyLabel(right_block));
   }
 }
 
 
 template<class InstrType>
 void LCodeGen::EmitBranch(InstrType instr, Condition condition) {
+  ASSERT((condition != al) && (condition != nv));
   BranchOnCondition branch(this, condition);
   EmitBranchGeneric(instr, branch);
 }
 
 
 template<class InstrType>
 void LCodeGen::EmitCompareAndBranch(InstrType instr,
                                     Condition condition,
                                     const Register& lhs,
                                     const Operand& rhs) {
+  ASSERT((condition != al) && (condition != nv));
   CompareAndBranch branch(this, condition, lhs, rhs);
   EmitBranchGeneric(instr, branch);
 }
 
 
 template<class InstrType>
 void LCodeGen::EmitTestAndBranch(InstrType instr,
                                  Condition condition,
                                  const Register& value,
                                  uint64_t mask) {
+  ASSERT((condition != al) && (condition != nv));
   TestAndBranch branch(this, condition, value, mask);
   EmitBranchGeneric(instr, branch);
 }
 
 
 template<class InstrType>
 void LCodeGen::EmitBranchIfNonZeroNumber(InstrType instr,
                                          const FPRegister& value,
                                          const FPRegister& scratch) {
   BranchIfNonZeroNumber branch(this, value, scratch);
@@ skipping 942 matching lines @@
 
 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::DoCmpIDAndBranch(LCmpIDAndBranch* instr) {
+void LCodeGen::DoCompareNumericAndBranch(LCompareNumericAndBranch* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   Condition cond = TokenToCondition(instr->op(), false);
 
   if (left->IsConstantOperand() && right->IsConstantOperand()) {
     // We can statically evaluate the comparison.
     double left_val = ToDouble(LConstantOperand::cast(left));
     double right_val = ToDouble(LConstantOperand::cast(right));
     int next_block = EvalComparison(instr->op(), left_val, right_val) ?
         instr->TrueDestination(chunk_) : instr->FalseDestination(chunk_);
@@ skipping 413 matching lines @@
   // Load the map's "bit field 2" into result.
   ASSERT((Map::kElementsKindBitCount + Map::kElementsKindShift) <= kByteSize);
   __ Ldrb(result.W(), FieldMemOperand(result, Map::kBitField2Offset));
 
   // Retrieve elements_kind from bit field 2.
   __ Ubfx(result.W(), result.W(), Map::kElementsKindShift,
           Map::kElementsKindBitCount);
 }
 
 
-void LCodeGen::DoFixedArrayBaseLength(LFixedArrayBaseLength* instr) {
-  Register result = ToRegister(instr->result());
-  Register array = ToRegister(instr->value());
-  __ Ldr(result, FieldMemOperand(array, FixedArrayBase::kLengthOffset));
-}
-
-
 void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
   // FunctionLiteral instruction is marked as call, we can trash any register.
   ASSERT(instr->IsMarkedAsCall());
 
   // Use the fast case closure allocation code that allocates in new
   // space for nested functions that don't need literals cloning.
   bool pretenure = instr->hydrogen()->pretenure();
   if (!pretenure && instr->hydrogen()->has_no_literals()) {
     FastNewClosureStub stub(instr->hydrogen()->language_mode(),
                             instr->hydrogen()->is_generator());
@@ skipping 375 matching lines @@
 
   // Check the marker in the calling frame.
   __ Bind(&check_frame_marker);
   __ Ldr(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
 
   EmitCompareAndBranch(
       instr, eq, temp1, Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
 }
 
 
+void LCodeGen::DoIsNumberAndBranch(LIsNumberAndBranch* instr) {
+  Representation r = instr->hydrogen()->value()->representation();
+  if (r.IsSmiOrInteger32() || r.IsDouble()) {
+    __ B(instr->TrueLabel(chunk_));
+  } else {
+    ASSERT(r.IsTagged());
+    Register value = ToRegister(instr->value());
+    HType type = instr->hydrogen()->value()->type();
+    if (type.IsTaggedNumber()) {
+      __ B(instr->TrueLabel(chunk_));
+    }
+    __ JumpIfSmi(value, instr->TrueLabel(chunk_));
+    // TODO(jbramley): Add an EmitBranch helper for this.
+    __ JumpForHeapNumber(value, NoReg,
+                         instr->TrueLabel(chunk_), instr->FalseLabel(chunk_));
+  }
+}
+
+
 void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
   Label* is_object = instr->TrueLabel(chunk_);
   Label* is_not_object = instr->FalseLabel(chunk_);
   Register value = ToRegister(instr->value());
   Register map = ToRegister(instr->temp1());
   Register scratch = ToRegister(instr->temp2());
 
   __ JumpIfSmi(value, is_not_object);
   __ JumpIfRoot(value, Heap::kNullValueRootIndex, is_object);
 
@@ skipping 2549 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