A64: Synchronize with r16024.

src/a64/macro-assembler-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 747 matching lines @@
     ASSERT((count * size) % 16 == 0);
   }
 }
 
 
 void MacroAssembler::Poke(const CPURegister& src, const Operand& offset) {
   if (offset.IsImmediate()) {
     ASSERT(offset.immediate() >= 0);
   } else if (emit_debug_code()) {
     Cmp(xzr, offset);
-    Check(le, "Poke offset is negative.");
+    Check(le, kStackAccessBelowStackPointer);
   }
 
   Str(src, MemOperand(StackPointer(), offset));
 }
 
 
 void MacroAssembler::Peek(const CPURegister& dst, const Operand& offset) {
   if (offset.IsImmediate()) {
     ASSERT(offset.immediate() >= 0);
   } else if (emit_debug_code()) {
     Cmp(xzr, offset);
-    Check(le, "Peek offset is negative.");
+    Check(le, kStackAccessBelowStackPointer);
   }
 
   Ldr(dst, MemOperand(StackPointer(), offset));
 }
 
 
 void MacroAssembler::PushCalleeSavedRegisters() {
   // Ensure that the macro-assembler doesn't use any scratch registers.
   InstructionAccurateScope scope(this);
 
@@ skipping 43 matching lines @@
 
 void MacroAssembler::AssertStackConsistency() {
   if (emit_debug_code() && !csp.Is(StackPointer())) {
     if (csp.Is(StackPointer())) {
       // TODO(jbramley): Check for csp alignment if it is the stack pointer.
     } else {
       // TODO(jbramley): Currently we cannot use this assertion in Push because
       // some calling code assumes that the flags are preserved. For an example,
       // look at Builtins::Generate_ArgumentsAdaptorTrampoline.
       Cmp(csp, StackPointer());
-      Check(ls, "The current stack pointer is below csp.");
+      Check(ls, kTheCurrentStackPointerIsBelowCsp);
     }
   }
 }
 
 
 void MacroAssembler::LoadRoot(Register destination,
                               Heap::RootListIndex index) {
   // TODO(jbramley): Most root values are constants, and can be synthesized
   // without a load. Refer to the ARM back end for details.
   Ldr(destination, MemOperand(root, index << kPointerSizeLog2));
@@ skipping 20 matching lines @@
   if (isolate()->heap()->InNewSpace(*object)) {
     Handle<Cell> cell = isolate()->factory()->NewCell(object);
     Mov(result, Operand(cell));
     Ldr(result, FieldMemOperand(result, Cell::kValueOffset));
   } else {
     Mov(result, Operand(object));
   }
 }
 
 
-void MacroAssembler::CheckForInvalidValuesInCalleeSavedRegs(RegList list) {
-  if (emit_debug_code()) {
-    // Only check for callee-saved registers.
-    // TODO(jbramley): Why? We still don't want caller-saved registers to be
-    // pushed with invalid values. Perhaps we need a
-    // CheckForInvalidValuesInRegs for other cases.
-    Label invalid, ok;
-    list &= kJSCalleeSavedRegList;
-    for (unsigned i = kFirstCalleeSavedRegisterIndex; list != 0; i++) {
-      if (list & (1 << i)) {
-        // Clear the current register from the list.
-        list &= ~(1 << i);
-        Register current = Register(i, kXRegSize);
-        Label smi;
-        JumpIfSmi(current, &smi);
-        // TODO(all): Better check for invalid values in callee-saved registers.
-        // Check that the register is not in [0, 4 KB].
-        // This catches odd (untagged) integers.
-        // We should actually check that the pointer is valid.
-        Cmp(current, 4 * KB);
-        B(hs, &invalid);
-        Bind(&smi);
-      }
-    }
-    B(&ok);
-    Bind(&invalid);
-    Abort("Invalid value in a callee saved register.");
-    Bind(&ok);
-  }
-}
-
-
 void MacroAssembler::LoadInstanceDescriptors(Register map,
                                              Register descriptors) {
   Ldr(descriptors, FieldMemOperand(map, Map::kDescriptorsOffset));
 }
 
 
 void MacroAssembler::NumberOfOwnDescriptors(Register dst, Register map) {
   Ldr(dst, FieldMemOperand(map, Map::kBitField3Offset));
   DecodeField<Map::NumberOfOwnDescriptorsBits>(dst);
 }
@@ skipping 235 matching lines @@
   __ Eor(scratch, smi, Operand(smi, ASR, kXRegSize - 1));
   // Add 1 or do nothing depending on the sign of the argument.
   __ Adds(smi, scratch, Operand(smi, LSR, kXRegSize - 1));
 
   // If the result is still negative, go to the slow case.
   // This only happens for the most negative smi.
   __ B(mi, slow);
 }
 
 
-void MacroAssembler::AssertSmi(Register object, char const* fail_message) {
+void MacroAssembler::AssertSmi(Register object, BailoutReason reason) {
   if (emit_debug_code()) {
     STATIC_ASSERT(kSmiTag == 0);
     Tst(object, kSmiTagMask);
-    Check(eq, fail_message);
+    Check(eq, reason);
   }
 }
 
 
-void MacroAssembler::AssertNotSmi(Register object, char const* fail_message) {
+void MacroAssembler::AssertNotSmi(Register object, BailoutReason reason) {
   if (emit_debug_code()) {
     STATIC_ASSERT(kSmiTag == 0);
     Tst(object, kSmiTagMask);
-    Check(ne, fail_message);
+    Check(ne, reason);
   }
 }
 
 
 void MacroAssembler::AssertName(Register object) {
   if (emit_debug_code()) {
     STATIC_ASSERT(kSmiTag == 0);
     // TODO(jbramley): Add AbortIfSmi and related functions.
     Label not_smi;
     JumpIfNotSmi(object, &not_smi);
-    Abort("Operand is a smi and not a name");
+    Abort(kOperandIsASmiAndNotAName);
     Bind(&not_smi);
 
     Ldr(Tmp1(), FieldMemOperand(object, HeapObject::kMapOffset));
     CompareInstanceType(Tmp1(), Tmp1(), LAST_NAME_TYPE);
-    Check(ls, "Operand is not a name");
+    Check(ls, kOperandIsNotAName);
   }
 }
 
 
 void MacroAssembler::AssertString(Register object) {
   if (emit_debug_code()) {
     Register temp = Tmp1();
     STATIC_ASSERT(kSmiTag == 0);
     Tst(object, kSmiTagMask);
-    Check(ne, "Operand is a smi and not a string");
+    Check(ne, kOperandIsASmiAndNotAString);
     Ldr(temp, FieldMemOperand(object, HeapObject::kMapOffset));
     CompareInstanceType(temp, temp, FIRST_NONSTRING_TYPE);
-    Check(lo, "Operand is not a string");
+    Check(lo, kOperandIsNotAString);
   }
 }
 
-
-void MacroAssembler::AssertRootValue(Register src,
-                                     Heap::RootListIndex root_value_index,
-                                     const char* message) {
-  if (emit_debug_code()) {
-    CompareRoot(src, root_value_index);
-    Check(eq, message);
-  }
-}
-
 
 void MacroAssembler::CallStub(CodeStub* stub, TypeFeedbackId ast_id) {
   ASSERT(AllowThisStubCall(stub));  // Stub calls are not allowed in some stubs.
   Call(stub->GetCode(isolate()), RelocInfo::CODE_TARGET, ast_id);
 }
 
 
 void MacroAssembler::TailCallStub(CodeStub* stub) {
   ASSERT(allow_stub_calls_ ||
          stub->CompilingCallsToThisStubIsGCSafe(isolate()));
@@ skipping 148 matching lines @@
   }
   // load value from ReturnValue
   Ldr(x0, MemOperand(fp, return_value_offset_from_fp * kPointerSize));
   Bind(&return_value_loaded);
   // No more valid handles (the result handle was the last one). Restore
   // previous handle scope.
   Str(next_address_reg, MemOperand(handle_scope_base, kNextOffset));
   if (emit_debug_code()) {
     Ldr(w1, MemOperand(handle_scope_base, kLevelOffset));
     Cmp(w1, level_reg);
-    Check(eq, "Unexpected level after return from api call");
+    Check(eq, kUnexpectedLevelAfterReturnFromApiCall);
   }
   Sub(level_reg, level_reg, 1);
   Str(level_reg, MemOperand(handle_scope_base, kLevelOffset));
   Ldr(x1, MemOperand(handle_scope_base, kLimitOffset));
   Cmp(limit_reg, x1);
   B(ne, &delete_allocated_handles);
 
   Bind(&leave_exit_frame);
   // Restore callee-saved registers.
   Peek(x19, (spill_offset + 0) * kXRegSizeInBytes);
@@ skipping 203 matching lines @@
     if (emit_debug_code()) {
       // Because the stack pointer must be aligned on a 16-byte boundary, the
       // aligned csp can be up to 12 bytes below the jssp. This is the case
       // where we only pushed one W register on top of an aligned jssp.
       Register temp = Tmp1();
       ASSERT(ActivationFrameAlignment() == 16);
       Sub(temp, csp, old_stack_pointer);
       // We want temp <= 0 && temp >= -12.
       Cmp(temp, 0);
       Ccmp(temp, -12, NFlag, le);
-      Check(ge, "The stack was corrupted by MacroAssembler::Call().");
+      Check(ge, kTheStackWasCorruptedByMacroAssemblerCall);
     }
     SetStackPointer(old_stack_pointer);
   }
 }
 
 
 void MacroAssembler::Jump(Register target) {
   Br(target);
 }
 
@@ skipping 376 matching lines @@
   // handled separately.
   ASSERT(!temps.IncludesAliasOf(dst));
   ASSERT(!temps.IncludesAliasOf(src));
   ASSERT(!temps.IncludesAliasOf(Tmp0()));
   ASSERT(!temps.IncludesAliasOf(Tmp1()));
   ASSERT(!temps.IncludesAliasOf(xzr));
   ASSERT(!AreAliased(dst, src, Tmp0(), Tmp1()));
 
   if (emit_debug_code()) {
     Cmp(dst, src);
-    Check(ne, "In CopyFields, the destination is the same as the source.");
+    Check(ne, kTheSourceAndDestinationAreTheSame);
   }
 
   // The value of 'count' at which a loop will be generated (if there are
   // enough scratch registers).
   static const unsigned kLoopThreshold = 8;
 
   ASSERT(!temps.IsEmpty());
   Register scratch1 = Register(temps.PopLowestIndex());
   Register scratch2 = Register(temps.PopLowestIndex());
   Register scratch3 = Register(temps.PopLowestIndex());
@@ skipping 15 matching lines @@
                                Register length,
                                Register scratch,
                                CopyHint hint) {
   ASSERT(!AreAliased(src, dst, length, scratch));
 
   // TODO(all): Implement a faster copy function, and use hint to determine
   // which algorithm to use for copies.
   if (emit_debug_code()) {
     // Check copy length.
     Cmp(length, 0);
-    Assert(ge, "Copy length < 0");
+    // TODO(all): Add this error code to objects.h.
+    // Assert(ge, kCopyLengthIsBelowZero);
+    Assert(ge, kUnknown);
 
     // Check src and dst buffers don't overlap.
     Add(scratch, src, length);  // Calculate end of src buffer.
     Cmp(scratch, dst);
     Add(scratch, dst, length);  // Calculate end of dst buffer.
     Ccmp(scratch, src, ZFlag, gt);
-    Assert(le, "CopyBytes src and dst buffers overlap");
+    // TODO(all): Add this error code to objects.h.
+    // Assert(le, kCopyBytesSrcAndDstBuffersOverlap);
+    Assert(le, kUnknown);
   }
 
   Label loop, done;
   Cbz(length, &done);
 
   Bind(&loop);
   Sub(length, length, 1);
   Ldrb(scratch, MemOperand(src, 1, PostIndex));
   Strb(scratch, MemOperand(dst, 1, PostIndex));
   Cbnz(length, &loop);
@@ skipping 22 matching lines @@
     Register scratch2,
     Label* failure,
     SmiCheckType smi_check) {
 
   if (smi_check == DO_SMI_CHECK) {
     JumpIfEitherSmi(first, second, failure);
   } else if (emit_debug_code()) {
     ASSERT(smi_check == DONT_DO_SMI_CHECK);
     Label not_smi;
     JumpIfEitherSmi(first, second, NULL, &not_smi);
-    Abort("At least one input is a smi.");
+
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kAtLeastOneInputIsASmi);
+    Abort(kUnknown);
+
     Bind(&not_smi);
   }
 
   // Test that both first and second are sequential ASCII strings.
   Ldr(scratch1, FieldMemOperand(first, HeapObject::kMapOffset));
   Ldr(scratch2, FieldMemOperand(second, HeapObject::kMapOffset));
   Ldrb(scratch1, FieldMemOperand(scratch1, Map::kInstanceTypeOffset));
   Ldrb(scratch2, FieldMemOperand(scratch2, Map::kInstanceTypeOffset));
 
   JumpIfEitherInstanceTypeIsNotSequentialAscii(scratch1,
@@ skipping 436 matching lines @@
   Cmp(exponent, HeapNumber::kExponentBias + HeapNumber::kMantissaBits + 32);
   CzeroX(result, ge);
   B(ge, &done);
 
   // The Fcvtzs sequence handles all cases except where the conversion causes
   // signed overflow in the int64_t target. Since we've already handled
   // exponents >= 84, we can guarantee that 63 <= exponent < 84.
 
   if (emit_debug_code()) {
     Cmp(exponent, HeapNumber::kExponentBias + 63);
-    Check(ge, "This input should have been handled by the FPU.");
+    // TODO(all): Add this error code to objects.h.
+    // Check(ge, kThisInputShouldHaveBeenHandledByTheFPU);
+    Check(ge, kUnknown);
   }
 
   // Isolate the mantissa bits, and set the implicit '1'.
   Register mantissa = scratch2;
   Ubfx(mantissa, result, 0, HeapNumber::kMantissaBits);
   Orr(mantissa, mantissa, 1UL << HeapNumber::kMantissaBits);
 
   // Negate the mantissa if necessary.
   Tst(result, kXSignMask);
   Cneg(mantissa, mantissa, ne);
@@ skipping 28 matching lines @@
 void MacroAssembler::HeapNumberECMA262ToInt32(Register result,
                                               Register heap_number,
                                               Register scratch1,
                                               Register scratch2,
                                               DoubleRegister double_scratch,
                                               ECMA262ToInt32Result format) {
   if (emit_debug_code()) {
     // Verify we indeed have a HeapNumber.
     Label ok;
     JumpIfHeapNumber(heap_number, &ok);
-    Abort("A HeapNumber is expected as input.");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kExpectedHeapNumber);
+    Abort(kUnknown);
     Bind(&ok);
   }
 
   Ldr(double_scratch, FieldMemOperand(heap_number, HeapNumber::kValueOffset));
   ECMA262ToInt32(result, double_scratch, scratch1, scratch2, format);
 }
 
 
 void MacroAssembler::EnterFrame(StackFrame::Type type) {
   ASSERT(jssp.Is(StackPointer()));
@@ skipping 294 matching lines @@
   Mov(top_address, Operand(heap_allocation_top));
 
   if ((flags & RESULT_CONTAINS_TOP) == 0) {
     // Load allocation top into result and the allocation limit.
     Ldp(result, allocation_limit, MemOperand(top_address));
   } else {
     if (emit_debug_code()) {
       // Assert that result actually contains top on entry.
       Ldr(Tmp0(), MemOperand(top_address));
       Cmp(result, Tmp0());
-      Check(eq, "Unexpected allocation top.");
+      Check(eq, kUnexpectedAllocationTop);
     }
     // Load the allocation limit. 'result' already contains the allocation top.
     Ldr(allocation_limit, MemOperand(top_address, limit - top));
   }
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
   // the same alignment on A64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   // Calculate new top and bail out if new space is exhausted.
@@ skipping 48 matching lines @@
   Mov(top_address, Operand(heap_allocation_top));
 
   if ((flags & RESULT_CONTAINS_TOP) == 0) {
     // Load allocation top into result and the allocation limit.
     Ldp(result, allocation_limit, MemOperand(top_address));
   } else {
     if (emit_debug_code()) {
       // Assert that result actually contains top on entry.
       Ldr(Tmp0(), MemOperand(top_address));
       Cmp(result, Tmp0());
-      Check(eq, "Unexpected allocation top.");
+      Check(eq, kUnexpectedAllocationTop);
     }
     // Load the allocation limit. 'result' already contains the allocation top.
     Ldr(allocation_limit, MemOperand(top_address, limit - top));
   }
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
   // the same alignment on A64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   // Calculate new top and bail out if new space is exhausted
   if ((flags & SIZE_IN_WORDS) != 0) {
     Adds(Tmp1(), result, Operand(object_size, LSL, kPointerSizeLog2));
   } else {
     Adds(Tmp1(), result, object_size);
   }
 
   if (emit_debug_code()) {
     Tst(Tmp1(), kObjectAlignmentMask);
-    Check(eq, "Unaligned allocation in new space");
+    Check(eq, kUnalignedAllocationInNewSpace);
   }
 
   B(vs, gc_required);
   Cmp(Tmp1(), allocation_limit);
   B(hi, gc_required);
   Str(Tmp1(), MemOperand(top_address));
 
   // Tag the object if requested.
   if ((flags & TAG_OBJECT) != 0) {
     Orr(result, result, kHeapObjectTag);
   }
 }
 
 
 void MacroAssembler::UndoAllocationInNewSpace(Register object,
                                               Register scratch) {
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   // Make sure the object has no tag before resetting top.
   Bic(object, object, kHeapObjectTagMask);
 #ifdef DEBUG
   // Check that the object un-allocated is below the current top.
   Mov(scratch, Operand(new_space_allocation_top));
   Ldr(scratch, MemOperand(scratch));
   Cmp(object, scratch);
-  Check(lt, "Trying to undo allocation of non allocated memory.");
+  // TODO(all): Add this error code to objects.h.
+  // Check(lt, kTryingToUndoAllocationOfNonAllocatedMemory);
+  Check(lt, kUnknown);
 #endif
   // Write the address of the object to un-allocate as the current top.
   Mov(scratch, Operand(new_space_allocation_top));
   Str(object, MemOperand(scratch));
 }
 
 
 void MacroAssembler::AllocateTwoByteString(Register result,
                                            Register length,
                                            Register scratch1,
@@ skipping 546 matching lines @@
 
   Label same_contexts;
 
   ASSERT(!AreAliased(holder_reg, scratch));
 
   // Load current lexical context from the stack frame.
   Ldr(scratch, MemOperand(fp, StandardFrameConstants::kContextOffset));
   // In debug mode, make sure the lexical context is set.
 #ifdef DEBUG
   Cmp(scratch, 0);
-  Check(ne, "we should not have an empty lexical context");
+  Check(ne, kWeShouldNotHaveAnEmptyLexicalContext);
 #endif
 
   // Load the native context of the current context.
   int offset =
       Context::kHeaderSize + Context::GLOBAL_OBJECT_INDEX * kPointerSize;
   Ldr(scratch, FieldMemOperand(scratch, offset));
   Ldr(scratch, FieldMemOperand(scratch, GlobalObject::kNativeContextOffset));
 
   // Check the context is a native context.
   if (emit_debug_code()) {
     // Read the first word and compare to the global_context_map.
     Register temp = Tmp1();
     Ldr(temp, FieldMemOperand(scratch, HeapObject::kMapOffset));
     CompareRoot(temp, Heap::kNativeContextMapRootIndex);
-    Check(eq, "JSGlobalObject::native_context should be a native context.");
+    // TODO(all): Add this error code to objects.h.
+    // Check(eq, kExpectedNativeContext);
+    Check(eq, kUnknown);
   }
 
   // Check if both contexts are the same.
   ldr(Tmp0(), FieldMemOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
   cmp(scratch, Tmp0());
   b(&same_contexts, eq);
 
   // Check the context is a native context.
   if (emit_debug_code()) {
     // Move Tmp0() into a different register, as CompareRoot will use it.
     Register temp = Tmp1();
     mov(temp, Tmp0());
     CompareRoot(temp, Heap::kNullValueRootIndex);
-    Check(ne, "JSGlobalProxy::context() should not be null.");
+    // TODO(all): Add this error code to objects.h.
+    // Check(ne, kExpectedNonNullContext);
+    Check(ne, kUnknown);
 
     Ldr(temp, FieldMemOperand(temp, HeapObject::kMapOffset));
     CompareRoot(temp, Heap::kNativeContextMapRootIndex);
-    Check(eq, "JSGlobalObject::native_context should be a native context.");
+    // TODO(all): Add this error code to objects.h.
+    // Check(eq, kExpectedNativeContext);
+    Check(eq, kUnknown);
 
     // Let's consider that Tmp0() has been cloberred by the MacroAssembler.
     // We reload it with its value.
     ldr(Tmp0(), FieldMemOperand(holder_reg,
                                 JSGlobalProxy::kNativeContextOffset));
   }
 
   // Check that the security token in the calling global object is
   // compatible with the security token in the receiving global
   // object.
@@ skipping 107 matching lines @@
 void MacroAssembler::RememberedSetHelper(Register object,  // For debug tests.
                                          Register address,
                                          Register scratch,
                                          SaveFPRegsMode fp_mode,
                                          RememberedSetFinalAction and_then) {
   ASSERT(!AreAliased(object, address, scratch));
   Label done, store_buffer_overflow;
   if (emit_debug_code()) {
     Label ok;
     JumpIfNotInNewSpace(object, &ok);
-    Abort("Remembered set pointer is in new space");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kRememberedSetPointerIsInNewSpace);
+    Abort(kUnknown);
     bind(&ok);
   }
   // Load store buffer top.
   Mov(Tmp0(), Operand(ExternalReference::store_buffer_top(isolate())));
   Ldr(scratch, MemOperand(Tmp0()));
   // Store pointer to buffer and increment buffer top.
   Str(address, MemOperand(scratch, kPointerSize, PostIndex));
   // Write back new top of buffer.
   Str(scratch, MemOperand(Tmp0()));
   // Call stub on end of buffer.
@@ skipping 111 matching lines @@
 
   // Although the object register is tagged, the offset is relative to the start
   // of the object, so offset must be a multiple of kPointerSize.
   ASSERT(IsAligned(offset, kPointerSize));
 
   Add(scratch, object, offset - kHeapObjectTag);
   if (emit_debug_code()) {
     Label ok;
     Tst(scratch, (1 << kPointerSizeLog2) - 1);
     B(eq, &ok);
-    Abort("Unaligned cell in write barrier");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kUnalignedCellInWriteBarrier);
+    Abort(kUnknown);
     Bind(&ok);
   }
 
   RecordWrite(object,
               scratch,
               value,
               lr_status,
               save_fp,
               remembered_set_action,
               OMIT_SMI_CHECK,
@@ skipping 30 matching lines @@
                                  SmiCheck smi_check,
                                  PregenExpectation pregen_expectation) {
   // The compiled code assumes that record write doesn't change the
   // context register, so we check that none of the clobbered
   // registers are cp.
   ASSERT(!address.is(cp) && !value.is(cp));
 
   if (emit_debug_code()) {
     Ldr(Tmp0(), MemOperand(address));
     Cmp(Tmp0(), value);
-    Check(eq, "Wrong address or value passed to RecordWrite.");
+    Check(eq, kWrongAddressOrValuePassedToRecordWrite);
   }
 
   Label done;
 
   if (smi_check == INLINE_SMI_CHECK) {
     ASSERT_EQ(0, kSmiTag);
     JumpIfSmi(value, &done);
   }
 
   CheckPageFlagClear(value,
@@ skipping 34 matching lines @@
 
 void MacroAssembler::AssertHasValidColor(const Register& reg) {
   if (emit_debug_code()) {
     // The bit sequence is backward. The first character in the string
     // represents the least significant bit.
     ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
 
     Label color_is_valid;
     Tbnz(reg, 0, &color_is_valid);
     Tbz(reg, 1, &color_is_valid);
-    Abort("Impossible color bit pattern found.");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kImpossibleColorBitPatternFound);
+    Abort(kUnknown);
     Bind(&color_is_valid);
   }
 }
 
 
 void MacroAssembler::GetMarkBits(Register addr_reg,
                                  Register bitmap_reg,
                                  Register shift_reg) {
   ASSERT(!AreAliased(addr_reg, bitmap_reg, shift_reg, no_reg));
   // addr_reg is divided into fields:
@@ skipping 76 matching lines @@
 
 void MacroAssembler::GetRelocatedValueLocation(Register ldr_location,
                                                Register result) {
   ASSERT(!result.Is(ldr_location));
   const uint32_t kLdrLitOffset_lsb = 5;
   const uint32_t kLdrLitOffset_width = 19;
   Ldr(result, MemOperand(ldr_location));
   if (emit_debug_code()) {
     And(result, result, LoadLiteralFMask);
     Cmp(result, LoadLiteralFixed);
-    Check(eq, "The instruction to patch should be a load literal.");
+    // TODO(all): Add this error code to objects.h.
+    // Check(eq, kTheInstructionToPatchShouldBeALoadLiteral);
+    Check(eq, kUnknown);
     // The instruction was clobbered. Reload it.
     Ldr(result, MemOperand(ldr_location));
   }
   Sbfx(result, result, kLdrLitOffset_lsb, kLdrLitOffset_width);
   Add(result, ldr_location, Operand(result, LSL, kWordSizeInBytesLog2));
 }
 
 
 void MacroAssembler::EnsureNotWhite(
     Register value,
@@ skipping 81 matching lines @@
 
   Bic(bitmap_scratch, bitmap_scratch, Page::kPageAlignmentMask);
   Ldr(load_scratch, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset));
   Add(load_scratch, load_scratch, length_scratch);
   Str(load_scratch, MemOperand(bitmap_scratch, MemoryChunk::kLiveBytesOffset));
 
   Bind(&done);
 }
 
 
-void MacroAssembler::Assert(Condition cond, const char* msg) {
+void MacroAssembler::Assert(Condition cond, BailoutReason reason) {
   if (emit_debug_code()) {
-    Check(cond, msg);
+    Check(cond, reason);
   }
 }
 
 
 
-void MacroAssembler::AssertRegisterIsClear(Register reg, const char* msg) {
+void MacroAssembler::AssertRegisterIsClear(Register reg, BailoutReason reason) {
   if (emit_debug_code()) {
-    CheckRegisterIsClear(reg, msg);
+    CheckRegisterIsClear(reg, reason);
   }
 }
 
 
 void MacroAssembler::AssertRegisterIsRoot(Register reg,
                                           Heap::RootListIndex index) {
   // CompareRoot uses Tmp0().
   ASSERT(!reg.Is(Tmp0()));
   if (emit_debug_code()) {
     CompareRoot(reg, index);
-    Check(eq, "Register did not match expected root");
+    Check(eq, kRegisterDidNotMatchExpectedRoot);
   }
 }
 
 
 void MacroAssembler::AssertFastElements(Register elements) {
   if (emit_debug_code()) {
     Register temp = Tmp1();
     Label ok;
     Ldr(temp, FieldMemOperand(elements, HeapObject::kMapOffset));
     JumpIfRoot(temp, Heap::kFixedArrayMapRootIndex, &ok);
     JumpIfRoot(temp, Heap::kFixedDoubleArrayMapRootIndex, &ok);
     JumpIfRoot(temp, Heap::kFixedCOWArrayMapRootIndex, &ok);
-    Abort("JSObject with fast elements map has slow elements");
+    Abort(kJSObjectWithFastElementsMapHasSlowElements);
     Bind(&ok);
   }
 }
 
 
 void MacroAssembler::AssertIsString(const Register& object) {
   if (emit_debug_code()) {
     Register temp = Tmp1();
     STATIC_ASSERT(kSmiTag == 0);
     Tst(object, Operand(kSmiTagMask));
-    Check(ne, "Operand is not a string");
+    Check(ne, kOperandIsNotAString);
     Ldr(temp, FieldMemOperand(object, HeapObject::kMapOffset));
     CompareInstanceType(temp, temp, FIRST_NONSTRING_TYPE);
-    Check(lo, "Operand is not a string");
+    Check(lo, kOperandIsNotAString);
   }
 }
 
 
-void MacroAssembler::Check(Condition cond, const char* msg) {
+void MacroAssembler::Check(Condition cond, BailoutReason reason) {
   Label ok;
   B(cond, &ok);
-  Abort(msg);
+  Abort(reason);
   // Will not return here.
   Bind(&ok);
 }
 
 
-void MacroAssembler::CheckRegisterIsClear(Register reg, const char* msg) {
+void MacroAssembler::CheckRegisterIsClear(Register reg, BailoutReason reason) {
   Label ok;
   Cbz(reg, &ok);
-  Abort(msg);
+  Abort(reason);
   // Will not return here.
   Bind(&ok);
 }
 
 
-void MacroAssembler::Abort(const char* msg) {
+void MacroAssembler::Abort(BailoutReason reason) {
 #ifdef DEBUG
-  if (msg != NULL) {
-    RecordComment("Abort message: ");
-    RecordComment(msg);
-  }
+  RecordComment("Abort message: ");
+  RecordComment(GetBailoutReason(reason));
 #endif
 
   Label msg_address;
   Adr(x0, &msg_address);
 
   if (use_real_aborts()) {
     // Split the message pointer into two SMI to avoid the GC
     // trying to scan the string.
     STATIC_ASSERT((kSmiShift == 32) && (kSmiTag == 0));
     SmiTag(x1, x0);
@@ skipping 23 matching lines @@
     //     valid code).
     //   - We need a way to stop execution on both the simulator and real
     //     hardware, and Unreachable() is the best option.
     Unreachable();
   }
 
   // Emit the message string directly in the instruction stream.
   {
     BlockConstPoolScope scope(this);
     Bind(&msg_address);
-    EmitStringData(msg);
+    // TODO(jbramley): Since the reason is an enum, why do we still encode the
+    // string (and a pointer to it) in the instruction stream?
+    EmitStringData(GetBailoutReason(reason));
   }
 }
 
 
 void MacroAssembler::LoadTransitionedArrayMapConditional(
     ElementsKind expected_kind,
     ElementsKind transitioned_kind,
     Register map_in_out,
     Register scratch,
     Label* no_map_match) {
@@ skipping 62 matching lines @@
 void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
                                                   Register map,
                                                   Register scratch) {
   // Load the initial map. The global functions all have initial maps.
   Ldr(map, FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
   if (emit_debug_code()) {
     Label ok, fail;
     CheckMap(map, scratch, Heap::kMetaMapRootIndex, &fail, DO_SMI_CHECK);
     B(&ok);
     Bind(&fail);
-    Abort("Global function must have initial map");
+    // TODO(all): Add this error code to objects.h.
+    // Abort(kGlobalFunctionMustHaveInitialMap);
+    Abort(kUnknown);
     Bind(&ok);
   }
 }
 
 
 // This is the main Printf implementation. All other Printf variants call
 // PrintfNoPreserve after setting up one or more PreserveRegisterScopes.
 void MacroAssembler::PrintfNoPreserve(const char * format,
                                       const CPURegister& arg0,
                                       const CPURegister& arg1,
@@ skipping 309 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64