Rename ASSERT* to DCHECK*.

src/arm64/regexp-macro-assembler-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/code-stubs.h"
 #include "src/cpu-profiler.h"
@@ skipping 108 matching lines @@
       masm_(new MacroAssembler(zone->isolate(), NULL, kRegExpCodeSize)),
       mode_(mode),
       num_registers_(registers_to_save),
       num_saved_registers_(registers_to_save),
       entry_label_(),
       start_label_(),
       success_label_(),
       backtrack_label_(),
       exit_label_() {
   __ SetStackPointer(csp);
-  ASSERT_EQ(0, registers_to_save % 2);
+  DCHECK_EQ(0, registers_to_save % 2);
   // We can cache at most 16 W registers in x0-x7.
   STATIC_ASSERT(kNumCachedRegisters <= 16);
   STATIC_ASSERT((kNumCachedRegisters % 2) == 0);
   __ B(&entry_label_);   // We'll write the entry code later.
   __ Bind(&start_label_);  // And then continue from here.
 }
 
 
 RegExpMacroAssemblerARM64::~RegExpMacroAssemblerARM64() {
   delete masm_;
@@ skipping 14 matching lines @@
 
 void RegExpMacroAssemblerARM64::AdvanceCurrentPosition(int by) {
   if (by != 0) {
     __ Add(current_input_offset(),
            current_input_offset(), by * char_size());
   }
 }
 
 
 void RegExpMacroAssemblerARM64::AdvanceRegister(int reg, int by) {
-  ASSERT((reg >= 0) && (reg < num_registers_));
+  DCHECK((reg >= 0) && (reg < num_registers_));
   if (by != 0) {
     Register to_advance;
     RegisterState register_state = GetRegisterState(reg);
     switch (register_state) {
       case STACKED:
         __ Ldr(w10, register_location(reg));
         __ Add(w10, w10, by);
         __ Str(w10, register_location(reg));
         break;
       case CACHED_LSW:
@@ skipping 80 matching lines @@
   __ Add(characters_address,
          input_end(),
          Operand(current_input_offset(), SXTW));
   if (cp_offset != 0) {
     __ Add(characters_address, characters_address, cp_offset * char_size());
   }
 
   for (int i = 0; i < str.length(); i++) {
     if (mode_ == ASCII) {
       __ Ldrb(w10, MemOperand(characters_address, 1, PostIndex));
-      ASSERT(str[i] <= String::kMaxOneByteCharCode);
+      DCHECK(str[i] <= String::kMaxOneByteCharCode);
     } else {
       __ Ldrh(w10, MemOperand(characters_address, 2, PostIndex));
     }
     CompareAndBranchOrBacktrack(w10, str[i], ne, on_failure);
   }
 }
 
 
 void RegExpMacroAssemblerARM64::CheckGreedyLoop(Label* on_equal) {
   __ Ldr(w10, MemOperand(backtrack_stackpointer()));
   __ Cmp(current_input_offset(), w10);
   __ Cset(x11, eq);
   __ Add(backtrack_stackpointer(),
          backtrack_stackpointer(), Operand(x11, LSL, kWRegSizeLog2));
   BranchOrBacktrack(eq, on_equal);
 }
 
 void RegExpMacroAssemblerARM64::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   Register capture_start_offset = w10;
   // Save the capture length in a callee-saved register so it will
   // be preserved if we call a C helper.
   Register capture_length = w19;
-  ASSERT(kCalleeSaved.IncludesAliasOf(capture_length));
+  DCHECK(kCalleeSaved.IncludesAliasOf(capture_length));
 
   // Find length of back-referenced capture.
-  ASSERT((start_reg % 2) == 0);
+  DCHECK((start_reg % 2) == 0);
   if (start_reg < kNumCachedRegisters) {
     __ Mov(capture_start_offset.X(), GetCachedRegister(start_reg));
     __ Lsr(x11, GetCachedRegister(start_reg), kWRegSizeInBits);
   } else {
     __ Ldp(w11, capture_start_offset, capture_location(start_reg, x10));
   }
   __ Sub(capture_length, w11, capture_start_offset);  // Length to check.
   // Succeed on empty capture (including no capture).
   __ Cbz(capture_length, &fallthrough);
 
@@ skipping 52 matching lines @@
     __ 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);
       // The current input offset should be <= 0, and fit in a W register.
       __ Check(le, kOffsetOutOfRange);
     }
   } else {
-    ASSERT(mode_ == UC16);
+    DCHECK(mode_ == UC16);
     int argument_count = 4;
 
     // The cached registers need to be retained.
     CPURegList cached_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 7);
-    ASSERT((cached_registers.Count() * 2) == kNumCachedRegisters);
+    DCHECK((cached_registers.Count() * 2) == kNumCachedRegisters);
     __ PushCPURegList(cached_registers);
 
     // Put arguments into arguments registers.
     // Parameters are
     //   x0: Address byte_offset1 - Address captured substring's start.
     //   x1: Address byte_offset2 - Address of current character position.
     //   w2: size_t byte_length - length of capture in bytes(!)
     //   x3: Isolate* isolate
 
     // Address of start of capture.
@@ skipping 30 matching lines @@
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   Register capture_start_address = x12;
   Register capture_end_address = x13;
   Register current_position_address = x14;
   Register capture_length = w15;
 
   // Find length of back-referenced capture.
-  ASSERT((start_reg % 2) == 0);
+  DCHECK((start_reg % 2) == 0);
   if (start_reg < kNumCachedRegisters) {
     __ Mov(x10, GetCachedRegister(start_reg));
     __ Lsr(x11, GetCachedRegister(start_reg), kWRegSizeInBits);
   } else {
     __ Ldp(w11, w10, capture_location(start_reg, x10));
   }
   __ Sub(capture_length, w11, w10);  // Length to check.
   // Succeed on empty capture (including no capture).
   __ Cbz(capture_length, &fallthrough);
 
   // Check that there are enough characters left in the input.
   __ Cmn(capture_length, current_input_offset());
   BranchOrBacktrack(gt, on_no_match);
 
   // Compute pointers to match string and capture string
   __ Add(capture_start_address, input_end(), Operand(w10, SXTW));
   __ Add(capture_end_address,
          capture_start_address,
          Operand(capture_length, SXTW));
   __ Add(current_position_address,
          input_end(),
          Operand(current_input_offset(), SXTW));
 
   Label loop;
   __ Bind(&loop);
   if (mode_ == ASCII) {
     __ Ldrb(w10, MemOperand(capture_start_address, 1, PostIndex));
     __ Ldrb(w11, MemOperand(current_position_address, 1, PostIndex));
   } else {
-    ASSERT(mode_ == UC16);
+    DCHECK(mode_ == UC16);
     __ Ldrh(w10, MemOperand(capture_start_address, 2, PostIndex));
     __ Ldrh(w11, MemOperand(current_position_address, 2, PostIndex));
   }
   __ 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());
@@ skipping 27 matching lines @@
   __ And(w10, current_character(), mask);
   CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerARM64::CheckNotCharacterAfterMinusAnd(
     uc16 c,
     uc16 minus,
     uc16 mask,
     Label* on_not_equal) {
-  ASSERT(minus < String::kMaxUtf16CodeUnit);
+  DCHECK(minus < String::kMaxUtf16CodeUnit);
   __ Sub(w10, current_character(), minus);
   __ And(w10, w10, mask);
   CompareAndBranchOrBacktrack(w10, c, ne, on_not_equal);
 }
 
 
 void RegExpMacroAssemblerARM64::CheckCharacterInRange(
     uc16 from,
     uc16 to,
     Label* on_in_range) {
@@ skipping 161 matching lines @@
   //  csp[0]:  secondary link/return address used by native call
 
   // Tell the system that we have a stack frame.  Because the type is MANUAL, no
   // code is generated.
   FrameScope scope(masm_, StackFrame::MANUAL);
 
   // Push registers on the stack, only push the argument registers that we need.
   CPURegList argument_registers(x0, x5, x6, x7);
 
   CPURegList registers_to_retain = kCalleeSaved;
-  ASSERT(kCalleeSaved.Count() == 11);
+  DCHECK(kCalleeSaved.Count() == 11);
   registers_to_retain.Combine(lr);
 
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ PushCPURegList(registers_to_retain);
   __ PushCPURegList(argument_registers);
 
   // Set frame pointer in place.
   __ Add(frame_pointer(), csp, argument_registers.Count() * kPointerSize);
 
   // Initialize callee-saved registers.
   __ Mov(start_offset(), w1);
   __ Mov(input_start(), x2);
   __ Mov(input_end(), x3);
   __ Mov(output_array(), x4);
 
   // Set the number of registers we will need to allocate, that is:
   //   - success_counter (X register)
   //   - (num_registers_ - kNumCachedRegisters) (W registers)
   int num_wreg_to_allocate = num_registers_ - kNumCachedRegisters;
   // Do not allocate registers on the stack if they can all be cached.
   if (num_wreg_to_allocate < 0) { num_wreg_to_allocate = 0; }
   // Make room for the success_counter.
   num_wreg_to_allocate += 2;
 
   // Make sure the stack alignment will be respected.
   int alignment = masm_->ActivationFrameAlignment();
-  ASSERT_EQ(alignment % 16, 0);
+  DCHECK_EQ(alignment % 16, 0);
   int align_mask = (alignment / kWRegSize) - 1;
   num_wreg_to_allocate = (num_wreg_to_allocate + align_mask) & ~align_mask;
 
   // Check if we have space on the stack.
   Label stack_limit_hit;
   Label stack_ok;
 
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ Mov(x10, stack_limit);
@@ skipping 132 matching lines @@
       }
 
       // Only carry on if there are more than kNumCachedRegisters capture
       // registers.
       int num_registers_left_on_stack =
           num_saved_registers_ - kNumCachedRegisters;
       if (num_registers_left_on_stack > 0) {
         Register base = x10;
         // There are always an even number of capture registers. A couple of
         // registers determine one match with two offsets.
-        ASSERT_EQ(0, num_registers_left_on_stack % 2);
+        DCHECK_EQ(0, num_registers_left_on_stack % 2);
         __ Add(base, frame_pointer(), kFirstCaptureOnStack);
 
         // We can unroll the loop here, we should not unroll for less than 2
         // registers.
         STATIC_ASSERT(kNumRegistersToUnroll > 2);
         if (num_registers_left_on_stack <= kNumRegistersToUnroll) {
           for (int i = 0; i < num_registers_left_on_stack / 2; i++) {
             __ Ldp(capture_end,
                    capture_start,
                    MemOperand(base, -kPointerSize, PostIndex));
@@ skipping 96 matching lines @@
     // Exit and return w0
     __ Bind(&exit_label_);
     if (global()) {
       __ Ldr(w0, MemOperand(frame_pointer(), kSuccessCounter));
     }
   }
 
   __ Bind(&return_w0);
 
   // Set stack pointer back to first register to retain
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Mov(csp, fp);
   __ AssertStackConsistency();
 
   // Restore registers.
   __ PopCPURegList(registers_to_retain);
 
   __ Ret();
 
   Label exit_with_exception;
   // Registers x0 to x7 are used to store the first captures, they need to be
   // retained over calls to C++ code.
   CPURegList cached_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 7);
-  ASSERT((cached_registers.Count() * 2) == kNumCachedRegisters);
+  DCHECK((cached_registers.Count() * 2) == kNumCachedRegisters);
 
   if (check_preempt_label_.is_linked()) {
     __ Bind(&check_preempt_label_);
     SaveLinkRegister();
     // The cached registers need to be retained.
     __ PushCPURegList(cached_registers);
     CallCheckStackGuardState(x10);
     // Returning from the regexp code restores the stack (csp <- fp)
     // so we don't need to drop the link register from it before exiting.
     __ Cbnz(w0, &return_w0);
@@ skipping 72 matching lines @@
   return kARM64Implementation;
 }
 
 
 void RegExpMacroAssemblerARM64::LoadCurrentCharacter(int cp_offset,
                                                      Label* on_end_of_input,
                                                      bool check_bounds,
                                                      int characters) {
   // TODO(pielan): Make sure long strings are caught before this, and not
   // just asserted in debug mode.
-  ASSERT(cp_offset >= -1);      // ^ and \b can look behind one character.
+  DCHECK(cp_offset >= -1);      // ^ and \b can look behind one character.
   // Be sane! (And ensure that an int32_t can be used to index the string)
-  ASSERT(cp_offset < (1<<30));
+  DCHECK(cp_offset < (1<<30));
   if (check_bounds) {
     CheckPosition(cp_offset + characters - 1, on_end_of_input);
   }
   LoadCurrentCharacterUnchecked(cp_offset, characters);
 }
 
 
 void RegExpMacroAssemblerARM64::PopCurrentPosition() {
   Pop(current_input_offset());
 }
@@ skipping 72 matching lines @@
   __ Mov(current_input_offset(), -by * char_size());
   // On RegExp code entry (where this operation is used), the character before
   // the current position is expected to be already loaded.
   // We have advanced the position, so it's safe to read backwards.
   LoadCurrentCharacterUnchecked(-1, 1);
   __ Bind(&after_position);
 }
 
 
 void RegExpMacroAssemblerARM64::SetRegister(int register_index, int to) {
-  ASSERT(register_index >= num_saved_registers_);  // Reserved for positions!
+  DCHECK(register_index >= num_saved_registers_);  // Reserved for positions!
   Register set_to = wzr;
   if (to != 0) {
     set_to = w10;
     __ Mov(set_to, to);
   }
   StoreRegister(register_index, set_to);
 }
 
 
 bool RegExpMacroAssemblerARM64::Succeed() {
   __ B(&success_label_);
   return global();
 }
 
 
 void RegExpMacroAssemblerARM64::WriteCurrentPositionToRegister(int reg,
                                                                int cp_offset) {
   Register position = current_input_offset();
   if (cp_offset != 0) {
     position = w10;
     __ Add(position, current_input_offset(), cp_offset * char_size());
   }
   StoreRegister(reg, position);
 }
 
 
 void RegExpMacroAssemblerARM64::ClearRegisters(int reg_from, int reg_to) {
-  ASSERT(reg_from <= reg_to);
+  DCHECK(reg_from <= reg_to);
   int num_registers = reg_to - reg_from + 1;
 
   // If the first capture register is cached in a hardware register but not
   // aligned on a 64-bit one, we need to clear the first one specifically.
   if ((reg_from < kNumCachedRegisters) && ((reg_from % 2) != 0)) {
     StoreRegister(reg_from, non_position_value());
     num_registers--;
     reg_from++;
   }
 
   // Clear cached registers in pairs as far as possible.
   while ((num_registers >= 2) && (reg_from < kNumCachedRegisters)) {
-    ASSERT(GetRegisterState(reg_from) == CACHED_LSW);
+    DCHECK(GetRegisterState(reg_from) == CACHED_LSW);
     __ Mov(GetCachedRegister(reg_from), twice_non_position_value());
     reg_from += 2;
     num_registers -= 2;
   }
 
   if ((num_registers % 2) == 1) {
     StoreRegister(reg_from, non_position_value());
     num_registers--;
     reg_from++;
   }
 
   if (num_registers > 0) {
     // If there are some remaining registers, they are stored on the stack.
-    ASSERT(reg_from >= kNumCachedRegisters);
+    DCHECK(reg_from >= kNumCachedRegisters);
 
     // Move down the indexes of the registers on stack to get the correct offset
     // in memory.
     reg_from -= kNumCachedRegisters;
     reg_to -= kNumCachedRegisters;
     // We should not unroll the loop for less than 2 registers.
     STATIC_ASSERT(kNumRegistersToUnroll > 2);
     // We position the base pointer to (reg_from + 1).
     int base_offset = kFirstRegisterOnStack -
         kWRegSize - (kWRegSize * reg_from);
@@ skipping 62 matching lines @@
 
   // Prepare for possible GC.
   HandleScope handles(isolate);
   Handle<Code> code_handle(re_code);
 
   Handle<String> subject(frame_entry<String*>(re_frame, kInput));
 
   // Current string.
   bool is_ascii = subject->IsOneByteRepresentationUnderneath();
 
-  ASSERT(re_code->instruction_start() <= *return_address);
-  ASSERT(*return_address <=
+  DCHECK(re_code->instruction_start() <= *return_address);
+  DCHECK(*return_address <=
       re_code->instruction_start() + re_code->instruction_size());
 
   Object* result = isolate->stack_guard()->HandleInterrupts();
 
   if (*code_handle != re_code) {  // Return address no longer valid
     int delta = code_handle->address() - re_code->address();
     // Overwrite the return address on the stack.
     *return_address += delta;
   }
 
@@ skipping 18 matching lines @@
     // If we changed between an ASCII and an UC16 string, the specialized
     // code cannot be used, and we need to restart regexp matching from
     // scratch (including, potentially, compiling a new version of the code).
     return RETRY;
   }
 
   // Otherwise, the content of the string might have moved. It must still
   // be a sequential or external string with the same content.
   // Update the start and end pointers in the stack frame to the current
   // location (whether it has actually moved or not).
-  ASSERT(StringShape(*subject_tmp).IsSequential() ||
+  DCHECK(StringShape(*subject_tmp).IsSequential() ||
          StringShape(*subject_tmp).IsExternal());
 
   // The original start address of the characters to match.
   const byte* start_address = *input_start;
 
   // Find the current start address of the same character at the current string
   // position.
   const byte* new_address = StringCharacterPosition(*subject_tmp,
       start_offset + slice_offset);
 
@@ skipping 32 matching lines @@
 
 
 // Private methods:
 
 void RegExpMacroAssemblerARM64::CallCheckStackGuardState(Register scratch) {
   // Allocate space on the stack to store the return address. The
   // CheckStackGuardState C++ function will override it if the code
   // moved. Allocate extra space for 2 arguments passed by pointers.
   // AAPCS64 requires the stack to be 16 byte aligned.
   int alignment = masm_->ActivationFrameAlignment();
-  ASSERT_EQ(alignment % 16, 0);
+  DCHECK_EQ(alignment % 16, 0);
   int align_mask = (alignment / kXRegSize) - 1;
   int xreg_to_claim = (3 + align_mask) & ~align_mask;
 
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Claim(xreg_to_claim);
 
   // CheckStackGuardState needs the end and start addresses of the input string.
   __ Poke(input_end(), 2 * kPointerSize);
   __ Add(x5, csp, 2 * kPointerSize);
   __ Poke(input_start(), kPointerSize);
   __ Add(x4, csp, kPointerSize);
 
   __ Mov(w3, start_offset());
   // RegExp code frame pointer.
   __ Mov(x2, frame_pointer());
   // Code* of self.
   __ Mov(x1, Operand(masm_->CodeObject()));
 
   // We need to pass a pointer to the return address as first argument.
   // The DirectCEntry stub will place the return address on the stack before
   // calling so the stack pointer will point to it.
   __ Mov(x0, csp);
 
   ExternalReference check_stack_guard_state =
       ExternalReference::re_check_stack_guard_state(isolate());
   __ Mov(scratch, check_stack_guard_state);
   DirectCEntryStub stub(isolate());
   stub.GenerateCall(masm_, scratch);
 
   // The input string may have been moved in memory, we need to reload it.
   __ Peek(input_start(), kPointerSize);
   __ Peek(input_end(), 2 * kPointerSize);
 
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Drop(xreg_to_claim);
 
   // Reload the Code pointer.
   __ Mov(code_pointer(), Operand(masm_->CodeObject()));
 }
 
 void RegExpMacroAssemblerARM64::BranchOrBacktrack(Condition condition,
                                                   Label* to) {
   if (condition == al) {  // Unconditional.
     if (to == NULL) {
@@ skipping 28 matching lines @@
   }
 }
 
 
 void RegExpMacroAssemblerARM64::CheckPreemption() {
   // Check for preemption.
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Cmp(csp, x10);
   CallIf(&check_preempt_label_, ls);
 }
 
 
 void RegExpMacroAssemblerARM64::CheckStackLimit() {
   ExternalReference stack_limit =
       ExternalReference::address_of_regexp_stack_limit(isolate());
   __ Mov(x10, stack_limit);
   __ Ldr(x10, MemOperand(x10));
   __ Cmp(backtrack_stackpointer(), x10);
   CallIf(&stack_overflow_label_, ls);
 }
 
 
 void RegExpMacroAssemblerARM64::Push(Register source) {
-  ASSERT(source.Is32Bits());
-  ASSERT(!source.is(backtrack_stackpointer()));
+  DCHECK(source.Is32Bits());
+  DCHECK(!source.is(backtrack_stackpointer()));
   __ Str(source,
          MemOperand(backtrack_stackpointer(),
                     -static_cast<int>(kWRegSize),
                     PreIndex));
 }
 
 
 void RegExpMacroAssemblerARM64::Pop(Register target) {
-  ASSERT(target.Is32Bits());
-  ASSERT(!target.is(backtrack_stackpointer()));
+  DCHECK(target.Is32Bits());
+  DCHECK(!target.is(backtrack_stackpointer()));
   __ Ldr(target,
          MemOperand(backtrack_stackpointer(), kWRegSize, PostIndex));
 }
 
 
 Register RegExpMacroAssemblerARM64::GetCachedRegister(int register_index) {
-  ASSERT(register_index < kNumCachedRegisters);
+  DCHECK(register_index < kNumCachedRegisters);
   return Register::Create(register_index / 2, kXRegSizeInBits);
 }
 
 
 Register RegExpMacroAssemblerARM64::GetRegister(int register_index,
                                                 Register maybe_result) {
-  ASSERT(maybe_result.Is32Bits());
-  ASSERT(register_index >= 0);
+  DCHECK(maybe_result.Is32Bits());
+  DCHECK(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   Register result;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Ldr(maybe_result, register_location(register_index));
       result = maybe_result;
       break;
     case CACHED_LSW:
       result = GetCachedRegister(register_index).W();
       break;
     case CACHED_MSW:
       __ Lsr(maybe_result.X(), GetCachedRegister(register_index),
              kWRegSizeInBits);
       result = maybe_result;
       break;
     default:
       UNREACHABLE();
       break;
   }
-  ASSERT(result.Is32Bits());
+  DCHECK(result.Is32Bits());
   return result;
 }
 
 
 void RegExpMacroAssemblerARM64::StoreRegister(int register_index,
                                               Register source) {
-  ASSERT(source.Is32Bits());
-  ASSERT(register_index >= 0);
+  DCHECK(source.Is32Bits());
+  DCHECK(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
 
   Register cached_register;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Str(source, register_location(register_index));
       break;
@@ skipping 16 matching lines @@
 
 void RegExpMacroAssemblerARM64::CallIf(Label* to, Condition condition) {
   Label skip_call;
   if (condition != al) __ B(&skip_call, NegateCondition(condition));
   __ Bl(to);
   __ Bind(&skip_call);
 }
 
 
 void RegExpMacroAssemblerARM64::RestoreLinkRegister() {
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Pop(lr, xzr);
   __ Add(lr, lr, Operand(masm_->CodeObject()));
 }
 
 
 void RegExpMacroAssemblerARM64::SaveLinkRegister() {
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
   __ Sub(lr, lr, Operand(masm_->CodeObject()));
   __ Push(xzr, lr);
 }
 
 
 MemOperand RegExpMacroAssemblerARM64::register_location(int register_index) {
-  ASSERT(register_index < (1<<30));
-  ASSERT(register_index >= kNumCachedRegisters);
+  DCHECK(register_index < (1<<30));
+  DCHECK(register_index >= kNumCachedRegisters);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   register_index -= kNumCachedRegisters;
   int offset = kFirstRegisterOnStack - register_index * kWRegSize;
   return MemOperand(frame_pointer(), offset);
 }
 
 MemOperand RegExpMacroAssemblerARM64::capture_location(int register_index,
                                                      Register scratch) {
-  ASSERT(register_index < (1<<30));
-  ASSERT(register_index < num_saved_registers_);
-  ASSERT(register_index >= kNumCachedRegisters);
-  ASSERT_EQ(register_index % 2, 0);
+  DCHECK(register_index < (1<<30));
+  DCHECK(register_index < num_saved_registers_);
+  DCHECK(register_index >= kNumCachedRegisters);
+  DCHECK_EQ(register_index % 2, 0);
   register_index -= kNumCachedRegisters;
   int offset = kFirstCaptureOnStack - register_index * kWRegSize;
   // capture_location is used with Stp instructions to load/store 2 registers.
   // The immediate field in the encoding is limited to 7 bits (signed).
   if (is_int7(offset)) {
     return MemOperand(frame_pointer(), offset);
   } else {
     __ Add(scratch, frame_pointer(), offset);
     return MemOperand(scratch);
   }
 }
 
 void RegExpMacroAssemblerARM64::LoadCurrentCharacterUnchecked(int cp_offset,
                                                               int characters) {
   Register offset = current_input_offset();
 
   // The ldr, str, ldrh, strh instructions can do unaligned accesses, if the CPU
   // and the operating system running on the target allow it.
   // If unaligned load/stores are not supported then this function must only
   // be used to load a single character at a time.
 
   // ARMv8 supports unaligned accesses but V8 or the kernel can decide to
   // disable it.
   // TODO(pielan): See whether or not we should disable unaligned accesses.
   if (!CanReadUnaligned()) {
-    ASSERT(characters == 1);
+    DCHECK(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));
       // The offset needs to fit in a W register.
       __ Check(eq, kOffsetOutOfRange);
     } 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) {
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     } else {
-      ASSERT(characters == 1);
+      DCHECK(characters == 1);
       __ Ldrb(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   } else {
-    ASSERT(mode_ == UC16);
+    DCHECK(mode_ == UC16);
     if (characters == 2) {
       __ Ldr(current_character(), MemOperand(input_end(), offset, SXTW));
     } else {
-      ASSERT(characters == 1);
+      DCHECK(characters == 1);
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64