A64: Synchronize with r16024.

src/a64/regexp-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 365 matching lines @@
 
     __ Bind(&fail);
     BranchOrBacktrack(al, on_no_match);
 
     __ Bind(&success);
     // Compute new value of character position after the matched part.
     __ Sub(current_input_offset().X(), current_position_address, input_end());
     if (masm_->emit_debug_code()) {
       __ Cmp(current_input_offset().X(), Operand(current_input_offset(), SXTW));
       __ Ccmp(current_input_offset(), 0, NoFlag, eq);
-      __ Check(le,
-          "current_input_offset should be <= 0 and fit in a W register.");
+      // The current input offset should be <= 0, and fit in a W register.
+      // TODO(all): Add this error code to objects.h.
+      // __ Check(le, kCurrentInputOffsetOutOfRange);
+      __ Check(le, kUnknown);
     }
   } else {
     ASSERT(mode_ == UC16);
     int argument_count = 4;
 
     // The cached registers need to be retained.
     CPURegList cached_registers(CPURegister::kRegister, kXRegSize, 0, 7);
     ASSERT((cached_registers.Count() * 2) == kNumCachedRegisters);
     __ PushCPURegList(cached_registers);
 
@@ skipping 79 matching lines @@
   __ Cmp(w10, w11);
   BranchOrBacktrack(ne, on_no_match);
   __ Cmp(capture_start_address, capture_end_address);
   __ B(lt, &loop);
 
   // Move current character position to position after match.
   __ Sub(current_input_offset().X(), current_position_address, input_end());
   if (masm_->emit_debug_code()) {
     __ Cmp(current_input_offset().X(), Operand(current_input_offset(), SXTW));
     __ Ccmp(current_input_offset(), 0, NoFlag, eq);
-    __ Check(le,
-        "current_input_offset should be <= 0 and fit in a W register.");
+    // The current input offset should be <= 0, and fit in a W register.
+    // TODO(all): Add this error code to objects.h.
+    // __ Check(le, kCurrentInputOffsetOutOfRange);
+    __ Check(le, kUnknown);
   }
   __ Bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerA64::CheckNotCharacter(unsigned c,
                                                 Label* on_not_equal) {
   CompareAndBranchOrBacktrack(current_character(), c, ne, on_not_equal);
 }
 
@@ skipping 267 matching lines @@
 
   // Initialize success_counter with 0.
   __ Str(wzr, MemOperand(frame_pointer(), kSuccessCounter));
 
   // Find negative length (offset of start relative to end).
   __ Sub(x10, input_start(), input_end());
   if (masm_->emit_debug_code()) {
     // Check that the input string length is < 2^30.
     __ Neg(x11, x10);
     __ Cmp(x11, (1<<30) - 1);
-    __ Check(ls, "The length of the input string cannot be >= 2^30.");
+    // TODO(all): Add this error code to objects.h.
+    // __ Check(ls, kInputStringTooLong);
+    __ Check(ls, kUnknown);
   }
   __ Mov(current_input_offset(), w10);
 
   // The non-position value is used as a clearing value for the
   // capture registers, it corresponds to the position of the first character
   // minus one.
   __ Sub(non_position_value(), current_input_offset(), char_size());
   __ Sub(non_position_value(), non_position_value(),
          Operand(start_offset(), LSL, (mode_ == UC16) ? 1 : 0));
   // We can store this value twice in an X register for initializing
@@ skipping 44 matching lines @@
       Register capture_end = w13;
       Register input_length = w14;
 
       // Copy captures to output.
 
       // Get string length.
       __ Sub(x10, input_end(), input_start());
       if (masm_->emit_debug_code()) {
         // Check that the input string length is < 2^30.
         __ Cmp(x10, (1<<30) - 1);
-        __ Check(ls, "The length of the input string cannot be >= 2^30.");
+        // TODO(all): Add this error code to objects.h.
+        // __ Check(ls, kInputStringTooLong);
+        __ Check(ls, kUnknown);
       }
       // input_start has a start_offset offset on entry. We need to include
       // it when computing the length of the whole string.
       if (mode_ == UC16) {
         __ Add(input_length, start_offset(), Operand(w10, LSR, 1));
       } else {
         __ Add(input_length, start_offset(), w10);
       }
 
       // Copy the results to the output array from the cached registers first.
@@ skipping 276 matching lines @@
 
 void RegExpMacroAssemblerA64::PushBacktrack(Label* label) {
   if (label->is_bound()) {
     int target = label->pos();
     __ Mov(w10, target + Code::kHeaderSize - kHeapObjectTag);
   } else {
     __ Adr(x10, label);
     __ Sub(x10, x10, code_pointer());
     if (masm_->emit_debug_code()) {
       __ Cmp(x10, kWRegMask);
-      __ Check(ls, "The code offset needs to fit in a W register.");
+      // The code offset has to fit in a W register.
+      // TODO(all): Add this error code to objects.h.
+      // __ Check(ls, kCodeOffsetOutOfRange);
+      __ Check(ls, kUnknown);
     }
   }
   Push(w10);
   CheckStackLimit();
 }
 
 
 void RegExpMacroAssemblerA64::PushCurrentPosition() {
   Push(current_input_offset());
 }
@@ skipping 136 matching lines @@
     }
   }
 }
 
 
 void RegExpMacroAssemblerA64::WriteStackPointerToRegister(int reg) {
   __ Ldr(x10, MemOperand(frame_pointer(), kStackBase));
   __ Sub(x10, backtrack_stackpointer(), x10);
   if (masm_->emit_debug_code()) {
     __ Cmp(x10, Operand(w10, SXTW));
-    __ Check(eq, "Offset from the stack base needs to fit in a W register.");
+    // The stack offset needs to fit in a W register.
+    // TODO(all): Add this error code to objects.h.
+    // __ Check(eq, kStackOffsetIsTooLarge);
+    __ Check(eq, kUnknown);
   }
   StoreRegister(reg, w10);
 }
 
 
 // Helper function for reading a value out of a stack frame.
 template <typename T>
 static T& frame_entry(Address re_frame, int frame_offset) {
   return *reinterpret_cast<T*>(re_frame + frame_offset);
 }
@@ skipping 381 matching lines @@
   // TODO(pielan): See whether or not we should disable unaligned accesses.
   if (!CanReadUnaligned()) {
     ASSERT(characters == 1);
   }
 
   if (cp_offset != 0) {
     if (masm_->emit_debug_code()) {
       __ Mov(x10, cp_offset * char_size());
       __ Add(x10, x10, Operand(current_input_offset(), SXTW));
       __ Cmp(x10, Operand(w10, SXTW));
-      __ Check(eq, "The offset needs to fit in a W register.");
+      // The offset needs to fit in a W register.
+      // TODO(all): Add this error code to objects.h.
+      // __ Check(eq, kCurrentInputOffsetOutOfRange);
+      __ Check(eq, kUnknown);
     } else {
       __ Add(w10, current_input_offset(), cp_offset * char_size());
     }
     offset = w10;
   }
 
   if (mode_ == ASCII) {
     if (characters == 4) {
       __ Ldr(current_character(), MemOperand(input_end(), offset, SXTW));
     } else if (characters == 2) {
@@ skipping 11 matching lines @@
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64