A64: Synchronize with r16024.

src/a64/code-stubs-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 561 matching lines @@
   __ Str(obj_length, FieldMemOperand(context, FixedArray::kLengthOffset));
 
   // If this block context is nested in the native context we get a smi
   // sentinel instead of a function. The block context should get the
   // canonical empty function of the native context as its closure which we
   // still have to look up.
   Label after_sentinel;
   __ JumpIfNotSmi(function, &after_sentinel);
   if (FLAG_debug_code) {
     __ Cmp(function, 0);
-    __ Assert(eq, "Expected 0 as a Smi sentinel");
+    __ Assert(eq, kExpected0AsASmiSentinel);
   }
 
   Register global_ctx = x14;
   __ Ldr(global_ctx, FieldMemOperand(global_obj,
                                      GlobalObject::kNativeContextOffset));
   __ Ldr(function, ContextMemOperand(global_ctx, Context::CLOSURE_INDEX));
   __ Bind(&after_sentinel);
 
   // Store the global object from the previous context, and set up the fixed
   // slots.
@@ skipping 95 matching lines @@
     if (cond == le) {
       __ Mov(result, GREATER);
     } else {
       __ Mov(result, LESS);
     }
     __ Ret();
   }
 
   // No fall through here.
   if (FLAG_debug_code) {
-    __ Abort("We should never reach this code.");
+    __ Unreachable();
   }
 
   __ Bind(&not_identical);
 }
 
 
 // See call site for description.
 static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,
                                            Register left,
                                            Register right,
                                            Register left_type,
                                            Register right_type,
                                            Register scratch) {
   ASSERT(!AreAliased(left, right, left_type, right_type, scratch));
 
   if (masm->emit_debug_code()) {
     // We assume that the arguments are not identical.
     __ Cmp(left, right);
-    __ Assert(ne, "Expected non-identical objects.");
+    __ Assert(ne, kExpectedNonIdenticalObjects);
   }
 
   // If either operand is a JS object or an oddball value, then they are not
   // equal since their pointers are different.
   // There is no test for undetectability in strict equality.
   STATIC_ASSERT(LAST_TYPE == LAST_SPEC_OBJECT_TYPE);
   Label right_non_object;
 
   __ Cmp(right_type, FIRST_SPEC_OBJECT_TYPE);
   __ B(lt, &right_non_object);
@@ skipping 301 matching lines @@
   if (cond == eq) {
     StringCompareStub::GenerateFlatAsciiStringEquals(masm, lhs, rhs,
                                                      x10, x11, x12);
   } else {
     StringCompareStub::GenerateCompareFlatAsciiStrings(masm, lhs, rhs,
                                                        x10, x11, x12, x13);
   }
 
   // Never fall through to here.
   if (FLAG_debug_code) {
-    __ Abort("We should never reach this code.");
+    __ Unreachable();
   }
 
   __ Bind(&slow);
 
   __ Push(lhs, rhs);
   // Figure out which native to call and setup the arguments.
   Builtins::JavaScript native;
   if (cond == eq) {
     native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;
   } else {
@@ skipping 529 matching lines @@
 
   // Code falls through if the result is not returned as either a smi or heap
   // number.
   __ Bind(&right_arg_changed);
   GenerateTypeTransition(masm);
 
   __ Bind(&call_runtime);
 #ifdef DEBUG
   if (masm->emit_debug_code()) {
     __ Cmp(saved_left, x1);
-    __ Assert(eq, "lhs has been clobbered.");
+    __ Assert(eq, kLhsHasBeenClobbered);
     __ Cmp(saved_right, x0);
-    __ Assert(eq, "lhs has been clobbered.");
+    __ Assert(eq, kRhsHasBeenClobbered);
   }
 #endif
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     GenerateRegisterArgsPush(masm);
     GenerateCallRuntime(masm);
   }
   __ Ret();
 }
 
@@ skipping 167 matching lines @@
   ASSERT(!AreAliased(result, heap_number_map, scratch1, scratch2));
 
   if ((mode == OVERWRITE_LEFT) || (mode == OVERWRITE_RIGHT)) {
     Label skip_allocation, allocated;
     Register overwritable_operand = (mode == OVERWRITE_LEFT) ? x1 : x0;
     if (masm->emit_debug_code()) {
       // Check that the overwritable operand is a Smi or a HeapNumber.
       Label ok;
       __ JumpIfSmi(overwritable_operand, &ok);
       __ JumpIfHeapNumber(overwritable_operand, &ok);
-      __ Abort("The overwritable operand should be a HeapNumber");
+      __ Abort(kExpectedSmiOrHeapNumber);
       __ Bind(&ok);
     }
     // If the overwritable operand is already a HeapNumber, we can skip
     // allocation of a heap number.
     __ JumpIfNotSmi(overwritable_operand, &skip_allocation);
     // Allocate a heap number for the result.
     __ AllocateHeapNumber(result, gc_required, scratch1, scratch2,
                           heap_number_map);
     __ B(&allocated);
     __ Bind(&skip_allocation);
@@ skipping 356 matching lines @@
       // A64 simulator does not currently simulate FPCR (where the rounding
       // mode is set), so test the operation with some debug code.
       if (masm->emit_debug_code()) {
         Register temp = masm->Tmp1();
         //  d5  zero_double   The value +0.0 as a double.
         __ Fneg(scratch0_double, zero_double);
         // Verify that we correctly generated +0.0 and -0.0.
         //  bits(+0.0) = 0x0000000000000000
         //  bits(-0.0) = 0x8000000000000000
         __ Fmov(temp, zero_double);
-        __ CheckRegisterIsClear(temp, "Could not generate +0.0.");
+        __ CheckRegisterIsClear(temp, kCouldNotGenerateZero);
         __ Fmov(temp, scratch0_double);
         __ Eor(temp, temp, kDSignMask);
-        __ CheckRegisterIsClear(temp, "Could not generate -0.0.");
+        __ CheckRegisterIsClear(temp, kCouldNotGenerateNegativeZero);
         // Check that -0.0 + 0.0 == +0.0.
         __ Fadd(scratch0_double, scratch0_double, zero_double);
         __ Fmov(temp, scratch0_double);
-        __ CheckRegisterIsClear(temp, "-0.0 + 0.0 did not produce +0.0.");
+        __ CheckRegisterIsClear(temp, kExpectedPositiveZero);
       }
 
       // If base is -INFINITY, make it +INFINITY.
       //  * Calculate base - base: All infinities will become NaNs since both
       //    -INFINITY+INFINITY and +INFINITY-INFINITY are NaN in A64.
       //  * If the result is NaN, calculate abs(base).
       __ Fsub(scratch0_double, base_double, base_double);
       __ Fcmp(scratch0_double, 0.0);
       __ Fabs(scratch1_double, base_double);
       __ Fcsel(base_double, scratch1_double, base_double, vs);
@@ skipping 251 matching lines @@
   Label return_location;
   __ Adr(x12, &return_location);
   __ Poke(x12, 0);
   if (__ emit_debug_code()) {
     // Verify that the slot below fp[kSPOffset]-8 points to the return location
     // (currently in x12).
     Register temp = masm->Tmp1();
     __ Ldr(temp, MemOperand(fp, ExitFrameConstants::kSPOffset));
     __ Ldr(temp, MemOperand(temp, -static_cast<int64_t>(kXRegSizeInBytes)));
     __ Cmp(temp, x12);
-    __ Check(eq, "fp[kSPOffset]-8 does not hold the return address.");
+    __ Check(eq, kReturnAddressNotFoundInFrame);
   }
 
   // Call the builtin.
   __ Blr(target);
   __ Bind(&return_location);
   const Register& result = x0;
 
   if (always_allocate) {
     __ Mov(x10, Operand(scope_depth));
     __ Ldr(x11, MemOperand(x10));
@@ skipping 1304 matching lines @@
   ASSERT(jssp.Is(__ StackPointer()));
   __ Peek(jsregexp_object, kJSRegExpOffset);
   __ JumpIfSmi(jsregexp_object, &runtime);
   __ JumpIfNotObjectType(jsregexp_object, x10, x10, JS_REGEXP_TYPE, &runtime);
 
   // Check that the RegExp has been compiled (data contains a fixed array).
   __ Ldr(regexp_data, FieldMemOperand(jsregexp_object, JSRegExp::kDataOffset));
   if (FLAG_debug_code) {
     STATIC_ASSERT(kSmiTag == 0);
     __ Tst(regexp_data, kSmiTagMask);
-    __ Check(ne, "Unexpected type for RegExp data, FixedArray expected");
+    __ Check(ne, kUnexpectedTypeForRegExpDataFixedArrayExpected);
     __ CompareObjectType(regexp_data, x10, x10, FIXED_ARRAY_TYPE);
-    __ Check(eq, "Unexpected type for RegExp data, FixedArray expected");
+    __ Check(eq, kUnexpectedTypeForRegExpDataFixedArrayExpected);
   }
 
   // Check the type of the RegExp. Only continue if type is JSRegExp::IRREGEXP.
   __ Ldr(x10, FieldMemOperand(regexp_data, JSRegExp::kDataTagOffset));
   __ Cmp(x10, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
   __ B(ne, &runtime);
 
   // Check that the number of captures fit in the static offsets vector buffer.
   // We have always at least one capture for the whole match, plus additional
   // ones due to capturing parentheses. A capture takes 2 registers.
@@ skipping 379 matching lines @@
   __ B(ne, &not_long_external);  // Go to (8).
 
   // (7) External string. Make it, offset-wise, look like a sequential string.
   __ Bind(&external_string);
   if (masm->emit_debug_code()) {
     // Assert that we do not have a cons or slice (indirect strings) here.
     // Sequential strings have already been ruled out.
     __ Ldr(x10, FieldMemOperand(subject, HeapObject::kMapOffset));
     __ Ldrb(x10, FieldMemOperand(x10, Map::kInstanceTypeOffset));
     __ Tst(x10, kIsIndirectStringMask);
-    __ Check(eq, "external string expected, but cons or sliced string found");
+    __ Check(eq, kExternalStringExpectedButNotFound);
     __ And(x10, x10, kStringRepresentationMask);
     __ Cmp(x10, 0);
-    __ Check(ne, "external string expected, but sequential string found");
+    __ Check(ne, kExternalStringExpectedButNotFound);
   }
   __ Ldr(subject,
          FieldMemOperand(subject, ExternalString::kResourceDataOffset));
   // Move the pointer so that offset-wise, it looks like a sequential string.
   STATIC_ASSERT(SeqTwoByteString::kHeaderSize == SeqOneByteString::kHeaderSize);
   __ Sub(subject, subject, SeqTwoByteString::kHeaderSize - kHeapObjectTag);
   __ B(&seq_string);    // Go to (5).
 
   // (8) If this is a short external string or not a string, bail out to
   // runtime.
@@ skipping 352 matching lines @@
                                     result_,
                                     &call_runtime_);
   __ SmiTag(result_);
   __ Bind(&exit_);
 }
 
 
 void StringCharCodeAtGenerator::GenerateSlow(
     MacroAssembler* masm,
     const RuntimeCallHelper& call_helper) {
-  __ Abort("Unexpected fallthrough to CharCodeAt slow case");
+  __ Abort(kUnexpectedFallthroughToCharCodeAtSlowCase);
 
   __ Bind(&index_not_smi_);
   // If index is a heap number, try converting it to an integer.
   __ CheckMap(index_,
               result_,
               Heap::kHeapNumberMapRootIndex,
               index_not_number_,
               DONT_DO_SMI_CHECK);
   call_helper.BeforeCall(masm);
   // Save object_ on the stack and pass index_ as argument for runtime call.
@@ skipping 24 matching lines @@
   // is too complex (e.g., when the string needs to be flattened).
   __ Bind(&call_runtime_);
   call_helper.BeforeCall(masm);
   __ SmiTag(index_);
   __ Push(object_, index_);
   __ CallRuntime(Runtime::kStringCharCodeAt, 2);
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
-  __ Abort("Unexpected fallthrough from CharCodeAt slow case");
+  __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
 }
 
 
 void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
   __ JumpIfNotSmi(code_, &slow_case_);
   __ Cmp(code_, Operand(Smi::FromInt(String::kMaxOneByteCharCode)));
   __ B(hi, &slow_case_);
 
   __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
   // At this point code register contains smi tagged ASCII char code.
   STATIC_ASSERT(kSmiShift > kPointerSizeLog2);
   __ Add(result_, result_, Operand(code_, LSR, kSmiShift - kPointerSizeLog2));
   __ Ldr(result_, FieldMemOperand(result_, FixedArray::kHeaderSize));
   __ JumpIfRoot(result_, Heap::kUndefinedValueRootIndex, &slow_case_);
   __ Bind(&exit_);
 }
 
 
 void StringCharFromCodeGenerator::GenerateSlow(
     MacroAssembler* masm,
     const RuntimeCallHelper& call_helper) {
-  __ Abort("Unexpected fallthrough to CharFromCode slow case");
+  __ Abort(kUnexpectedFallthroughToCharFromCodeSlowCase);
 
   __ Bind(&slow_case_);
   call_helper.BeforeCall(masm);
   __ Push(code_);
   __ CallRuntime(Runtime::kCharFromCode, 1);
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
-  __ Abort("Unexpected fallthrough from CharFromCode slow case");
+  __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
   // Inputs are in x0 (lhs) and x1 (rhs).
   ASSERT(state_ == CompareIC::SMI);
   ASM_LOCATION("ICCompareStub[Smis]");
   Label miss;
   // Bail out (to 'miss') unless both x0 and x1 are smis.
   __ JumpIfEitherNotSmi(x0, x1, &miss);
@@ skipping 518 matching lines @@
     // If entry is undefined no string with this hash can be found.
     Label is_string;
     Register type = scratch;
     __ JumpIfNotObjectType(candidate, type, type, ODDBALL_TYPE, &is_string);
 
     __ Cmp(undefined, candidate);
     __ B(eq, not_found);
     // Must be the hole (deleted entry).
     if (FLAG_debug_code) {
       __ CompareRoot(candidate, Heap::kTheHoleValueRootIndex);
-      __ Assert(eq, "oddball in string table is not undefined or the hole");
+      __ Assert(eq, kOddballInStringTableIsNotUndefinedOrTheHole);
     }
     __ B(&next_probe[i]);
 
     __ Bind(&is_string);
 
     // Check that the candidate is a non-external ASCII string. The instance
     // type is still in the type register from the CompareObjectType
     // operation.
     __ JumpIfInstanceTypeIsNotSequentialAscii(type, type, &next_probe[i]);
 
@@ skipping 1611 matching lines @@
     ElementsKind candidate_kind = GetFastElementsKindFromSequenceIndex(i);
     // TODO(jbramley): Is this the best way to handle this? Can we make the tail
     // calls conditional, rather than hopping over each one?
     __ CompareAndBranch(kind, candidate_kind, ne, &next);
     T stub(candidate_kind);
     __ TailCallStub(&stub);
     __ Bind(&next);
   }
 
   // If we reached this point there is a problem.
-  __ Abort("Unexpected ElementsKind in array constructor");
+  __ Abort(kUnexpectedElementsKindInArrayConstructor);
 }
 
 
 // TODO(jbramley): If this needs to be a special case, make it a proper template
 // specialization, and not a separate function.
 static void CreateArrayDispatchOneArgument(MacroAssembler* masm) {
   // x0 - argc
   // x1 - constructor?
   // x2 - type info cell
   // x3 - kind
@@ skipping 42 matching lines @@
     ElementsKind candidate_kind = GetFastElementsKindFromSequenceIndex(i);
     // TODO(jbramley): Is this the best way to handle this? Can we make the tail
     // calls conditional, rather than hopping over each one?
     __ CompareAndBranch(kind, candidate_kind, ne, &next);
     ArraySingleArgumentConstructorStub stub(candidate_kind);
     __ TailCallStub(&stub);
     __ Bind(&next);
   }
 
   // If we reached this point there is a problem.
-  __ Abort("Unexpected ElementsKind in array constructor");
+  __ Abort(kUnexpectedElementsKindInArrayConstructor);
 }
 
 
 template<class T>
 static void ArrayConstructorStubAheadOfTimeHelper(Isolate* isolate) {
   int to_index = GetSequenceIndexFromFastElementsKind(
       TERMINAL_FAST_ELEMENTS_KIND);
   for (int i = 0; i <= to_index; ++i) {
     ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
     T stub(kind);
@@ skipping 48 matching lines @@
     // builtin Array functions which always have maps.
 
     Label unexpected_map, map_ok;
     // Initial map for the builtin Array function should be a map.
     __ Ldr(x10, FieldMemOperand(constructor,
                                 JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ JumpIfSmi(x10, &unexpected_map);
     __ JumpIfObjectType(x10, x10, x11, MAP_TYPE, &map_ok);
     __ Bind(&unexpected_map);
-    __ Abort("Unexpected initial map for Array function");
+    __ Abort(kUnexpectedInitialMapForArrayFunction);
     __ Bind(&map_ok);
 
     // In type_info_cell, we expect either undefined or a valid Cell.
     Label okay_here;
     Handle<Map> cell_map = masm->isolate()->factory()->cell_map();
     __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &okay_here);
     __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kMapOffset));
     __ Cmp(x10, Operand(cell_map));
-    __ Assert(eq, "Expected property cell in type_info_cell");
+    __ Assert(eq, kExpectedPropertyCellInTypeInfoCell);
     __ Bind(&okay_here);
   }
 
   Register kind = x3;
   Label no_info, switch_ready;
   // Get the elements kind and case on that.
   __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &no_info);
   __ Ldr(kind, FieldMemOperand(type_info_cell, PropertyCell::kValueOffset));
 
   // The type cell may have undefined in its value.
@@ skipping 95 matching lines @@
     // builtin Array functions which always have maps.
 
     Label unexpected_map, map_ok;
     // Initial map for the builtin Array function should be a map.
     __ Ldr(x10, FieldMemOperand(constructor,
                                 JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ JumpIfSmi(x10, &unexpected_map);
     __ JumpIfObjectType(x10, x10, x11, MAP_TYPE, &map_ok);
     __ Bind(&unexpected_map);
-    __ Abort("Unexpected initial map for Array function");
+    __ Abort(kUnexpectedInitialMapForArrayFunction);
     __ Bind(&map_ok);
   }
 
   Register kind = w3;
   // Figure out the right elements kind
   __ Ldr(x10, FieldMemOperand(constructor,
                               JSFunction::kPrototypeOrInitialMapOffset));
 
   // TODO(jbramley): Add a helper function to read elements kind from an
   // existing map.
   // Load the map's "bit field 2" into result.
   __ Ldr(kind, FieldMemOperand(x10, Map::kBitField2Offset));
   // Retrieve elements_kind from bit field 2.
   __ Ubfx(kind, kind, Map::kElementsKindShift, Map::kElementsKindBitCount);
 
   if (FLAG_debug_code) {
     Label done;
     __ Cmp(x3, FAST_ELEMENTS);
     __ Ccmp(x3, FAST_HOLEY_ELEMENTS, ZFlag, ne);
-    __ Assert(eq,
-              "Invalid ElementsKind for InternalArray or InternalPackedArray");
+    __ Assert(eq, kInvalidElementsKindForInternalArrayOrInternalPackedArray);
   }
 
   Label fast_elements_case;
   __ CompareAndBranch(kind, FAST_ELEMENTS, eq, &fast_elements_case);
   GenerateCase(masm, FAST_HOLEY_ELEMENTS);
 
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64