Rename ASSERT* to DCHECK*.

src/arm64/ic-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/arm64/assembler-arm64.h"
 #include "src/code-stubs.h"
@@ skipping 34 matching lines @@
 // The scratch registers need to be different from elements, name and result.
 // The generated code assumes that the receiver has slow properties,
 // is not a global object and does not have interceptors.
 static void GenerateDictionaryLoad(MacroAssembler* masm,
                                    Label* miss,
                                    Register elements,
                                    Register name,
                                    Register result,
                                    Register scratch1,
                                    Register scratch2) {
-  ASSERT(!AreAliased(elements, name, scratch1, scratch2));
-  ASSERT(!AreAliased(result, scratch1, scratch2));
+  DCHECK(!AreAliased(elements, name, scratch1, scratch2));
+  DCHECK(!AreAliased(result, scratch1, scratch2));
 
   Label done;
 
   // Probe the dictionary.
   NameDictionaryLookupStub::GeneratePositiveLookup(masm,
                                                    miss,
                                                    &done,
                                                    elements,
                                                    name,
                                                    scratch1,
@@ skipping 25 matching lines @@
 //
 // The generated code assumes that the receiver has slow properties,
 // is not a global object and does not have interceptors.
 static void GenerateDictionaryStore(MacroAssembler* masm,
                                     Label* miss,
                                     Register elements,
                                     Register name,
                                     Register value,
                                     Register scratch1,
                                     Register scratch2) {
-  ASSERT(!AreAliased(elements, name, value, scratch1, scratch2));
+  DCHECK(!AreAliased(elements, name, value, scratch1, scratch2));
 
   Label done;
 
   // Probe the dictionary.
   NameDictionaryLookupStub::GeneratePositiveLookup(masm,
                                                    miss,
                                                    &done,
                                                    elements,
                                                    name,
                                                    scratch1,
@@ skipping 27 matching lines @@
 
 // Checks the receiver for special cases (value type, slow case bits).
 // Falls through for regular JS object and return the map of the
 // receiver in 'map_scratch' if the receiver is not a SMI.
 static void GenerateKeyedLoadReceiverCheck(MacroAssembler* masm,
                                            Register receiver,
                                            Register map_scratch,
                                            Register scratch,
                                            int interceptor_bit,
                                            Label* slow) {
-  ASSERT(!AreAliased(map_scratch, scratch));
+  DCHECK(!AreAliased(map_scratch, scratch));
 
   // Check that the object isn't a smi.
   __ JumpIfSmi(receiver, slow);
   // Get the map of the receiver.
   __ Ldr(map_scratch, FieldMemOperand(receiver, HeapObject::kMapOffset));
   // Check bit field.
   __ Ldrb(scratch, FieldMemOperand(map_scratch, Map::kBitFieldOffset));
   __ Tbnz(scratch, Map::kIsAccessCheckNeeded, slow);
   __ Tbnz(scratch, interceptor_bit, slow);
 
@@ skipping 28 matching lines @@
 //                used by further computation.
 static void GenerateFastArrayLoad(MacroAssembler* masm,
                                   Register receiver,
                                   Register key,
                                   Register elements,
                                   Register elements_map,
                                   Register scratch2,
                                   Register result,
                                   Label* not_fast_array,
                                   Label* slow) {
-  ASSERT(!AreAliased(receiver, key, elements, elements_map, scratch2));
+  DCHECK(!AreAliased(receiver, key, elements, elements_map, scratch2));
 
   // Check for fast array.
   __ Ldr(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
   if (not_fast_array != NULL) {
     // Check that the object is in fast mode and writable.
     __ Ldr(elements_map, FieldMemOperand(elements, HeapObject::kMapOffset));
     __ JumpIfNotRoot(elements_map, Heap::kFixedArrayMapRootIndex,
                      not_fast_array);
   } else {
     __ AssertFastElements(elements);
@@ skipping 28 matching lines @@
 // Falls through if a key is a unique name.
 // The map of the key is returned in 'map_scratch'.
 // If the jump to 'index_string' is done the hash of the key is left
 // in 'hash_scratch'.
 static void GenerateKeyNameCheck(MacroAssembler* masm,
                                  Register key,
                                  Register map_scratch,
                                  Register hash_scratch,
                                  Label* index_string,
                                  Label* not_unique) {
-  ASSERT(!AreAliased(key, map_scratch, hash_scratch));
+  DCHECK(!AreAliased(key, map_scratch, hash_scratch));
 
   // Is the key a name?
   Label unique;
   __ JumpIfObjectType(key, map_scratch, hash_scratch, LAST_UNIQUE_NAME_TYPE,
                       not_unique, hi);
   STATIC_ASSERT(LAST_UNIQUE_NAME_TYPE == FIRST_NONSTRING_TYPE);
   __ B(eq, &unique);
 
   // Is the string an array index with cached numeric value?
   __ Ldr(hash_scratch.W(), FieldMemOperand(key, Name::kHashFieldOffset));
@@ skipping 18 matching lines @@
 // left with the object's elements map. Otherwise, it is used as a scratch
 // register.
 static MemOperand GenerateMappedArgumentsLookup(MacroAssembler* masm,
                                                 Register object,
                                                 Register key,
                                                 Register map,
                                                 Register scratch1,
                                                 Register scratch2,
                                                 Label* unmapped_case,
                                                 Label* slow_case) {
-  ASSERT(!AreAliased(object, key, map, scratch1, scratch2));
+  DCHECK(!AreAliased(object, key, map, scratch1, scratch2));
 
   Heap* heap = masm->isolate()->heap();
 
   // Check that the receiver is a JSObject. Because of the elements
   // map check later, we do not need to check for interceptors or
   // whether it requires access checks.
   __ JumpIfSmi(object, slow_case);
   // Check that the object is some kind of JSObject.
   __ JumpIfObjectType(object, map, scratch1, FIRST_JS_RECEIVER_TYPE,
                       slow_case, lt);
@@ skipping 34 matching lines @@
 }
 
 
 // The 'parameter_map' register must be loaded with the parameter map of the
 // arguments object and is overwritten.
 static MemOperand GenerateUnmappedArgumentsLookup(MacroAssembler* masm,
                                                   Register key,
                                                   Register parameter_map,
                                                   Register scratch,
                                                   Label* slow_case) {
-  ASSERT(!AreAliased(key, parameter_map, scratch));
+  DCHECK(!AreAliased(key, parameter_map, scratch));
 
   // Element is in arguments backing store, which is referenced by the
   // second element of the parameter_map.
   const int kBackingStoreOffset = FixedArray::kHeaderSize + kPointerSize;
   Register backing_store = parameter_map;
   __ Ldr(backing_store, FieldMemOperand(parameter_map, kBackingStoreOffset));
   Handle<Map> fixed_array_map(masm->isolate()->heap()->fixed_array_map());
   __ CheckMap(
       backing_store, scratch, fixed_array_map, slow_case, DONT_DO_SMI_CHECK);
   __ Ldr(scratch, FieldMemOperand(backing_store, FixedArray::kLengthOffset));
   __ Cmp(key, scratch);
   __ B(hs, slow_case);
 
   __ Add(backing_store,
          backing_store,
          FixedArray::kHeaderSize - kHeapObjectTag);
   __ SmiUntag(scratch, key);
   return MemOperand(backing_store, scratch, LSL, kPointerSizeLog2);
 }
 
 
 void LoadIC::GenerateMegamorphic(MacroAssembler* masm) {
   // The return address is in lr.
   Register receiver = ReceiverRegister();
   Register name = NameRegister();
-  ASSERT(receiver.is(x1));
-  ASSERT(name.is(x2));
+  DCHECK(receiver.is(x1));
+  DCHECK(name.is(x2));
 
   // Probe the stub cache.
   Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
       Code::ComputeHandlerFlags(Code::LOAD_IC));
   masm->isolate()->stub_cache()->GenerateProbe(
       masm, flags, receiver, name, x3, x4, x5, x6);
 
   // Cache miss: Jump to runtime.
   GenerateMiss(masm);
 }
 
 
 void LoadIC::GenerateNormal(MacroAssembler* masm) {
   Register dictionary = x0;
-  ASSERT(!dictionary.is(ReceiverRegister()));
-  ASSERT(!dictionary.is(NameRegister()));
+  DCHECK(!dictionary.is(ReceiverRegister()));
+  DCHECK(!dictionary.is(NameRegister()));
   Label slow;
 
   __ Ldr(dictionary,
          FieldMemOperand(ReceiverRegister(), JSObject::kPropertiesOffset));
   GenerateDictionaryLoad(masm, &slow, dictionary, NameRegister(), x0, x3, x4);
   __ Ret();
 
   // Dictionary load failed, go slow (but don't miss).
   __ Bind(&slow);
   GenerateRuntimeGetProperty(masm);
@@ skipping 20 matching lines @@
   __ Push(ReceiverRegister(), NameRegister());
   __ TailCallRuntime(Runtime::kGetProperty, 2, 1);
 }
 
 
 void KeyedLoadIC::GenerateSloppyArguments(MacroAssembler* masm) {
   // The return address is in lr.
   Register result = x0;
   Register receiver = ReceiverRegister();
   Register key = NameRegister();
-  ASSERT(receiver.is(x1));
-  ASSERT(key.is(x2));
+  DCHECK(receiver.is(x1));
+  DCHECK(key.is(x2));
 
   Label miss, unmapped;
 
   Register map_scratch = x0;
   MemOperand mapped_location = GenerateMappedArgumentsLookup(
       masm, receiver, key, map_scratch, x3, x4, &unmapped, &miss);
   __ Ldr(result, mapped_location);
   __ Ret();
 
   __ Bind(&unmapped);
   // Parameter map is left in map_scratch when a jump on unmapped is done.
   MemOperand unmapped_location =
       GenerateUnmappedArgumentsLookup(masm, key, map_scratch, x3, &miss);
   __ Ldr(result, unmapped_location);
   __ JumpIfRoot(result, Heap::kTheHoleValueRootIndex, &miss);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void KeyedStoreIC::GenerateSloppyArguments(MacroAssembler* masm) {
   ASM_LOCATION("KeyedStoreIC::GenerateSloppyArguments");
   Label slow, notin;
   Register value = ValueRegister();
   Register key = NameRegister();
   Register receiver = ReceiverRegister();
-  ASSERT(receiver.is(x1));
-  ASSERT(key.is(x2));
-  ASSERT(value.is(x0));
+  DCHECK(receiver.is(x1));
+  DCHECK(key.is(x2));
+  DCHECK(value.is(x0));
 
   Register map = x3;
 
   // These registers are used by GenerateMappedArgumentsLookup to build a
   // MemOperand. They are live for as long as the MemOperand is live.
   Register mapped1 = x4;
   Register mapped2 = x5;
 
   MemOperand mapped =
       GenerateMappedArgumentsLookup(masm, receiver, key, map,
@@ skipping 40 matching lines @@
 
   __ TailCallExternalReference(ref, 2, 1);
 }
 
 
 // IC register specifications
 const Register LoadIC::ReceiverRegister() { return x1; }
 const Register LoadIC::NameRegister() { return x2; }
 
 const Register LoadIC::SlotRegister() {
-  ASSERT(FLAG_vector_ics);
+  DCHECK(FLAG_vector_ics);
   return x0;
 }
 
 
 const Register LoadIC::VectorRegister() {
-  ASSERT(FLAG_vector_ics);
+  DCHECK(FLAG_vector_ics);
   return x3;
 }
 
 
 const Register StoreIC::ReceiverRegister() { return x1; }
 const Register StoreIC::NameRegister() { return x2; }
 const Register StoreIC::ValueRegister() { return x0; }
 
 
 const Register KeyedStoreIC::MapRegister() {
@@ skipping 10 matching lines @@
 
 static void GenerateKeyedLoadWithSmiKey(MacroAssembler* masm,
                                         Register key,
                                         Register receiver,
                                         Register scratch1,
                                         Register scratch2,
                                         Register scratch3,
                                         Register scratch4,
                                         Register scratch5,
                                         Label *slow) {
-  ASSERT(!AreAliased(
+  DCHECK(!AreAliased(
       key, receiver, scratch1, scratch2, scratch3, scratch4, scratch5));
 
   Isolate* isolate = masm->isolate();
   Label check_number_dictionary;
   // If we can load the value, it should be returned in x0.
   Register result = x0;
 
   GenerateKeyedLoadReceiverCheck(
       masm, receiver, scratch1, scratch2, Map::kHasIndexedInterceptor, slow);
 
@@ skipping 20 matching lines @@
 
 static void GenerateKeyedLoadWithNameKey(MacroAssembler* masm,
                                          Register key,
                                          Register receiver,
                                          Register scratch1,
                                          Register scratch2,
                                          Register scratch3,
                                          Register scratch4,
                                          Register scratch5,
                                          Label *slow) {
-  ASSERT(!AreAliased(
+  DCHECK(!AreAliased(
       key, receiver, scratch1, scratch2, scratch3, scratch4, scratch5));
 
   Isolate* isolate = masm->isolate();
   Label probe_dictionary, property_array_property;
   // If we can load the value, it should be returned in x0.
   Register result = x0;
 
   GenerateKeyedLoadReceiverCheck(
       masm, receiver, scratch1, scratch2, Map::kHasNamedInterceptor, slow);
 
@@ skipping 98 matching lines @@
   __ Ret();
 }
 
 
 void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {
   // The return address is in lr.
   Label slow, check_name, index_smi, index_name;
 
   Register key = NameRegister();
   Register receiver = ReceiverRegister();
-  ASSERT(key.is(x2));
-  ASSERT(receiver.is(x1));
+  DCHECK(key.is(x2));
+  DCHECK(receiver.is(x1));
 
   __ JumpIfNotSmi(key, &check_name);
   __ Bind(&index_smi);
   // Now the key is known to be a smi. This place is also jumped to from below
   // where a numeric string is converted to a smi.
   GenerateKeyedLoadWithSmiKey(masm, key, receiver, x7, x3, x4, x5, x6, &slow);
 
   // Slow case.
   __ Bind(&slow);
   __ IncrementCounter(
@@ skipping 13 matching lines @@
 
 
 void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
   // Return address is in lr.
   Label miss;
 
   Register receiver = ReceiverRegister();
   Register index = NameRegister();
   Register result = x0;
   Register scratch = x3;
-  ASSERT(!scratch.is(receiver) && !scratch.is(index));
+  DCHECK(!scratch.is(receiver) && !scratch.is(index));
 
   StringCharAtGenerator char_at_generator(receiver,
                                           index,
                                           scratch,
                                           result,
                                           &miss,  // When not a string.
                                           &miss,  // When not a number.
                                           &miss,  // When index out of range.
                                           STRING_INDEX_IS_ARRAY_INDEX);
   char_at_generator.GenerateFast(masm);
   __ Ret();
 
   StubRuntimeCallHelper call_helper;
   char_at_generator.GenerateSlow(masm, call_helper);
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void KeyedLoadIC::GenerateIndexedInterceptor(MacroAssembler* masm) {
   // Return address is in lr.
   Label slow;
 
   Register receiver = ReceiverRegister();
   Register key = NameRegister();
   Register scratch1 = x3;
   Register scratch2 = x4;
-  ASSERT(!AreAliased(scratch1, scratch2, receiver, key));
+  DCHECK(!AreAliased(scratch1, scratch2, receiver, key));
 
   // Check that the receiver isn't a smi.
   __ JumpIfSmi(receiver, &slow);
 
   // Check that the key is an array index, that is Uint32.
   __ TestAndBranchIfAnySet(key, kSmiTagMask | kSmiSignMask, &slow);
 
   // Get the map of the receiver.
   Register map = scratch1;
   __ Ldr(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
 
   // Check that it has indexed interceptor and access checks
   // are not enabled for this object.
   __ Ldrb(scratch2, FieldMemOperand(map, Map::kBitFieldOffset));
-  ASSERT(kSlowCaseBitFieldMask ==
+  DCHECK(kSlowCaseBitFieldMask ==
       ((1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor)));
   __ Tbnz(scratch2, Map::kIsAccessCheckNeeded, &slow);
   __ Tbz(scratch2, Map::kHasIndexedInterceptor, &slow);
 
   // Everything is fine, call runtime.
   __ Push(receiver, key);
   __ TailCallExternalReference(
       ExternalReference(IC_Utility(kLoadElementWithInterceptor),
                         masm->isolate()),
       2, 1);
@@ skipping 50 matching lines @@
     Label* fast_double,
     Label* slow,
     KeyedStoreCheckMap check_map,
     KeyedStoreIncrementLength increment_length,
     Register value,
     Register key,
     Register receiver,
     Register receiver_map,
     Register elements_map,
     Register elements) {
-  ASSERT(!AreAliased(
+  DCHECK(!AreAliased(
       value, key, receiver, receiver_map, elements_map, elements, x10, x11));
 
   Label transition_smi_elements;
   Label transition_double_elements;
   Label fast_double_without_map_check;
   Label non_double_value;
   Label finish_store;
 
   __ Bind(fast_object);
   if (check_map == kCheckMap) {
@@ skipping 141 matching lines @@
   Label array;
   Label fast_object;
   Label extra;
   Label fast_object_grow;
   Label fast_double_grow;
   Label fast_double;
 
   Register value = ValueRegister();
   Register key = NameRegister();
   Register receiver = ReceiverRegister();
-  ASSERT(receiver.is(x1));
-  ASSERT(key.is(x2));
-  ASSERT(value.is(x0));
+  DCHECK(receiver.is(x1));
+  DCHECK(key.is(x2));
+  DCHECK(value.is(x0));
 
   Register receiver_map = x3;
   Register elements = x4;
   Register elements_map = x5;
 
   __ JumpIfNotSmi(key, &slow);
   __ JumpIfSmi(receiver, &slow);
   __ Ldr(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
 
   // Check that the receiver does not require access checks and is not observed.
@@ skipping 67 matching lines @@
   KeyedStoreGenerateGenericHelper(masm, &fast_object_grow, &fast_double_grow,
                                   &slow, kDontCheckMap, kIncrementLength,
                                   value, key, receiver, receiver_map,
                                   elements_map, elements);
 }
 
 
 void StoreIC::GenerateMegamorphic(MacroAssembler* masm) {
   Register receiver = ReceiverRegister();
   Register name = NameRegister();
-  ASSERT(!AreAliased(receiver, name, ValueRegister(), x3, x4, x5, x6));
+  DCHECK(!AreAliased(receiver, name, ValueRegister(), x3, x4, x5, x6));
 
   // Probe the stub cache.
   Code::Flags flags = Code::RemoveTypeAndHolderFromFlags(
       Code::ComputeHandlerFlags(Code::STORE_IC));
   masm->isolate()->stub_cache()->GenerateProbe(
       masm, flags, receiver, name, x3, x4, x5, x6);
 
   // Cache miss: Jump to runtime.
   GenerateMiss(masm);
 }
 
 
 void StoreIC::GenerateMiss(MacroAssembler* masm) {
   __ Push(ReceiverRegister(), NameRegister(), ValueRegister());
 
   // Tail call to the entry.
   ExternalReference ref =
       ExternalReference(IC_Utility(kStoreIC_Miss), masm->isolate());
   __ TailCallExternalReference(ref, 3, 1);
 }
 
 
 void StoreIC::GenerateNormal(MacroAssembler* masm) {
   Label miss;
   Register value = ValueRegister();
   Register receiver = ReceiverRegister();
   Register name = NameRegister();
   Register dictionary = x3;
-  ASSERT(!AreAliased(value, receiver, name, x3, x4, x5));
+  DCHECK(!AreAliased(value, receiver, name, x3, x4, x5));
 
   __ Ldr(dictionary, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
 
   GenerateDictionaryStore(masm, &miss, dictionary, name, value, x4, x5);
   Counters* counters = masm->isolate()->counters();
   __ IncrementCounter(counters->store_normal_hit(), 1, x4, x5);
   __ Ret();
 
   // Cache miss: Jump to runtime.
   __ Bind(&miss);
@@ skipping 88 matching lines @@
   }
 
   // Patch and activate code generated by JumpPatchSite::EmitJumpIfNotSmi()
   // and JumpPatchSite::EmitJumpIfSmi().
   // Changing
   //   tb(n)z xzr, #0, <target>
   // to
   //   tb(!n)z test_reg, #0, <target>
   Instruction* to_patch = info.SmiCheck();
   PatchingAssembler patcher(to_patch, 1);
-  ASSERT(to_patch->IsTestBranch());
-  ASSERT(to_patch->ImmTestBranchBit5() == 0);
-  ASSERT(to_patch->ImmTestBranchBit40() == 0);
+  DCHECK(to_patch->IsTestBranch());
+  DCHECK(to_patch->ImmTestBranchBit5() == 0);
+  DCHECK(to_patch->ImmTestBranchBit40() == 0);
 
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagMask == 1);
 
   int branch_imm = to_patch->ImmTestBranch();
   Register smi_reg;
   if (check == ENABLE_INLINED_SMI_CHECK) {
-    ASSERT(to_patch->Rt() == xzr.code());
+    DCHECK(to_patch->Rt() == xzr.code());
     smi_reg = info.SmiRegister();
   } else {
-    ASSERT(check == DISABLE_INLINED_SMI_CHECK);
-    ASSERT(to_patch->Rt() != xzr.code());
+    DCHECK(check == DISABLE_INLINED_SMI_CHECK);
+    DCHECK(to_patch->Rt() != xzr.code());
     smi_reg = xzr;
   }
 
   if (to_patch->Mask(TestBranchMask) == TBZ) {
     // This is JumpIfNotSmi(smi_reg, branch_imm).
     patcher.tbnz(smi_reg, 0, branch_imm);
   } else {
-    ASSERT(to_patch->Mask(TestBranchMask) == TBNZ);
+    DCHECK(to_patch->Mask(TestBranchMask) == TBNZ);
     // This is JumpIfSmi(smi_reg, branch_imm).
     patcher.tbz(smi_reg, 0, branch_imm);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64