Rename ASSERT* to DCHECK*.

src/arm64/code-stubs-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/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 382 matching lines @@
 
 void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm) {
   // Update the static counter each time a new code stub is generated.
   isolate()->counters()->code_stubs()->Increment();
 
   CodeStubInterfaceDescriptor* descriptor = GetInterfaceDescriptor();
   int param_count = descriptor->GetEnvironmentParameterCount();
   {
     // Call the runtime system in a fresh internal frame.
     FrameScope scope(masm, StackFrame::INTERNAL);
-    ASSERT((param_count == 0) ||
+    DCHECK((param_count == 0) ||
            x0.Is(descriptor->GetEnvironmentParameterRegister(param_count - 1)));
 
     // Push arguments
     MacroAssembler::PushPopQueue queue(masm);
     for (int i = 0; i < param_count; ++i) {
       queue.Queue(descriptor->GetEnvironmentParameterRegister(i));
     }
     queue.PushQueued();
 
     ExternalReference miss = descriptor->miss_handler();
     __ CallExternalReference(miss, param_count);
   }
 
   __ Ret();
 }
 
 
 void DoubleToIStub::Generate(MacroAssembler* masm) {
   Label done;
   Register input = source();
   Register result = destination();
-  ASSERT(is_truncating());
+  DCHECK(is_truncating());
 
-  ASSERT(result.Is64Bits());
-  ASSERT(jssp.Is(masm->StackPointer()));
+  DCHECK(result.Is64Bits());
+  DCHECK(jssp.Is(masm->StackPointer()));
 
   int double_offset = offset();
 
   DoubleRegister double_scratch = d0;  // only used if !skip_fastpath()
   Register scratch1 = GetAllocatableRegisterThatIsNotOneOf(input, result);
   Register scratch2 =
       GetAllocatableRegisterThatIsNotOneOf(input, result, scratch1);
 
   __ Push(scratch1, scratch2);
   // Account for saved regs if input is jssp.
@@ skipping 59 matching lines @@
 
 
 // See call site for description.
 static void EmitIdenticalObjectComparison(MacroAssembler* masm,
                                           Register left,
                                           Register right,
                                           Register scratch,
                                           FPRegister double_scratch,
                                           Label* slow,
                                           Condition cond) {
-  ASSERT(!AreAliased(left, right, scratch));
+  DCHECK(!AreAliased(left, right, scratch));
   Label not_identical, return_equal, heap_number;
   Register result = x0;
 
   __ Cmp(right, left);
   __ B(ne, &not_identical);
 
   // Test for NaN. Sadly, we can't just compare to factory::nan_value(),
   // so we do the second best thing - test it ourselves.
   // They are both equal and they are not both Smis so both of them are not
   // Smis.  If it's not a heap number, then return equal.
@@ skipping 34 matching lines @@
     __ Mov(result, LESS);     // Things aren't greater than themselves.
   } else {
     __ Mov(result, EQUAL);    // Things are <=, >=, ==, === themselves.
   }
   __ Ret();
 
   // Cases lt and gt have been handled earlier, and case ne is never seen, as
   // it is handled in the parser (see Parser::ParseBinaryExpression). We are
   // only concerned with cases ge, le and eq here.
   if ((cond != lt) && (cond != gt)) {
-    ASSERT((cond == ge) || (cond == le) || (cond == eq));
+    DCHECK((cond == ge) || (cond == le) || (cond == eq));
     __ Bind(&heap_number);
     // Left and right are identical pointers to a heap number object. Return
     // non-equal if the heap number is a NaN, and equal otherwise. Comparing
     // the number to itself will set the overflow flag iff the number is NaN.
     __ Ldr(double_scratch, FieldMemOperand(right, HeapNumber::kValueOffset));
     __ Fcmp(double_scratch, double_scratch);
     __ B(vc, &return_equal);  // Not NaN, so treat as normal heap number.
 
     if (cond == le) {
       __ Mov(result, GREATER);
@@ skipping 12 matching lines @@
 }
 
 
 // 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));
+  DCHECK(!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, 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);
 
   // Return non-zero - x0 already contains a non-zero pointer.
-  ASSERT(left.is(x0) || right.is(x0));
+  DCHECK(left.is(x0) || right.is(x0));
   Label return_not_equal;
   __ Bind(&return_not_equal);
   __ Ret();
 
   __ Bind(&right_non_object);
 
   // Check for oddballs: true, false, null, undefined.
   __ Cmp(right_type, ODDBALL_TYPE);
 
   // If right is not ODDBALL, test left. Otherwise, set eq condition.
@@ skipping 17 matching lines @@
 
 // See call site for description.
 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
                                     Register left,
                                     Register right,
                                     FPRegister left_d,
                                     FPRegister right_d,
                                     Register scratch,
                                     Label* slow,
                                     bool strict) {
-  ASSERT(!AreAliased(left, right, scratch));
-  ASSERT(!AreAliased(left_d, right_d));
-  ASSERT((left.is(x0) && right.is(x1)) ||
+  DCHECK(!AreAliased(left, right, scratch));
+  DCHECK(!AreAliased(left_d, right_d));
+  DCHECK((left.is(x0) && right.is(x1)) ||
          (right.is(x0) && left.is(x1)));
   Register result = x0;
 
   Label right_is_smi, done;
   __ JumpIfSmi(right, &right_is_smi);
 
   // Left is the smi. Check whether right is a heap number.
   if (strict) {
     // If right is not a number and left is a smi, then strict equality cannot
     // succeed. Return non-equal.
@@ skipping 52 matching lines @@
 // See call site for description.
 static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,
                                                      Register left,
                                                      Register right,
                                                      Register left_map,
                                                      Register right_map,
                                                      Register left_type,
                                                      Register right_type,
                                                      Label* possible_strings,
                                                      Label* not_both_strings) {
-  ASSERT(!AreAliased(left, right, left_map, right_map, left_type, right_type));
+  DCHECK(!AreAliased(left, right, left_map, right_map, left_type, right_type));
   Register result = x0;
 
   Label object_test;
   STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
   // TODO(all): reexamine this branch sequence for optimisation wrt branch
   // prediction.
   __ Tbnz(right_type, MaskToBit(kIsNotStringMask), &object_test);
   __ Tbnz(right_type, MaskToBit(kIsNotInternalizedMask), possible_strings);
   __ Tbnz(left_type, MaskToBit(kIsNotStringMask), not_both_strings);
   __ Tbnz(left_type, MaskToBit(kIsNotInternalizedMask), possible_strings);
@@ skipping 99 matching lines @@
   __ B(vs, &nan);  // Overflow flag set if either is NaN.
   STATIC_ASSERT((LESS == -1) && (EQUAL == 0) && (GREATER == 1));
   __ Cset(result, gt);  // gt => 1, otherwise (lt, eq) => 0 (EQUAL).
   __ Csinv(result, result, xzr, ge);  // lt => -1, gt => 1, eq => 0.
   __ Ret();
 
   __ Bind(&nan);
   // Left and/or right is a NaN. Load the result register with whatever makes
   // the comparison fail, since comparisons with NaN always fail (except ne,
   // which is filtered out at a higher level.)
-  ASSERT(cond != ne);
+  DCHECK(cond != ne);
   if ((cond == lt) || (cond == le)) {
     __ Mov(result, GREATER);
   } else {
     __ Mov(result, LESS);
   }
   __ Ret();
 
   __ Bind(&not_smis);
   // At this point we know we are dealing with two different objects, and
   // neither of them is a smi. The objects are in rhs_ and lhs_.
@@ skipping 70 matching lines @@
   // Figure out which native to call and setup the arguments.
   Builtins::JavaScript native;
   if (cond == eq) {
     native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;
   } else {
     native = Builtins::COMPARE;
     int ncr;  // NaN compare result
     if ((cond == lt) || (cond == le)) {
       ncr = GREATER;
     } else {
-      ASSERT((cond == gt) || (cond == ge));  // remaining cases
+      DCHECK((cond == gt) || (cond == ge));  // remaining cases
       ncr = LESS;
     }
     __ Mov(x10, Smi::FromInt(ncr));
     __ Push(x10);
   }
 
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ InvokeBuiltin(native, JUMP_FUNCTION);
 
@@ skipping 287 matching lines @@
     // Bail out to runtime code.
     __ Bind(&call_runtime);
     // Put the arguments back on the stack.
     __ Push(base_tagged, exponent_tagged);
     __ TailCallRuntime(Runtime::kMathPowRT, 2, 1);
 
     // Return.
     __ Bind(&done);
     __ AllocateHeapNumber(result_tagged, &call_runtime, scratch0, scratch1,
                           result_double);
-    ASSERT(result_tagged.is(x0));
+    DCHECK(result_tagged.is(x0));
     __ IncrementCounter(
         isolate()->counters()->math_pow(), 1, scratch0, scratch1);
     __ Ret();
   } else {
     AllowExternalCallThatCantCauseGC scope(masm);
     __ Mov(saved_lr, lr);
     __ Fmov(base_double, base_double_copy);
     __ Scvtf(exponent_double, exponent_integer);
     __ CallCFunction(
         ExternalReference::power_double_double_function(isolate()),
@@ skipping 83 matching lines @@
   // at the highest address:
   //
   //    jssp]argc-1]: receiver
   //    jssp[argc-2]: arg[argc-2]
   //    ...           ...
   //    jssp[1]:      arg[1]
   //    jssp[0]:      arg[0]
   //
   // The arguments are in reverse order, so that arg[argc-2] is actually the
   // first argument to the target function and arg[0] is the last.
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   const Register& argc_input = x0;
   const Register& target_input = x1;
 
   // Calculate argv, argc and the target address, and store them in
   // callee-saved registers so we can retry the call without having to reload
   // these arguments.
   // TODO(jbramley): If the first call attempt succeeds in the common case (as
   // it should), then we might be better off putting these parameters directly
   // into their argument registers, rather than using callee-saved registers and
   // preserving them on the stack.
   const Register& argv = x21;
   const Register& argc = x22;
   const Register& target = x23;
 
   // Derive argv from the stack pointer so that it points to the first argument
   // (arg[argc-2]), or just below the receiver in case there are no arguments.
   //  - Adjust for the arg[] array.
   Register temp_argv = x11;
   __ Add(temp_argv, jssp, Operand(x0, LSL, kPointerSizeLog2));
   //  - Adjust for the receiver.
   __ Sub(temp_argv, temp_argv, 1 * kPointerSize);
 
   // Enter the exit frame. Reserve three slots to preserve x21-x23 callee-saved
   // registers.
   FrameScope scope(masm, StackFrame::MANUAL);
   __ EnterExitFrame(save_doubles_, x10, 3);
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
 
   // Poke callee-saved registers into reserved space.
   __ Poke(argv, 1 * kPointerSize);
   __ Poke(argc, 2 * kPointerSize);
   __ Poke(target, 3 * kPointerSize);
 
   // We normally only keep tagged values in callee-saved registers, as they
   // could be pushed onto the stack by called stubs and functions, and on the
   // stack they can confuse the GC. However, we're only calling C functions
   // which can push arbitrary data onto the stack anyway, and so the GC won't
@@ skipping 29 matching lines @@
   //  csp -> csp[0]:   Space reserved for the return address.
   //
   // After a successful call, the exit frame, preserved registers (x21-x23) and
   // the arguments (including the receiver) are dropped or popped as
   // appropriate. The stub then returns.
   //
   // After an unsuccessful call, the exit frame and suchlike are left
   // untouched, and the stub either throws an exception by jumping to one of
   // the exception_returned label.
 
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
 
   // Prepare AAPCS64 arguments to pass to the builtin.
   __ Mov(x0, argc);
   __ Mov(x1, argv);
   __ Mov(x2, ExternalReference::isolate_address(isolate()));
 
   Label return_location;
   __ Adr(x12, &return_location);
   __ Poke(x12, 0);
 
@@ skipping 26 matching lines @@
   // The call succeeded, so unwind the stack and return.
 
   // Restore callee-saved registers x21-x23.
   __ Mov(x11, argc);
 
   __ Peek(argv, 1 * kPointerSize);
   __ Peek(argc, 2 * kPointerSize);
   __ Peek(target, 3 * kPointerSize);
 
   __ LeaveExitFrame(save_doubles_, x10, true);
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   // Pop or drop the remaining stack slots and return from the stub.
   //         jssp[24]:    Arguments array (of size argc), including receiver.
   //         jssp[16]:    Preserved x23 (used for target).
   //         jssp[8]:     Preserved x22 (used for argc).
   //         jssp[0]:     Preserved x21 (used for argv).
   __ Drop(x11);
   __ AssertFPCRState();
   __ Ret();
 
   // The stack pointer is still csp if we aren't returning, and the frame
@@ skipping 51 matching lines @@
 // See use of the CALL_GENERATED_CODE macro for example in src/execution.cc.
 // Input:
 //   x0: code entry.
 //   x1: function.
 //   x2: receiver.
 //   x3: argc.
 //   x4: argv.
 // Output:
 //   x0: result.
 void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   Register code_entry = x0;
 
   // Enable instruction instrumentation. This only works on the simulator, and
   // will have no effect on the model or real hardware.
   __ EnableInstrumentation();
 
   Label invoke, handler_entry, exit;
 
   // Push callee-saved registers and synchronize the system stack pointer (csp)
   // and the JavaScript stack pointer (jssp).
@@ skipping 33 matching lines @@
   ExternalReference js_entry_sp(Isolate::kJSEntrySPAddress, isolate());
   __ Mov(x10, ExternalReference(js_entry_sp));
   __ Ldr(x11, MemOperand(x10));
   __ Cbnz(x11, &non_outermost_js);
   __ Str(fp, MemOperand(x10));
   __ Mov(x12, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
   __ Push(x12);
   __ B(&done);
   __ Bind(&non_outermost_js);
   // We spare one instruction by pushing xzr since the marker is 0.
-  ASSERT(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME) == NULL);
+  DCHECK(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME) == NULL);
   __ Push(xzr);
   __ Bind(&done);
 
   // The frame set up looks like this:
   // jssp[0] : JS entry frame marker.
   // jssp[1] : C entry FP.
   // jssp[2] : stack frame marker.
   // jssp[3] : stack frmae marker.
   // jssp[4] : bad frame pointer 0xfff...ff   <- fp points here.
 
@@ skipping 81 matching lines @@
   __ Bind(&non_outermost_js_2);
 
   // Restore the top frame descriptors from the stack.
   __ Pop(x10);
   __ Mov(x11, ExternalReference(Isolate::kCEntryFPAddress, isolate()));
   __ Str(x10, MemOperand(x11));
 
   // Reset the stack to the callee saved registers.
   __ Drop(-EntryFrameConstants::kCallerFPOffset, kByteSizeInBytes);
   // Restore the callee-saved registers and return.
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   __ Mov(csp, jssp);
   __ SetStackPointer(csp);
   __ PopCalleeSavedRegisters();
   // After this point, we must not modify jssp because it is a callee-saved
   // register which we have just restored.
   __ Ret();
 }
 
 
 void FunctionPrototypeStub::Generate(MacroAssembler* masm) {
@@ skipping 112 matching lines @@
     __ Ldr(chain_prototype, FieldMemOperand(chain_map, Map::kPrototypeOffset));
     __ B(&loop);
   }
 
   // Return sequence when no arguments are on the stack.
   // We cannot fall through to here.
   __ Bind(&return_true);
   __ Mov(result, res_true);
   __ Bind(&return_result);
   if (HasCallSiteInlineCheck()) {
-    ASSERT(ReturnTrueFalseObject());
+    DCHECK(ReturnTrueFalseObject());
     __ Add(map_check_site, map_check_site, kDeltaToLoadBoolResult);
     __ GetRelocatedValueLocation(map_check_site, scratch2);
     __ Str(result, MemOperand(scratch2));
   } else {
     __ StoreRoot(result, Heap::kInstanceofCacheAnswerRootIndex);
   }
   __ Ret();
 
   Label object_not_null, object_not_null_or_smi;
 
@@ skipping 615 matching lines @@
   // Ensure that a RegExp stack is allocated.
   ExternalReference address_of_regexp_stack_memory_address =
       ExternalReference::address_of_regexp_stack_memory_address(isolate());
   ExternalReference address_of_regexp_stack_memory_size =
       ExternalReference::address_of_regexp_stack_memory_size(isolate());
   __ Mov(x10, address_of_regexp_stack_memory_size);
   __ Ldr(x10, MemOperand(x10));
   __ Cbz(x10, &runtime);
 
   // Check that the first argument is a JSRegExp object.
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(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, kUnexpectedTypeForRegExpDataFixedArrayExpected);
@@ skipping 16 matching lines @@
   // Check (number_of_captures + 1) * 2 <= offsets vector size
   //             number_of_captures * 2 <= offsets vector size - 2
   STATIC_ASSERT(Isolate::kJSRegexpStaticOffsetsVectorSize >= 2);
   __ Add(x10, x10, x10);
   __ Cmp(x10, Isolate::kJSRegexpStaticOffsetsVectorSize - 2);
   __ B(hi, &runtime);
 
   // Initialize offset for possibly sliced string.
   __ Mov(sliced_string_offset, 0);
 
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   __ Peek(subject, kSubjectOffset);
   __ JumpIfSmi(subject, &runtime);
 
   __ Ldr(x10, FieldMemOperand(subject, HeapObject::kMapOffset));
   __ Ldrb(string_type, FieldMemOperand(x10, Map::kInstanceTypeOffset));
 
   __ Ldr(jsstring_length, FieldMemOperand(subject, String::kLengthOffset));
 
   // Handle subject string according to its encoding and representation:
   // (1) Sequential string?  If yes, go to (5).
@@ skipping 62 matching lines @@
   STATIC_ASSERT(ExternalString::kMaxShortLength < SlicedString::kMinLength);
   __ TestAndBranchIfAnySet(string_type.X(),
                            kStringRepresentationMask,
                            &external_string);  // Go to (7).
 
   // (5) Sequential string.  Load regexp code according to encoding.
   __ Bind(&seq_string);
 
   // Check that the third argument is a positive smi less than the subject
   // string length. A negative value will be greater (unsigned comparison).
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   __ Peek(x10, kPreviousIndexOffset);
   __ JumpIfNotSmi(x10, &runtime);
   __ Cmp(jsstring_length, x10);
   __ B(ls, &runtime);
 
   // Argument 2 (x1): We need to load argument 2 (the previous index) into x1
   // before entering the exit frame.
   __ SmiUntag(x1, x10);
 
   // The third bit determines the string encoding in string_type.
   STATIC_ASSERT(kOneByteStringTag == 0x04);
   STATIC_ASSERT(kTwoByteStringTag == 0x00);
   STATIC_ASSERT(kStringEncodingMask == 0x04);
 
   // Find the code object based on the assumptions above.
   // kDataAsciiCodeOffset and kDataUC16CodeOffset are adjacent, adds an offset
   // of kPointerSize to reach the latter.
-  ASSERT_EQ(JSRegExp::kDataAsciiCodeOffset + kPointerSize,
+  DCHECK_EQ(JSRegExp::kDataAsciiCodeOffset + kPointerSize,
             JSRegExp::kDataUC16CodeOffset);
   __ Mov(x10, kPointerSize);
   // We will need the encoding later: ASCII = 0x04
   //                                  UC16  = 0x00
   __ Ands(string_encoding, string_type, kStringEncodingMask);
   __ CzeroX(x10, ne);
   __ Add(x10, regexp_data, x10);
   __ Ldr(code_object, FieldMemOperand(x10, JSRegExp::kDataAsciiCodeOffset));
 
   // (E) Carry on.  String handling is done.
 
   // Check that the irregexp code has been generated for the actual string
   // encoding. If it has, the field contains a code object otherwise it contains
   // a smi (code flushing support).
   __ JumpIfSmi(code_object, &runtime);
 
   // All checks done. Now push arguments for native regexp code.
   __ IncrementCounter(isolate()->counters()->regexp_entry_native(), 1,
                       x10,
                       x11);
 
   // Isolates: note we add an additional parameter here (isolate pointer).
   __ EnterExitFrame(false, x10, 1);
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
 
   // We have 9 arguments to pass to the regexp code, therefore we have to pass
   // one on the stack and the rest as registers.
 
   // Note that the placement of the argument on the stack isn't standard
   // AAPCS64:
   // csp[0]: Space for the return address placed by DirectCEntryStub.
   // csp[8]: Argument 9, the current isolate address.
 
   __ Mov(x10, ExternalReference::isolate_address(isolate()));
@@ skipping 83 matching lines @@
 
   // Calculate number of capture registers (number_of_captures + 1) * 2
   // and store it in the last match info.
   __ Ldrsw(x10,
            UntagSmiFieldMemOperand(regexp_data,
                                    JSRegExp::kIrregexpCaptureCountOffset));
   __ Add(x10, x10, x10);
   __ Add(number_of_capture_registers, x10, 2);
 
   // Check that the fourth object is a JSArray object.
-  ASSERT(jssp.Is(__ StackPointer()));
+  DCHECK(jssp.Is(__ StackPointer()));
   __ Peek(x10, kLastMatchInfoOffset);
   __ JumpIfSmi(x10, &runtime);
   __ JumpIfNotObjectType(x10, x11, x11, JS_ARRAY_TYPE, &runtime);
 
   // Check that the JSArray is the fast case.
   __ Ldr(last_match_info_elements,
          FieldMemOperand(x10, JSArray::kElementsOffset));
   __ Ldr(x10,
          FieldMemOperand(last_match_info_elements, HeapObject::kMapOffset));
   __ JumpIfNotRoot(x10, Heap::kFixedArrayMapRootIndex, &runtime);
@@ skipping 161 matching lines @@
 
 
 static void GenerateRecordCallTarget(MacroAssembler* masm,
                                      Register argc,
                                      Register function,
                                      Register feedback_vector,
                                      Register index,
                                      Register scratch1,
                                      Register scratch2) {
   ASM_LOCATION("GenerateRecordCallTarget");
-  ASSERT(!AreAliased(scratch1, scratch2,
+  DCHECK(!AreAliased(scratch1, scratch2,
                      argc, function, feedback_vector, index));
   // Cache the called function in a feedback vector slot. Cache states are
   // uninitialized, monomorphic (indicated by a JSFunction), and megamorphic.
   //  argc :            number of arguments to the construct function
   //  function :        the function to call
   //  feedback_vector : the feedback vector
   //  index :           slot in feedback vector (smi)
   Label initialize, done, miss, megamorphic, not_array_function;
 
-  ASSERT_EQ(*TypeFeedbackInfo::MegamorphicSentinel(masm->isolate()),
+  DCHECK_EQ(*TypeFeedbackInfo::MegamorphicSentinel(masm->isolate()),
             masm->isolate()->heap()->megamorphic_symbol());
-  ASSERT_EQ(*TypeFeedbackInfo::UninitializedSentinel(masm->isolate()),
+  DCHECK_EQ(*TypeFeedbackInfo::UninitializedSentinel(masm->isolate()),
             masm->isolate()->heap()->uninitialized_symbol());
 
   // Load the cache state.
   __ Add(scratch1, feedback_vector,
          Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(scratch1, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
 
   // A monomorphic cache hit or an already megamorphic state: invoke the
   // function without changing the state.
   __ Cmp(scratch1, function);
@@ skipping 44 matching lines @@
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       CreateAllocationSiteStub create_stub(masm->isolate());
 
       // Arguments register must be smi-tagged to call out.
       __ SmiTag(argc);
       __ Push(argc, function, feedback_vector, index);
 
       // CreateAllocationSiteStub expect the feedback vector in x2 and the slot
       // index in x3.
-      ASSERT(feedback_vector.Is(x2) && index.Is(x3));
+      DCHECK(feedback_vector.Is(x2) && index.Is(x3));
       __ CallStub(&create_stub);
 
       __ Pop(index, feedback_vector, function, argc);
       __ SmiUntag(argc);
     }
     __ B(&done);
 
     __ Bind(&not_array_function);
   }
 
@@ skipping 405 matching lines @@
               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.
   __ Push(object_, index_);
   if (index_flags_ == STRING_INDEX_IS_NUMBER) {
     __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
   } else {
-    ASSERT(index_flags_ == STRING_INDEX_IS_ARRAY_INDEX);
+    DCHECK(index_flags_ == STRING_INDEX_IS_ARRAY_INDEX);
     // NumberToSmi discards numbers that are not exact integers.
     __ CallRuntime(Runtime::kNumberToSmi, 1);
   }
   // Save the conversion result before the pop instructions below
   // have a chance to overwrite it.
   __ Mov(index_, x0);
   __ Pop(object_);
   // Reload the instance type.
   __ Ldr(result_, FieldMemOperand(object_, HeapObject::kMapOffset));
   __ Ldrb(result_, FieldMemOperand(result_, Map::kInstanceTypeOffset));
@@ skipping 46 matching lines @@
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
   // Inputs are in x0 (lhs) and x1 (rhs).
-  ASSERT(state_ == CompareIC::SMI);
+  DCHECK(state_ == CompareIC::SMI);
   ASM_LOCATION("ICCompareStub[Smis]");
   Label miss;
   // Bail out (to 'miss') unless both x0 and x1 are smis.
   __ JumpIfEitherNotSmi(x0, x1, &miss);
 
   if (GetCondition() == eq) {
     // For equality we do not care about the sign of the result.
     __ Sub(x0, x0, x1);
   } else {
     // Untag before subtracting to avoid handling overflow.
     __ SmiUntag(x1);
     __ Sub(x0, x1, Operand::UntagSmi(x0));
   }
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateNumbers(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::NUMBER);
+  DCHECK(state_ == CompareIC::NUMBER);
   ASM_LOCATION("ICCompareStub[HeapNumbers]");
 
   Label unordered, maybe_undefined1, maybe_undefined2;
   Label miss, handle_lhs, values_in_d_regs;
   Label untag_rhs, untag_lhs;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
   FPRegister rhs_d = d0;
@@ skipping 47 matching lines @@
   if (Token::IsOrderedRelationalCompareOp(op_)) {
     __ JumpIfRoot(lhs, Heap::kUndefinedValueRootIndex, &unordered);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateInternalizedStrings(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::INTERNALIZED_STRING);
+  DCHECK(state_ == CompareIC::INTERNALIZED_STRING);
   ASM_LOCATION("ICCompareStub[InternalizedStrings]");
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(lhs, rhs, &miss);
 
@@ skipping 17 matching lines @@
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateUniqueNames(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::UNIQUE_NAME);
+  DCHECK(state_ == CompareIC::UNIQUE_NAME);
   ASM_LOCATION("ICCompareStub[UniqueNames]");
-  ASSERT(GetCondition() == eq);
+  DCHECK(GetCondition() == eq);
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   Register lhs_instance_type = w2;
   Register rhs_instance_type = w3;
 
   // Check that both operands are heap objects.
@@ skipping 16 matching lines @@
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateStrings(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::STRING);
+  DCHECK(state_ == CompareIC::STRING);
   ASM_LOCATION("ICCompareStub[Strings]");
 
   Label miss;
 
   bool equality = Token::IsEqualityOp(op_);
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
@@ skipping 20 matching lines @@
   __ Mov(result, EQUAL);
   __ Ret();
 
   __ Bind(&not_equal);
   // Handle not identical strings
 
   // Check that both strings are internalized strings. If they are, we're done
   // because we already know they are not identical. We know they are both
   // strings.
   if (equality) {
-    ASSERT(GetCondition() == eq);
+    DCHECK(GetCondition() == eq);
     STATIC_ASSERT(kInternalizedTag == 0);
     Label not_internalized_strings;
     __ Orr(x12, lhs_type, rhs_type);
     __ TestAndBranchIfAnySet(
         x12, kIsNotInternalizedMask, &not_internalized_strings);
     // Result is in rhs (x0), and not EQUAL, as rhs is not a smi.
     __ Ret();
     __ Bind(&not_internalized_strings);
   }
 
@@ skipping 19 matching lines @@
   } else {
     __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateObjects(MacroAssembler* masm) {
-  ASSERT(state_ == CompareIC::OBJECT);
+  DCHECK(state_ == CompareIC::OBJECT);
   ASM_LOCATION("ICCompareStub[Objects]");
 
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   __ JumpIfEitherSmi(rhs, lhs, &miss);
 
   __ JumpIfNotObjectType(rhs, x10, x10, JS_OBJECT_TYPE, &miss);
   __ JumpIfNotObjectType(lhs, x10, x10, JS_OBJECT_TYPE, &miss);
 
-  ASSERT(GetCondition() == eq);
+  DCHECK(GetCondition() == eq);
   __ Sub(result, rhs, lhs);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateKnownObjects(MacroAssembler* masm) {
   ASM_LOCATION("ICCompareStub[KnownObjects]");
@@ skipping 55 matching lines @@
   }
 
   // Tail-call to the new stub.
   __ Jump(stub_entry);
 }
 
 
 void StringHelper::GenerateHashInit(MacroAssembler* masm,
                                     Register hash,
                                     Register character) {
-  ASSERT(!AreAliased(hash, character));
+  DCHECK(!AreAliased(hash, character));
 
   // hash = character + (character << 10);
   __ LoadRoot(hash, Heap::kHashSeedRootIndex);
   // Untag smi seed and add the character.
   __ Add(hash, character, Operand::UntagSmi(hash));
 
   // Compute hashes modulo 2^32 using a 32-bit W register.
   Register hash_w = hash.W();
 
   // hash += hash << 10;
   __ Add(hash_w, hash_w, Operand(hash_w, LSL, 10));
   // hash ^= hash >> 6;
   __ Eor(hash_w, hash_w, Operand(hash_w, LSR, 6));
 }
 
 
 void StringHelper::GenerateHashAddCharacter(MacroAssembler* masm,
                                             Register hash,
                                             Register character) {
-  ASSERT(!AreAliased(hash, character));
+  DCHECK(!AreAliased(hash, character));
 
   // hash += character;
   __ Add(hash, hash, character);
 
   // Compute hashes modulo 2^32 using a 32-bit W register.
   Register hash_w = hash.W();
 
   // hash += hash << 10;
   __ Add(hash_w, hash_w, Operand(hash_w, LSL, 10));
   // hash ^= hash >> 6;
   __ Eor(hash_w, hash_w, Operand(hash_w, LSR, 6));
 }
 
 
 void StringHelper::GenerateHashGetHash(MacroAssembler* masm,
                                        Register hash,
                                        Register scratch) {
   // Compute hashes modulo 2^32 using a 32-bit W register.
   Register hash_w = hash.W();
   Register scratch_w = scratch.W();
-  ASSERT(!AreAliased(hash_w, scratch_w));
+  DCHECK(!AreAliased(hash_w, scratch_w));
 
   // hash += hash << 3;
   __ Add(hash_w, hash_w, Operand(hash_w, LSL, 3));
   // hash ^= hash >> 11;
   __ Eor(hash_w, hash_w, Operand(hash_w, LSR, 11));
   // hash += hash << 15;
   __ Add(hash_w, hash_w, Operand(hash_w, LSL, 15));
 
   __ Ands(hash_w, hash_w, String::kHashBitMask);
 
@@ skipping 253 matching lines @@
   generator.SkipSlow(masm, &runtime);
 }
 
 
 void StringCompareStub::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
                                                       Register left,
                                                       Register right,
                                                       Register scratch1,
                                                       Register scratch2,
                                                       Register scratch3) {
-  ASSERT(!AreAliased(left, right, scratch1, scratch2, scratch3));
+  DCHECK(!AreAliased(left, right, scratch1, scratch2, scratch3));
   Register result = x0;
   Register left_length = scratch1;
   Register right_length = scratch2;
 
   // Compare lengths. If lengths differ, strings can't be equal. Lengths are
   // smis, and don't need to be untagged.
   Label strings_not_equal, check_zero_length;
   __ Ldr(left_length, FieldMemOperand(left, String::kLengthOffset));
   __ Ldr(right_length, FieldMemOperand(right, String::kLengthOffset));
   __ Cmp(left_length, right_length);
@@ skipping 22 matching lines @@
 }
 
 
 void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                                         Register left,
                                                         Register right,
                                                         Register scratch1,
                                                         Register scratch2,
                                                         Register scratch3,
                                                         Register scratch4) {
-  ASSERT(!AreAliased(left, right, scratch1, scratch2, scratch3, scratch4));
+  DCHECK(!AreAliased(left, right, scratch1, scratch2, scratch3, scratch4));
   Label result_not_equal, compare_lengths;
 
   // Find minimum length and length difference.
   Register length_delta = scratch3;
   __ Ldr(scratch1, FieldMemOperand(left, String::kLengthOffset));
   __ Ldr(scratch2, FieldMemOperand(right, String::kLengthOffset));
   __ Subs(length_delta, scratch1, scratch2);
 
   Register min_length = scratch1;
   __ Csel(min_length, scratch2, scratch1, gt);
   __ Cbz(min_length, &compare_lengths);
 
   // Compare loop.
   GenerateAsciiCharsCompareLoop(masm,
                                 left, right, min_length, scratch2, scratch4,
                                 &result_not_equal);
 
   // Compare lengths - strings up to min-length are equal.
   __ Bind(&compare_lengths);
 
-  ASSERT(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
+  DCHECK(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
 
   // Use length_delta as result if it's zero.
   Register result = x0;
   __ Subs(result, length_delta, 0);
 
   __ Bind(&result_not_equal);
   Register greater = x10;
   Register less = x11;
   __ Mov(greater, Smi::FromInt(GREATER));
   __ Mov(less, Smi::FromInt(LESS));
   __ CmovX(result, greater, gt);
   __ CmovX(result, less, lt);
   __ Ret();
 }
 
 
 void StringCompareStub::GenerateAsciiCharsCompareLoop(
     MacroAssembler* masm,
     Register left,
     Register right,
     Register length,
     Register scratch1,
     Register scratch2,
     Label* chars_not_equal) {
-  ASSERT(!AreAliased(left, right, length, scratch1, scratch2));
+  DCHECK(!AreAliased(left, right, length, scratch1, scratch2));
 
   // Change index to run from -length to -1 by adding length to string
   // start. This means that loop ends when index reaches zero, which
   // doesn't need an additional compare.
   __ SmiUntag(length);
   __ Add(scratch1, length, SeqOneByteString::kHeaderSize - kHeapObjectTag);
   __ Add(left, left, scratch1);
   __ Add(right, right, scratch1);
 
   Register index = length;
@@ skipping 119 matching lines @@
   InformIncrementalMarker(masm);
   regs_.Restore(masm);  // Restore the extra scratch registers we used.
   __ Ret();
 }
 
 
 void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) {
   regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_);
   Register address =
     x0.Is(regs_.address()) ? regs_.scratch0() : regs_.address();
-  ASSERT(!address.Is(regs_.object()));
-  ASSERT(!address.Is(x0));
+  DCHECK(!address.Is(regs_.object()));
+  DCHECK(!address.Is(x0));
   __ Mov(address, regs_.address());
   __ Mov(x0, regs_.object());
   __ Mov(x1, address);
   __ Mov(x2, ExternalReference::isolate_address(isolate()));
 
   AllowExternalCallThatCantCauseGC scope(masm);
   ExternalReference function =
       ExternalReference::incremental_marking_record_write_function(
           isolate());
   __ CallCFunction(function, 3, 0);
@@ skipping 219 matching lines @@
 
 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
   if (masm->isolate()->function_entry_hook() != NULL) {
     ProfileEntryHookStub stub(masm->isolate());
     Assembler::BlockConstPoolScope no_const_pools(masm);
     DontEmitDebugCodeScope no_debug_code(masm);
     Label entry_hook_call_start;
     __ Bind(&entry_hook_call_start);
     __ Push(lr);
     __ CallStub(&stub);
-    ASSERT(masm->SizeOfCodeGeneratedSince(&entry_hook_call_start) ==
+    DCHECK(masm->SizeOfCodeGeneratedSince(&entry_hook_call_start) ==
            GetProfileEntryHookCallSize(masm));
 
     __ Pop(lr);
   }
 }
 
 
 void ProfileEntryHookStub::Generate(MacroAssembler* masm) {
   MacroAssembler::NoUseRealAbortsScope no_use_real_aborts(masm);
 
   // Save all kCallerSaved registers (including lr), since this can be called
   // from anywhere.
   // TODO(jbramley): What about FP registers?
   __ PushCPURegList(kCallerSaved);
-  ASSERT(kCallerSaved.IncludesAliasOf(lr));
+  DCHECK(kCallerSaved.IncludesAliasOf(lr));
   const int kNumSavedRegs = kCallerSaved.Count();
 
   // Compute the function's address as the first argument.
   __ Sub(x0, lr, GetProfileEntryHookCallSize(masm));
 
 #if V8_HOST_ARCH_ARM64
   uintptr_t entry_hook =
       reinterpret_cast<uintptr_t>(isolate()->function_entry_hook());
   __ Mov(x10, entry_hook);
 #else
@@ skipping 40 matching lines @@
   __ AssertFPCRState();
   __ Ret();
 
   __ SetStackPointer(old_stack_pointer);
 }
 
 void DirectCEntryStub::GenerateCall(MacroAssembler* masm,
                                     Register target) {
   // Make sure the caller configured the stack pointer (see comment in
   // DirectCEntryStub::Generate).
-  ASSERT(csp.Is(__ StackPointer()));
+  DCHECK(csp.Is(__ StackPointer()));
 
   intptr_t code =
       reinterpret_cast<intptr_t>(GetCode().location());
   __ Mov(lr, Operand(code, RelocInfo::CODE_TARGET));
   __ Mov(x10, target);
   // Branch to the stub.
   __ Blr(lr);
 }
 
 
 // Probe the name dictionary in the 'elements' register.
 // Jump to the 'done' label if a property with the given name is found.
 // Jump to the 'miss' label otherwise.
 //
 // If lookup was successful 'scratch2' will be equal to elements + 4 * index.
 // 'elements' and 'name' registers are preserved on miss.
 void NameDictionaryLookupStub::GeneratePositiveLookup(
     MacroAssembler* masm,
     Label* miss,
     Label* done,
     Register elements,
     Register name,
     Register scratch1,
     Register scratch2) {
-  ASSERT(!AreAliased(elements, name, scratch1, scratch2));
+  DCHECK(!AreAliased(elements, name, scratch1, scratch2));
 
   // Assert that name contains a string.
   __ AssertName(name);
 
   // Compute the capacity mask.
   __ Ldrsw(scratch1, UntagSmiFieldMemOperand(elements, kCapacityOffset));
   __ Sub(scratch1, scratch1, 1);
 
   // Generate an unrolled loop that performs a few probes before giving up.
   for (int i = 0; i < kInlinedProbes; i++) {
     // Compute the masked index: (hash + i + i * i) & mask.
     __ Ldr(scratch2, FieldMemOperand(name, Name::kHashFieldOffset));
     if (i > 0) {
       // Add the probe offset (i + i * i) left shifted to avoid right shifting
       // the hash in a separate instruction. The value hash + i + i * i is right
       // shifted in the following and instruction.
-      ASSERT(NameDictionary::GetProbeOffset(i) <
+      DCHECK(NameDictionary::GetProbeOffset(i) <
           1 << (32 - Name::kHashFieldOffset));
       __ Add(scratch2, scratch2, Operand(
           NameDictionary::GetProbeOffset(i) << Name::kHashShift));
     }
     __ And(scratch2, scratch1, Operand(scratch2, LSR, Name::kHashShift));
 
     // Scale the index by multiplying by the element size.
-    ASSERT(NameDictionary::kEntrySize == 3);
+    DCHECK(NameDictionary::kEntrySize == 3);
     __ Add(scratch2, scratch2, Operand(scratch2, LSL, 1));
 
     // Check if the key is identical to the name.
     UseScratchRegisterScope temps(masm);
     Register scratch3 = temps.AcquireX();
     __ Add(scratch2, elements, Operand(scratch2, LSL, kPointerSizeLog2));
     __ Ldr(scratch3, FieldMemOperand(scratch2, kElementsStartOffset));
     __ Cmp(name, scratch3);
     __ B(eq, done);
   }
 
   // The inlined probes didn't find the entry.
   // Call the complete stub to scan the whole dictionary.
 
   CPURegList spill_list(CPURegister::kRegister, kXRegSizeInBits, 0, 6);
   spill_list.Combine(lr);
   spill_list.Remove(scratch1);
   spill_list.Remove(scratch2);
 
   __ PushCPURegList(spill_list);
 
   if (name.is(x0)) {
-    ASSERT(!elements.is(x1));
+    DCHECK(!elements.is(x1));
     __ Mov(x1, name);
     __ Mov(x0, elements);
   } else {
     __ Mov(x0, elements);
     __ Mov(x1, name);
   }
 
   Label not_found;
   NameDictionaryLookupStub stub(masm->isolate(), POSITIVE_LOOKUP);
   __ CallStub(&stub);
   __ Cbz(x0, &not_found);
   __ Mov(scratch2, x2);  // Move entry index into scratch2.
   __ PopCPURegList(spill_list);
   __ B(done);
 
   __ Bind(&not_found);
   __ PopCPURegList(spill_list);
   __ B(miss);
 }
 
 
 void NameDictionaryLookupStub::GenerateNegativeLookup(MacroAssembler* masm,
                                                       Label* miss,
                                                       Label* done,
                                                       Register receiver,
                                                       Register properties,
                                                       Handle<Name> name,
                                                       Register scratch0) {
-  ASSERT(!AreAliased(receiver, properties, scratch0));
-  ASSERT(name->IsUniqueName());
+  DCHECK(!AreAliased(receiver, properties, scratch0));
+  DCHECK(name->IsUniqueName());
   // If names of slots in range from 1 to kProbes - 1 for the hash value are
   // not equal to the name and kProbes-th slot is not used (its name is the
   // undefined value), it guarantees the hash table doesn't contain the
   // property. It's true even if some slots represent deleted properties
   // (their names are the hole value).
   for (int i = 0; i < kInlinedProbes; i++) {
     // scratch0 points to properties hash.
     // Compute the masked index: (hash + i + i * i) & mask.
     Register index = scratch0;
     // Capacity is smi 2^n.
     __ Ldrsw(index, UntagSmiFieldMemOperand(properties, kCapacityOffset));
     __ Sub(index, index, 1);
     __ And(index, index, name->Hash() + NameDictionary::GetProbeOffset(i));
 
     // Scale the index by multiplying by the entry size.
-    ASSERT(NameDictionary::kEntrySize == 3);
+    DCHECK(NameDictionary::kEntrySize == 3);
     __ Add(index, index, Operand(index, LSL, 1));  // index *= 3.
 
     Register entity_name = scratch0;
     // Having undefined at this place means the name is not contained.
     Register tmp = index;
     __ Add(tmp, properties, Operand(index, LSL, kPointerSizeLog2));
     __ Ldr(entity_name, FieldMemOperand(tmp, kElementsStartOffset));
 
     __ JumpIfRoot(entity_name, Heap::kUndefinedValueRootIndex, done);
 
@@ skipping 60 matching lines @@
   __ Ldr(hash, FieldMemOperand(key, Name::kHashFieldOffset));
   __ LoadRoot(undefined, Heap::kUndefinedValueRootIndex);
 
   for (int i = kInlinedProbes; i < kTotalProbes; i++) {
     // Compute the masked index: (hash + i + i * i) & mask.
     // Capacity is smi 2^n.
     if (i > 0) {
       // Add the probe offset (i + i * i) left shifted to avoid right shifting
       // the hash in a separate instruction. The value hash + i + i * i is right
       // shifted in the following and instruction.
-      ASSERT(NameDictionary::GetProbeOffset(i) <
+      DCHECK(NameDictionary::GetProbeOffset(i) <
              1 << (32 - Name::kHashFieldOffset));
       __ Add(index, hash,
              NameDictionary::GetProbeOffset(i) << Name::kHashShift);
     } else {
       __ Mov(index, hash);
     }
     __ And(index, mask, Operand(index, LSR, Name::kHashShift));
 
     // Scale the index by multiplying by the entry size.
-    ASSERT(NameDictionary::kEntrySize == 3);
+    DCHECK(NameDictionary::kEntrySize == 3);
     __ Add(index, index, Operand(index, LSL, 1));  // index *= 3.
 
     __ Add(index, dictionary, Operand(index, LSL, kPointerSizeLog2));
     __ Ldr(entry_key, FieldMemOperand(index, kElementsStartOffset));
 
     // Having undefined at this place means the name is not contained.
     __ Cmp(entry_key, undefined);
     __ B(eq, &not_in_dictionary);
 
     // Stop if found the property.
@@ skipping 415 matching lines @@
   // not controlled by GC.
   const int kApiStackSpace = 4;
 
   // Allocate space for CallApiFunctionAndReturn can store some scratch
   // registeres on the stack.
   const int kCallApiFunctionSpillSpace = 4;
 
   FrameScope frame_scope(masm, StackFrame::MANUAL);
   __ EnterExitFrame(false, x10, kApiStackSpace + kCallApiFunctionSpillSpace);
 
-  ASSERT(!AreAliased(x0, api_function_address));
+  DCHECK(!AreAliased(x0, api_function_address));
   // x0 = FunctionCallbackInfo&
   // Arguments is after the return address.
   __ Add(x0, masm->StackPointer(), 1 * kPointerSize);
   // FunctionCallbackInfo::implicit_args_ and FunctionCallbackInfo::values_
   __ Add(x10, args, Operand((FCA::kArgsLength - 1 + argc) * kPointerSize));
   __ Stp(args, x10, MemOperand(x0, 0 * kPointerSize));
   // FunctionCallbackInfo::length_ = argc and
   // FunctionCallbackInfo::is_construct_call = 0
   __ Mov(x10, argc);
   __ Stp(x10, xzr, MemOperand(x0, 2 * kPointerSize));
@@ skipping 64 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64