A64: Synchronize with r16024.

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 771 matching lines @@
   code->set_stack_slots(GetStackSlotCount());
   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
   if (FLAG_weak_embedded_maps_in_optimized_code) {
     RegisterDependentCodeForEmbeddedMaps(code);
   }
   PopulateDeoptimizationData(code);
   info()->CommitDependencies(code);
 }
 
 
-void LCodeGen::Abort(const char* reason) {
+void LCodeGen::Abort(BailoutReason reason) {
   info()->set_bailout_reason(reason);
   status_ = ABORTED;
 }
 
 
 void LCodeGen::Comment(const char* format, ...) {
   if (!FLAG_code_comments) return;
   char buffer[4 * KB];
   StringBuilder builder(buffer, ARRAY_SIZE(buffer));
   va_list arguments;
@@ skipping 90 matching lines @@
 void LCodeGen::Deoptimize(LEnvironment* environment,
                           Deoptimizer::BailoutType bailout_type) {
   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
   ASSERT(environment->HasBeenRegistered());
   ASSERT(info()->IsOptimizing() || info()->IsStub());
   int id = environment->deoptimization_index();
   Address entry =
       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
 
   if (entry == NULL) {
-    Abort("bailout was not prepared");
+    Abort(kBailoutWasNotPrepared);
     return;
   }
 
   ASSERT(FLAG_deopt_every_n_times < 2);  // Other values not supported on A64.
   if (FLAG_deopt_every_n_times == 1 &&
       !info()->IsStub() &&
       info()->opt_count() == id) {
     ASSERT(frame_is_built_);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     return;
@@ skipping 150 matching lines @@
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     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.");
+      Abort(kToOperandUnsupportedDoubleImmediate);
     }
     ASSERT(r.IsTagged());
     return Operand(constant->handle());
   } else if (op->IsRegister()) {
     return Operand(ToRegister(op));
   } else if (op->IsDoubleRegister()) {
-    Abort("ToOperand IsDoubleRegister unimplemented");
+    Abort(kToOperandIsDoubleRegisterUnimplemented);
     return Operand(0);
   }
   // Stack slots not implemented, use ToMemOperand instead.
   UNREACHABLE();
   return Operand(0);
 }
 
 
 Operand LCodeGen::ToOperand32I(LOperand* op) {
   return ToOperand32(op, SIGNED_INT32);
@@ skipping 13 matching lines @@
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       ASSERT(constant->HasInteger32Value());
       return Operand(signedness == SIGNED_INT32
                      ? constant->Integer32Value()
                      : static_cast<uint32_t>(constant->Integer32Value()));
     } else {
       // Other constants not implemented.
-      Abort("ToOperand32 unsupported immediate.");
+      // TODO(all): Add this error code to objects.h.
+      // Abort(kToOperand32UnsupportedImmediate);
+      Abort(kUnknown);
     }
   }
   // Other cases are not implemented.
   UNREACHABLE();
   return Operand(0);
 }
 
 
 MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
   ASSERT(op != NULL);
@@ skipping 213 matching lines @@
   Register result = ToRegister(instr->result());
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
 
   // Allocate memory for the object.
   AllocationFlags flags = TAG_OBJECT;
   if (instr->hydrogen()->MustAllocateDoubleAligned()) {
     flags = static_cast<AllocationFlags>(flags | DOUBLE_ALIGNMENT);
   }
 
-  if (instr->hydrogen()->CanAllocateInOldPointerSpace()) {
-    ASSERT(!instr->hydrogen()->CanAllocateInOldDataSpace());
+  if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
+    ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
+    ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE);
-  } else if (instr->hydrogen()->CanAllocateInOldDataSpace()) {
+  } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
+    ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_DATA_SPACE);
   }
 
   if (instr->size()->IsConstantOperand()) {
     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
     __ Allocate(size, result, temp1, temp2, deferred->entry(), flags);
   } else {
     Register size = ToRegister(instr->size());
     __ Allocate(size, result, temp1, temp2, deferred->entry(), flags);
   }
@@ skipping 34 matching lines @@
   if (instr->size()->IsConstantOperand()) {
     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
     // Use result as a scratch register.
     __ Mov(result, Operand(Smi::FromInt(size)));
     __ Push(result);
   } else {
     Register size = ToRegister(instr->size());
     __ SmiTag(size);
     __ Push(size);
   }
-  if (instr->hydrogen()->CanAllocateInOldPointerSpace()) {
-    ASSERT(!instr->hydrogen()->CanAllocateInOldDataSpace());
+  if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
+    ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
+    ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     CallRuntimeFromDeferred(Runtime::kAllocateInOldPointerSpace, 1, instr);
-  } else if (instr->hydrogen()->CanAllocateInOldDataSpace()) {
+  } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
+    ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
     CallRuntimeFromDeferred(Runtime::kAllocateInOldDataSpace, 1, instr);
   } else {
     CallRuntimeFromDeferred(Runtime::kAllocateInNewSpace, 1, instr);
   }
   __ StoreToSafepointRegisterSlot(x0, result);
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Register receiver = ToRegister(instr->receiver());
@@ skipping 174 matching lines @@
 
 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");
+    // TODO(all): Add this error code to objects.h.
+    // __ Assert(InvertCondition(cc), kEliminatedBoundsCheckFailed);
+    __ Assert(InvertCondition(cc), kUnknown);
   } else {
     DeoptimizeIf(cc, check->environment());
   }
 }
 
 
 void LCodeGen::DoBoundsCheck(LBoundsCheck *instr) {
   if (instr->hydrogen()->skip_check()) return;
 
   Register length = ToRegister(instr->length());
@@ skipping 179 matching lines @@
   // If necessary, load the function object.
   if (function_reg.IsNone()) {
     function_reg = x1;
     __ LoadHeapObject(function_reg, function);
   }
 
   if (FLAG_debug_code) {
     Label is_not_smi;
     // Try to confirm that function_reg (x1) is a tagged pointer.
     __ JumpIfNotSmi(function_reg, &is_not_smi);
-    __ Abort("In CallKnownFunction, a function object is expected in x1.");
+    // TODO(all): Add this error code to objects.h.
+    // __ Abort(kExpectedFunctionObject);
+    __ Abort(kUnknown);
     __ Bind(&is_not_smi);
   }
 
   if (can_invoke_directly) {
     // Change context.
     __ Ldr(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
 
     // Set the arguments count if adaption is not needed. Assumes that x0 is
     // available to write to at this point.
     if (dont_adapt_arguments) {
@@ skipping 465 matching lines @@
 }
 
 
 void LCodeGen::DoConstantD(LConstantD* instr) {
   ASSERT(instr->result()->IsDoubleRegister());
   DoubleRegister result = ToDoubleRegister(instr->result());
   __ Fmov(result, instr->value());
 }
 
 
+void LCodeGen::DoConstantE(LConstantE* instr) {
+  __ Mov(ToRegister(instr->result()), Operand(instr->value()));
+}
+
+
 void LCodeGen::DoConstantI(LConstantI* instr) {
   __ Mov(ToRegister(instr->result()), instr->value());
 }
 
 
 void LCodeGen::DoConstantS(LConstantS* instr) {
   __ Mov(ToRegister(instr->result()), Operand(instr->value()));
 }
 
 
@@ skipping 791 matching lines @@
           label->hydrogen_value()->id(),
           label->block_id(),
           LabelType(label));
 
   __ Bind(label->label());
   current_block_ = label->block_id();
   DoGap(label);
 }
 
 
-void LCodeGen::DoLinkObjectInList(LLinkObjectInList* instr) {
-  Register object = ToRegister(instr->object());
-  Register temp = ToRegister(instr->temp());
-  ExternalReference sites_list_address = instr->GetReference(isolate());
-
-  __ Mov(temp, Operand(sites_list_address));
-  __ Ldr(temp, MemOperand(temp));
-  __ Str(temp, FieldMemOperand(object,
-                               instr->hydrogen()->store_field().offset()));
-  __ Mov(temp, Operand(sites_list_address));
-  __ Str(object, MemOperand(temp));
-}
-
-
 void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
   Register context = ToRegister(instr->context());
   Register result = ToRegister(instr->result());
   __ Ldr(result, ContextMemOperand(context, instr->slot_index()));
   if (instr->hydrogen()->RequiresHoleCheck()) {
     if (instr->hydrogen()->DeoptimizesOnHole()) {
       DeoptimizeIfRoot(result, Heap::kTheHoleValueRootIndex,
                        instr->environment());
     } else {
       Label not_the_hole;
@@ skipping 121 matching lines @@
   ElementsKind elements_kind = instr->elements_kind();
 
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
   bool key_is_constant = instr->key()->IsConstantOperand();
   Register key = no_reg;
   int constant_key = 0;
   if (key_is_constant) {
     ASSERT(instr->temp() == NULL);
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xf0000000) {
-      Abort("Array index constant value too big.");
+      Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     scratch = ToRegister(instr->temp());
     key = ToRegister(instr->key());
   }
 
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   MemOperand mem_op =
       PrepareKeyedExternalArrayOperand(key, ext_ptr, scratch, key_is_smi,
                                        key_is_constant, constant_key,
@@ skipping 69 matching lines @@
   DoubleRegister result = ToDoubleRegister(instr->result());
   Register load_base;
   int offset = 0;
 
   if (instr->key()->IsConstantOperand()) {
     ASSERT(instr->hydrogen()->RequiresHoleCheck() ||
            (instr->temp() == NULL));
 
     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xf0000000) {
-      Abort("Array index constant value too big.");
+      Abort(kArrayIndexConstantValueTooBig);
     }
     offset = FixedDoubleArray::OffsetOfElementAt(constant_key +
                                                  instr->additional_index());
     load_base = elements;
   } else {
     load_base = ToRegister(instr->temp());
     Register key = ToRegister(instr->key());
     bool key_is_tagged = instr->hydrogen()->key()->representation().IsSmi();
     CalcKeyedArrayBaseRegister(load_base, elements, key, key_is_tagged,
                                instr->hydrogen()->elements_kind());
@@ skipping 55 matching lines @@
 
   ASSERT(ToRegister(instr->result()).Is(x0));
 }
 
 
 void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
   HObjectAccess access = instr->hydrogen()->access();
   int offset = access.offset();
   Register object = ToRegister(instr->object());
 
+  if (access.IsExternalMemory()) {
+    Register result = ToRegister(instr->result());
+    __ Ldr(result, MemOperand(object, offset));
+    return;
+  }
+
   if (instr->hydrogen()->representation().IsDouble()) {
     FPRegister result = ToDoubleRegister(instr->result());
     __ Ldr(result, FieldMemOperand(object, offset));
   } else {
     Register result = ToRegister(instr->result());
     if (access.IsInobject()) {
       __ Ldr(result, FieldMemOperand(object, offset));
     } else {
       __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
       __ Ldr(result, FieldMemOperand(result, offset));
@@ skipping 919 matching lines @@
   __ Bind(&slow);
 
   // Check that the dst register contains new space allocation top, which is a
   // valid address for the GC.
   if (FLAG_debug_code) {
     ExternalReference new_space_allocation_top =
         ExternalReference::new_space_allocation_top_address(isolate());
     __ Mov(scratch1, Operand(new_space_allocation_top));
     __ Ldr(scratch1, MemOperand(scratch1));
     __ Cmp(dst, scratch1);
-    __ Check(eq, "Register dst does not contain allocation top.");
+    // TODO(all): Add this error code to objects.h.
+    // __ Check(eq, kRegisterDstDoesNotContainAllocationTop);
+    __ Check(eq, kUnknown);
   }
 
   {
     // Preserve the value of all registers.
     PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
 
     CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr);
     __ StoreToSafepointRegisterSlot(x0, dst);
   }
 
@@ skipping 134 matching lines @@
 
 
 void LCodeGen::DoParameter(LParameter* instr) {
   // Nothing to do.
 }
 
 
 void LCodeGen::DoPushArgument(LPushArgument* instr) {
   LOperand* argument = instr->value();
   if (argument->IsDoubleRegister() || argument->IsDoubleStackSlot()) {
-    Abort("DoPushArgument not implemented for double types.");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kDoPushArgumentNotImplementedForDoubleTypes);
+    Abort(kUnknown);
   } else {
     __ Push(ToRegister(argument));
   }
 }
 
 
 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.
@@ skipping 44 matching lines @@
   Register value = ToRegister(instr->value());
   Register temp = ToRegister(instr->temp());
 
   if (FLAG_debug_code) {
     __ Ldr(temp, FieldMemOperand(string, HeapObject::kMapOffset));
     __ Ldrb(temp, FieldMemOperand(temp, Map::kInstanceTypeOffset));
     __ And(temp, temp, kStringRepresentationMask | kStringEncodingMask);
 
     if (encoding == String::ONE_BYTE_ENCODING) {
       __ Cmp(temp, kSeqStringTag | kOneByteStringTag);
-      __ Check(eq, "Unexpected string type");
+      __ Check(eq, kUnexpectedStringType);
     } else {
       ASSERT(encoding == String::TWO_BYTE_ENCODING);
       __ Cmp(temp, kSeqStringTag | kTwoByteStringTag);
-      __ Check(eq, "Unexpected string type");
+      __ Check(eq, kUnexpectedStringType);
     }
   }
 
   __ Add(temp, string, SeqString::kHeaderSize - kHeapObjectTag);
   if (encoding == String::ONE_BYTE_ENCODING) {
     __ Strb(value, MemOperand(temp, index));
   } else {
     __ Strh(value, MemOperand(temp, index, LSL, 1));
   }
 }
@@ skipping 232 matching lines @@
   Register scratch;
   ElementsKind elements_kind = instr->elements_kind();
 
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     ASSERT(instr->temp() == NULL);
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xf0000000) {
-      Abort("Array index constant value too big.");
+      Abort(kArrayIndexConstantValueTooBig);
     }
   } else {
     key = ToRegister(instr->key());
     scratch = ToRegister(instr->temp());
   }
 
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
   MemOperand dst =
     PrepareKeyedExternalArrayOperand(key, ext_ptr, scratch, key_is_smi,
                                      key_is_constant, constant_key,
@@ skipping 38 matching lines @@
 
 void LCodeGen::DoStoreKeyedFixedDouble(LStoreKeyedFixedDouble* instr) {
   Register elements = ToRegister(instr->elements());
   DoubleRegister value = ToDoubleRegister(instr->value());
   Register store_base = ToRegister(instr->temp());
   int offset = 0;
 
   if (instr->key()->IsConstantOperand()) {
     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xf0000000) {
-      Abort("Array index constant value too big.");
+      Abort(kArrayIndexConstantValueTooBig);
     }
     offset = FixedDoubleArray::OffsetOfElementAt(constant_key +
                                                  instr->additional_index());
     store_base = elements;
   } else {
     Register key = ToRegister(instr->key());
     bool key_is_tagged = instr->hydrogen()->key()->representation().IsSmi();
     CalcKeyedArrayBaseRegister(store_base, elements, key, key_is_tagged,
                                instr->hydrogen()->elements_kind());
     offset = FixedDoubleArray::OffsetOfElementAt(instr->additional_index());
@@ skipping 61 matching lines @@
 // to tidy up this function.
 void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
   Representation representation = instr->representation();
 
   Register object = ToRegister(instr->object());
   Register temp0 = ToRegister(instr->temp0());
   Register temp1 = ToRegister(instr->temp1());
   HObjectAccess access = instr->hydrogen()->access();
   int offset = access.offset();
 
+  if (access.IsExternalMemory()) {
+    Register value = ToRegister(instr->value());
+    __ Str(value, MemOperand(object, offset));
+    return;
+  }
+
   Handle<Map> transition = instr->transition();
 
   if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
     Register value = ToRegister(instr->value());
     if (!instr->hydrogen()->value()->type().IsHeapObject()) {
       DeoptimizeIfSmi(value, instr->environment());
     }
   } else if (FLAG_track_double_fields && representation.IsDouble()) {
     ASSERT(transition.is_null());
     ASSERT(access.IsInobject());
@@ skipping 178 matching lines @@
   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
   InlineSmiCheckInfo::EmitNotInlined(masm());
 
   Condition condition = TokenToCondition(op, false);
 
   EmitBranch(instr, condition);
 }
 
 
-void LCodeGen::DoStringLength(LStringLength* instr) {
-  Register string = ToRegister(instr->string());
-  Register result = ToRegister(instr->result());
-  __ Ldr(result, FieldMemOperand(string, String::kLengthOffset));
-}
-
-
 void LCodeGen::DoSubI(LSubI* instr) {
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
   Operand right = ToOperand32I(instr->right());
   if (can_overflow) {
     __ Subs(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Sub(result, left, right);
@@ skipping 149 matching lines @@
   __ CopyFields(x0, x1, CPURegList(x10, x11, x12), size / kPointerSize);
 }
 
 
 void LCodeGen::DoThrow(LThrow* instr) {
   Register value = ToRegister(instr->value());
   __ Push(value);
   CallRuntime(Runtime::kThrow, 1, instr);
 
   if (FLAG_debug_code) {
-    __ Abort("Unreachable code in Throw.");
+    __ Unreachable();
   }
 }
 
 
 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();
@@ skipping 246 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