Rename ASSERT* to DCHECK*.

src/code-stubs.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"
 
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/cpu-profiler.h"
 #include "src/factory.h"
@@ skipping 21 matching lines @@
 
 void InterfaceDescriptor::Initialize(
     int register_parameter_count,
     Register* registers,
     Representation* register_param_representations,
     PlatformInterfaceDescriptor* platform_descriptor) {
   platform_specific_descriptor_ = platform_descriptor;
   register_param_count_ = register_parameter_count;
 
   // An interface descriptor must have a context register.
-  ASSERT(register_parameter_count > 0 && registers[0].is(ContextRegister()));
+  DCHECK(register_parameter_count > 0 && registers[0].is(ContextRegister()));
 
   // InterfaceDescriptor owns a copy of the registers array.
   register_params_.Reset(NewArray<Register>(register_parameter_count));
   for (int i = 0; i < register_parameter_count; i++) {
     register_params_[i] = registers[i];
   }
 
   // If a representations array is specified, then the descriptor owns that as
   // well.
   if (register_param_representations != NULL) {
     register_param_representations_.Reset(
         NewArray<Representation>(register_parameter_count));
     for (int i = 0; i < register_parameter_count; i++) {
       // If there is a context register, the representation must be tagged.
-      ASSERT(i != 0 || register_param_representations[i].Equals(
+      DCHECK(i != 0 || register_param_representations[i].Equals(
           Representation::Tagged()));
       register_param_representations_[i] = register_param_representations[i];
     }
   }
 }
 
 
 void CodeStubInterfaceDescriptor::Initialize(
     CodeStub::Major major, int register_parameter_count, Register* registers,
     Address deoptimization_handler,
@@ skipping 103 matching lines @@
   return new_object;
 }
 
 
 Handle<Code> CodeStub::GetCode() {
   Heap* heap = isolate()->heap();
   Code* code;
   if (UseSpecialCache()
       ? FindCodeInSpecialCache(&code)
       : FindCodeInCache(&code)) {
-    ASSERT(GetCodeKind() == code->kind());
+    DCHECK(GetCodeKind() == code->kind());
     return Handle<Code>(code);
   }
 
   {
     HandleScope scope(isolate());
 
     Handle<Code> new_object = GenerateCode();
     new_object->set_stub_key(GetKey());
     FinishCode(new_object);
     RecordCodeGeneration(new_object);
@@ skipping 17 matching lines @@
           UnseededNumberDictionary::AtNumberPut(
               Handle<UnseededNumberDictionary>(heap->code_stubs()),
               GetKey(),
               new_object);
       heap->public_set_code_stubs(*dict);
     }
     code = *new_object;
   }
 
   Activate(code);
-  ASSERT(!NeedsImmovableCode() ||
+  DCHECK(!NeedsImmovableCode() ||
          heap->lo_space()->Contains(code) ||
          heap->code_space()->FirstPage()->Contains(code->address()));
   return Handle<Code>(code, isolate());
 }
 
 
 const char* CodeStub::MajorName(CodeStub::Major major_key,
                                 bool allow_unknown_keys) {
   switch (major_key) {
 #define DEF_CASE(name) case name: return #name "Stub";
@@ skipping 105 matching lines @@
       return MONOMORPHIC;
     case CompareIC::GENERIC:
       return ::v8::internal::GENERIC;
   }
   UNREACHABLE();
   return ::v8::internal::UNINITIALIZED;
 }
 
 
 void ICCompareStub::AddToSpecialCache(Handle<Code> new_object) {
-  ASSERT(*known_map_ != NULL);
+  DCHECK(*known_map_ != NULL);
   Isolate* isolate = new_object->GetIsolate();
   Factory* factory = isolate->factory();
   return Map::UpdateCodeCache(known_map_,
                               strict() ?
                                   factory->strict_compare_ic_string() :
                                   factory->compare_ic_string(),
                               new_object);
 }
 
 
 bool ICCompareStub::FindCodeInSpecialCache(Code** code_out) {
   Factory* factory = isolate()->factory();
   Code::Flags flags = Code::ComputeFlags(
       GetCodeKind(),
       UNINITIALIZED);
-  ASSERT(op_ == Token::EQ || op_ == Token::EQ_STRICT);
+  DCHECK(op_ == Token::EQ || op_ == Token::EQ_STRICT);
   Handle<Object> probe(
       known_map_->FindInCodeCache(
         strict() ?
             *factory->strict_compare_ic_string() :
             *factory->compare_ic_string(),
         flags),
       isolate());
   if (probe->IsCode()) {
     *code_out = Code::cast(*probe);
 #ifdef DEBUG
     Token::Value cached_op;
     ICCompareStub::DecodeKey((*code_out)->stub_key(), NULL, NULL, NULL,
                              &cached_op);
-    ASSERT(op_ == cached_op);
+    DCHECK(op_ == cached_op);
 #endif
     return true;
   }
   return false;
 }
 
 
 int ICCompareStub::MinorKey() const {
   return OpField::encode(op_ - Token::EQ) |
          LeftStateField::encode(left_) |
@@ skipping 42 matching lines @@
     case CompareIC::INTERNALIZED_STRING:
       GenerateInternalizedStrings(masm);
       break;
     case CompareIC::UNIQUE_NAME:
       GenerateUniqueNames(masm);
       break;
     case CompareIC::OBJECT:
       GenerateObjects(masm);
       break;
     case CompareIC::KNOWN_OBJECT:
-      ASSERT(*known_map_ != NULL);
+      DCHECK(*known_map_ != NULL);
       GenerateKnownObjects(masm);
       break;
     case CompareIC::GENERIC:
       GenerateGeneric(masm);
       break;
   }
 }
 
 
 void CompareNilICStub::UpdateStatus(Handle<Object> object) {
-  ASSERT(!state_.Contains(GENERIC));
+  DCHECK(!state_.Contains(GENERIC));
   State old_state(state_);
   if (object->IsNull()) {
     state_.Add(NULL_TYPE);
   } else if (object->IsUndefined()) {
     state_.Add(UNDEFINED);
   } else if (object->IsUndetectableObject() ||
              object->IsOddball() ||
              !object->IsHeapObject()) {
     state_.RemoveAll();
     state_.Add(GENERIC);
   } else if (IsMonomorphic()) {
     state_.RemoveAll();
     state_.Add(GENERIC);
   } else {
     state_.Add(MONOMORPHIC_MAP);
   }
   TraceTransition(old_state, state_);
 }
 
 
 template<class StateType>
 void HydrogenCodeStub::TraceTransition(StateType from, StateType to) {
   // Note: Although a no-op transition is semantically OK, it is hinting at a
   // bug somewhere in our state transition machinery.
-  ASSERT(from != to);
+  DCHECK(from != to);
   if (!FLAG_trace_ic) return;
   OFStream os(stdout);
   os << "[";
   PrintBaseName(os);
   os << ": " << from << "=>" << to << "]" << endl;
 }
 
 
 void CompareNilICStub::PrintBaseName(OStream& os) const {  // NOLINT
   CodeStub::PrintBaseName(os);
@@ skipping 332 matching lines @@
     Add(SPEC_OBJECT);
     return !object->IsUndetectableObject();
   } else if (object->IsString()) {
     Add(STRING);
     return !object->IsUndetectableObject() &&
         String::cast(*object)->length() != 0;
   } else if (object->IsSymbol()) {
     Add(SYMBOL);
     return true;
   } else if (object->IsHeapNumber()) {
-    ASSERT(!object->IsUndetectableObject());
+    DCHECK(!object->IsUndetectableObject());
     Add(HEAP_NUMBER);
     double value = HeapNumber::cast(*object)->value();
     return value != 0 && !std::isnan(value);
   } else {
     // We should never see an internal object at runtime here!
     UNREACHABLE();
     return true;
   }
 }
 
@@ skipping 17 matching lines @@
   StubFailureTrampolineStub stub2(isolate, JS_FUNCTION_STUB_MODE);
   stub1.GetCode();
   stub2.GetCode();
 }
 
 
 void ProfileEntryHookStub::EntryHookTrampoline(intptr_t function,
                                                intptr_t stack_pointer,
                                                Isolate* isolate) {
   FunctionEntryHook entry_hook = isolate->function_entry_hook();
-  ASSERT(entry_hook != NULL);
+  DCHECK(entry_hook != NULL);
   entry_hook(function, stack_pointer);
 }
 
 
 static void InstallDescriptor(Isolate* isolate, HydrogenCodeStub* stub) {
   int major_key = stub->MajorKey();
   CodeStubInterfaceDescriptor* descriptor =
       isolate->code_stub_interface_descriptor(major_key);
   if (!descriptor->IsInitialized()) {
     stub->InitializeInterfaceDescriptor(descriptor);
@@ skipping 103 matching lines @@
   InstallDescriptor(isolate, &stub3);
 }
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(
     Isolate* isolate) : PlatformCodeStub(isolate) {
   InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
 } }  // namespace v8::internal