A64: Add more descriptive messages to aborts

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 1999 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);
-    // TODO(all): Add this error code to objects.h.
-    // Assert(ge, kCopyLengthIsBelowZero);
-    Assert(ge, kUnknown);
+    Assert(ge, kUnexpectedNegativeValue);
 
     // 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);
-    // TODO(all): Add this error code to objects.h.
-    // Assert(le, kCopyBytesSrcAndDstBuffersOverlap);
-    Assert(le, kUnknown);
+    Assert(le, kCopyBuffersOverlap);
   }
 
   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 23 matching lines @@
     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);
 
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kAtLeastOneInputIsASmi);
-    Abort(kUnknown);
+    // At least one input is a smi, but the flags indicated a smi check wasn't
+    // needed.
+    Abort(kUnexpectedSmi);
 
     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));
 
@@ skipping 343 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);
-    // TODO(all): Add this error code to objects.h.
-    // Check(ge, kThisInputShouldHaveBeenHandledByTheFPU);
-    Check(ge, kUnknown);
+    // Exponents less than this should have been handled by the Fcvt case.
+    Check(ge, kUnexpectedValue);
   }
 
   // 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);
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kExpectedHeapNumber);
-    Abort(kUnknown);
+    Abort(kExpectedHeapNumber);
     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 409 matching lines @@
   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);
-  // TODO(all): Add this error code to objects.h.
-  // Check(lt, kTryingToUndoAllocationOfNonAllocatedMemory);
-  Check(lt, kUnknown);
+  Check(lt, kUndoAllocationOfNonAllocatedMemory);
 #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 561 matching lines @@
       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);
-    // TODO(all): Add this error code to objects.h.
-    // Check(eq, kExpectedNativeContext);
-    Check(eq, kUnknown);
+    Check(eq, kExpectedNativeContext);
   }
 
   // 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);
-    // TODO(all): Add this error code to objects.h.
-    // Check(ne, kExpectedNonNullContext);
-    Check(ne, kUnknown);
+    Check(ne, kExpectedNonNullContext);
 
     Ldr(temp, FieldMemOperand(temp, HeapObject::kMapOffset));
     CompareRoot(temp, Heap::kNativeContextMapRootIndex);
-    // TODO(all): Add this error code to objects.h.
-    // Check(eq, kExpectedNativeContext);
-    Check(eq, kUnknown);
+    Check(eq, kExpectedNativeContext);
 
     // 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);
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kRememberedSetPointerIsInNewSpace);
-    Abort(kUnknown);
+    Abort(kRememberedSetPointerInNewSpace);
     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);
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kUnalignedCellInWriteBarrier);
-    Abort(kUnknown);
+    Abort(kUnalignedCellInWriteBarrier);
     Bind(&ok);
   }
 
   RecordWrite(object,
               scratch,
               value,
               lr_status,
               save_fp,
               remembered_set_action,
               OMIT_SMI_CHECK,
@@ skipping 85 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);
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kImpossibleColorBitPatternFound);
-    Abort(kUnknown);
+    Abort(kUnexpectedColorFound);
     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);
-    // TODO(all): Add this error code to objects.h.
-    // Check(eq, kTheInstructionToPatchShouldBeALoadLiteral);
-    Check(eq, kUnknown);
+    Check(eq, kTheInstructionToPatchShouldBeAnLdrLiteral);
     // 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 289 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);
-    // TODO(all): Add this error code to objects.h.
-    // Abort(kGlobalFunctionMustHaveInitialMap);
-    Abort(kUnknown);
+    Abort(kGlobalFunctionsMustHaveInitialMap);
     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