Rename ASSERT* to DCHECK*.

src/mips/codegen-mips.cc

 // Copyright 2012 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_MIPS
 
 #include "src/codegen.h"
 #include "src/macro-assembler.h"
@@ skipping 39 matching lines @@
     MathExpGenerator::EmitMathExp(
         &masm, input, result, double_scratch1, double_scratch2,
         temp1, temp2, temp3);
     __ Pop(temp3, temp2, temp1);
     __ MovToFloatResult(result);
     __ Ret();
   }
 
   CodeDesc desc;
   masm.GetCode(&desc);
-  ASSERT(!RelocInfo::RequiresRelocation(desc));
+  DCHECK(!RelocInfo::RequiresRelocation(desc));
 
   CpuFeatures::FlushICache(buffer, actual_size);
   base::OS::ProtectCode(buffer, actual_size);
 
 #if !defined(USE_SIMULATOR)
   return FUNCTION_CAST<UnaryMathFunction>(buffer);
 #else
   fast_exp_mips_machine_code = buffer;
   return &fast_exp_simulator;
 #endif
@@ skipping 20 matching lines @@
           leave, ua_chk16w, ua_loop16w, ua_skip_pref, ua_chkw,
           ua_chk1w, ua_wordCopy_loop, ua_smallCopy, ua_smallCopy_loop;
 
     // The size of each prefetch.
     uint32_t pref_chunk = 32;
     // The maximum size of a prefetch, it must not be less then pref_chunk.
     // If the real size of a prefetch is greater then max_pref_size and
     // the kPrefHintPrepareForStore hint is used, the code will not work
     // correctly.
     uint32_t max_pref_size = 128;
-    ASSERT(pref_chunk < max_pref_size);
+    DCHECK(pref_chunk < max_pref_size);
 
     // pref_limit is set based on the fact that we never use an offset
     // greater then 5 on a store pref and that a single pref can
     // never be larger then max_pref_size.
     uint32_t pref_limit = (5 * pref_chunk) + max_pref_size;
     int32_t pref_hint_load = kPrefHintLoadStreamed;
     int32_t pref_hint_store = kPrefHintPrepareForStore;
     uint32_t loadstore_chunk = 4;
 
     // The initial prefetches may fetch bytes that are before the buffer being
     // copied. Start copies with an offset of 4 so avoid this situation when
     // using kPrefHintPrepareForStore.
-    ASSERT(pref_hint_store != kPrefHintPrepareForStore ||
+    DCHECK(pref_hint_store != kPrefHintPrepareForStore ||
            pref_chunk * 4 >= max_pref_size);
 
     // If the size is less than 8, go to lastb. Regardless of size,
     // copy dst pointer to v0 for the retuen value.
     __ slti(t2, a2, 2 * loadstore_chunk);
     __ bne(t2, zero_reg, &lastb);
     __ mov(v0, a0);  // In delay slot.
 
     // If src and dst have different alignments, go to unaligned, if they
     // have the same alignment (but are not actually aligned) do a partial
@@ skipping 462 matching lines @@
     __ addiu(a0, a0, 1);
     __ addiu(a1, a1, 1);
     __ bne(a0, a3, &ua_smallCopy_loop);
     __ sb(v1, MemOperand(a0, -1));  // In delay slot.
 
     __ jr(ra);
     __ nop();
   }
   CodeDesc desc;
   masm.GetCode(&desc);
-  ASSERT(!RelocInfo::RequiresRelocation(desc));
+  DCHECK(!RelocInfo::RequiresRelocation(desc));
 
   CpuFeatures::FlushICache(buffer, actual_size);
   base::OS::ProtectCode(buffer, actual_size);
   return FUNCTION_CAST<MemCopyUint8Function>(buffer);
 #endif
 }
 #endif
 
 UnaryMathFunction CreateSqrtFunction() {
 #if defined(USE_SIMULATOR)
   return &std::sqrt;
 #else
   size_t actual_size;
   byte* buffer =
       static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true));
   if (buffer == NULL) return &std::sqrt;
 
   MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
 
   __ MovFromFloatParameter(f12);
   __ sqrt_d(f0, f12);
   __ MovToFloatResult(f0);
   __ Ret();
 
   CodeDesc desc;
   masm.GetCode(&desc);
-  ASSERT(!RelocInfo::RequiresRelocation(desc));
+  DCHECK(!RelocInfo::RequiresRelocation(desc));
 
   CpuFeatures::FlushICache(buffer, actual_size);
   base::OS::ProtectCode(buffer, actual_size);
   return FUNCTION_CAST<UnaryMathFunction>(buffer);
 #endif
 }
 
 #undef __
 
 
 // -------------------------------------------------------------------------
 // Platform-specific RuntimeCallHelper functions.
 
 void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const {
   masm->EnterFrame(StackFrame::INTERNAL);
-  ASSERT(!masm->has_frame());
+  DCHECK(!masm->has_frame());
   masm->set_has_frame(true);
 }
 
 
 void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const {
   masm->LeaveFrame(StackFrame::INTERNAL);
-  ASSERT(masm->has_frame());
+  DCHECK(masm->has_frame());
   masm->set_has_frame(false);
 }
 
 
 // -------------------------------------------------------------------------
 // Code generators
 
 #define __ ACCESS_MASM(masm)
 
 void ElementsTransitionGenerator::GenerateMapChangeElementsTransition(
     MacroAssembler* masm,
     Register receiver,
     Register key,
     Register value,
     Register target_map,
     AllocationSiteMode mode,
     Label* allocation_memento_found) {
   Register scratch_elements = t0;
-  ASSERT(!AreAliased(receiver, key, value, target_map,
+  DCHECK(!AreAliased(receiver, key, value, target_map,
                      scratch_elements));
 
   if (mode == TRACK_ALLOCATION_SITE) {
-    ASSERT(allocation_memento_found != NULL);
+    DCHECK(allocation_memento_found != NULL);
     __ JumpIfJSArrayHasAllocationMemento(
         receiver, scratch_elements, allocation_memento_found);
   }
 
   // Set transitioned map.
   __ sw(target_map, FieldMemOperand(receiver, HeapObject::kMapOffset));
   __ RecordWriteField(receiver,
                       HeapObject::kMapOffset,
                       target_map,
                       t5,
@@ skipping 18 matching lines @@
   Register length = t1;
   Register array = t2;
   Register array_end = array;
 
   // target_map parameter can be clobbered.
   Register scratch1 = target_map;
   Register scratch2 = t5;
   Register scratch3 = t3;
 
   // Verify input registers don't conflict with locals.
-  ASSERT(!AreAliased(receiver, key, value, target_map,
+  DCHECK(!AreAliased(receiver, key, value, target_map,
                      elements, length, array, scratch2));
 
   Register scratch = t6;
 
   if (mode == TRACK_ALLOCATION_SITE) {
     __ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
   }
 
   // Check for empty arrays, which only require a map transition and no changes
   // to the backing store.
@@ skipping 124 matching lines @@
     AllocationSiteMode mode,
     Label* fail) {
   // Register ra contains the return address.
   Label entry, loop, convert_hole, gc_required, only_change_map;
   Register elements = t0;
   Register array = t2;
   Register length = t1;
   Register scratch = t5;
 
   // Verify input registers don't conflict with locals.
-  ASSERT(!AreAliased(receiver, key, value, target_map,
+  DCHECK(!AreAliased(receiver, key, value, target_map,
                      elements, array, length, scratch));
 
   if (mode == TRACK_ALLOCATION_SITE) {
     __ JumpIfJSArrayHasAllocationMemento(receiver, elements, fail);
   }
 
   // Check for empty arrays, which only require a map transition and no changes
   // to the backing store.
   __ lw(elements, FieldMemOperand(receiver, JSObject::kElementsOffset));
   __ LoadRoot(at, Heap::kEmptyFixedArrayRootIndex);
@@ skipping 217 matching lines @@
 
 
 void MathExpGenerator::EmitMathExp(MacroAssembler* masm,
                                    DoubleRegister input,
                                    DoubleRegister result,
                                    DoubleRegister double_scratch1,
                                    DoubleRegister double_scratch2,
                                    Register temp1,
                                    Register temp2,
                                    Register temp3) {
-  ASSERT(!input.is(result));
-  ASSERT(!input.is(double_scratch1));
-  ASSERT(!input.is(double_scratch2));
-  ASSERT(!result.is(double_scratch1));
-  ASSERT(!result.is(double_scratch2));
-  ASSERT(!double_scratch1.is(double_scratch2));
-  ASSERT(!temp1.is(temp2));
-  ASSERT(!temp1.is(temp3));
-  ASSERT(!temp2.is(temp3));
-  ASSERT(ExternalReference::math_exp_constants(0).address() != NULL);
+  DCHECK(!input.is(result));
+  DCHECK(!input.is(double_scratch1));
+  DCHECK(!input.is(double_scratch2));
+  DCHECK(!result.is(double_scratch1));
+  DCHECK(!result.is(double_scratch2));
+  DCHECK(!double_scratch1.is(double_scratch2));
+  DCHECK(!temp1.is(temp2));
+  DCHECK(!temp1.is(temp3));
+  DCHECK(!temp2.is(temp3));
+  DCHECK(ExternalReference::math_exp_constants(0).address() != NULL);
 
   Label zero, infinity, done;
 
   __ li(temp3, Operand(ExternalReference::math_exp_constants(0)));
 
   __ ldc1(double_scratch1, ExpConstant(0, temp3));
   __ BranchF(&zero, NULL, ge, double_scratch1, input);
 
   __ ldc1(double_scratch2, ExpConstant(1, temp3));
   __ BranchF(&infinity, NULL, ge, input, double_scratch2);
 
   __ ldc1(double_scratch1, ExpConstant(3, temp3));
   __ ldc1(result, ExpConstant(4, temp3));
   __ mul_d(double_scratch1, double_scratch1, input);
   __ add_d(double_scratch1, double_scratch1, result);
   __ FmoveLow(temp2, double_scratch1);
   __ sub_d(double_scratch1, double_scratch1, result);
   __ ldc1(result, ExpConstant(6, temp3));
   __ ldc1(double_scratch2, ExpConstant(5, temp3));
   __ mul_d(double_scratch1, double_scratch1, double_scratch2);
   __ sub_d(double_scratch1, double_scratch1, input);
   __ sub_d(result, result, double_scratch1);
   __ mul_d(double_scratch2, double_scratch1, double_scratch1);
   __ mul_d(result, result, double_scratch2);
   __ ldc1(double_scratch2, ExpConstant(7, temp3));
   __ mul_d(result, result, double_scratch2);
   __ sub_d(result, result, double_scratch1);
   // Mov 1 in double_scratch2 as math_exp_constants_array[8] == 1.
-  ASSERT(*reinterpret_cast<double*>
+  DCHECK(*reinterpret_cast<double*>
          (ExternalReference::math_exp_constants(8).address()) == 1);
   __ Move(double_scratch2, 1);
   __ add_d(result, result, double_scratch2);
   __ srl(temp1, temp2, 11);
   __ Ext(temp2, temp2, 0, 11);
   __ Addu(temp1, temp1, Operand(0x3ff));
 
   // Must not call ExpConstant() after overwriting temp3!
   __ li(temp3, Operand(ExternalReference::math_exp_log_table()));
   __ sll(at, temp2, 3);
@@ skipping 23 matching lines @@
   __ bind(&done);
 }
 
 #ifdef DEBUG
 // nop(CODE_AGE_MARKER_NOP)
 static const uint32_t kCodeAgePatchFirstInstruction = 0x00010180;
 #endif
 
 
 CodeAgingHelper::CodeAgingHelper() {
-  ASSERT(young_sequence_.length() == kNoCodeAgeSequenceLength);
+  DCHECK(young_sequence_.length() == kNoCodeAgeSequenceLength);
   // Since patcher is a large object, allocate it dynamically when needed,
   // to avoid overloading the stack in stress conditions.
   // DONT_FLUSH is used because the CodeAgingHelper is initialized early in
   // the process, before MIPS simulator ICache is setup.
   SmartPointer<CodePatcher> patcher(
       new CodePatcher(young_sequence_.start(),
                       young_sequence_.length() / Assembler::kInstrSize,
                       CodePatcher::DONT_FLUSH));
   PredictableCodeSizeScope scope(patcher->masm(), young_sequence_.length());
   patcher->masm()->Push(ra, fp, cp, a1);
   patcher->masm()->nop(Assembler::CODE_AGE_SEQUENCE_NOP);
   patcher->masm()->Addu(
       fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
 }
 
 
 #ifdef DEBUG
 bool CodeAgingHelper::IsOld(byte* candidate) const {
   return Memory::uint32_at(candidate) == kCodeAgePatchFirstInstruction;
 }
 #endif
 
 
 bool Code::IsYoungSequence(Isolate* isolate, byte* sequence) {
   bool result = isolate->code_aging_helper()->IsYoung(sequence);
-  ASSERT(result || isolate->code_aging_helper()->IsOld(sequence));
+  DCHECK(result || isolate->code_aging_helper()->IsOld(sequence));
   return result;
 }
 
 
 void Code::GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age,
                                MarkingParity* parity) {
   if (IsYoungSequence(isolate, sequence)) {
     *age = kNoAgeCodeAge;
     *parity = NO_MARKING_PARITY;
   } else {
@@ skipping 30 matching lines @@
     patcher.masm()->nop();  // Pad the empty space.
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS