Rename ASSERT* to DCHECK*.

src/stub-cache.h

 // 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.
 
 #ifndef V8_STUB_CACHE_H_
 #define V8_STUB_CACHE_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/code-stubs.h"
@@ skipping 107 matching lines @@
   // update strategy on updates is fairly clear and simple:  Any existing entry
   // in the primary cache is moved to the secondary cache, and secondary cache
   // entries are overwritten.
 
   // Hash algorithm for the primary table.  This algorithm is replicated in
   // assembler for every architecture.  Returns an index into the table that
   // is scaled by 1 << kCacheIndexShift.
   static int PrimaryOffset(Name* name, Code::Flags flags, Map* map) {
     STATIC_ASSERT(kCacheIndexShift == Name::kHashShift);
     // Compute the hash of the name (use entire hash field).
-    ASSERT(name->HasHashCode());
+    DCHECK(name->HasHashCode());
     uint32_t field = name->hash_field();
     // Using only the low bits in 64-bit mode is unlikely to increase the
     // risk of collision even if the heap is spread over an area larger than
     // 4Gb (and not at all if it isn't).
     uint32_t map_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map));
     // We always set the in_loop bit to zero when generating the lookup code
     // so do it here too so the hash codes match.
     uint32_t iflags =
         (static_cast<uint32_t>(flags) & ~Code::kFlagsNotUsedInLookup);
@@ skipping 210 matching lines @@
       return code->ic_state() == MONOMORPHIC ? Logger::LOAD_IC_TAG
                                              : Logger::LOAD_POLYMORPHIC_IC_TAG;
     } else if (kind() == Code::KEYED_LOAD_IC) {
       return code->ic_state() == MONOMORPHIC
                  ? Logger::KEYED_LOAD_IC_TAG
                  : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;
     } else if (kind() == Code::STORE_IC) {
       return code->ic_state() == MONOMORPHIC ? Logger::STORE_IC_TAG
                                              : Logger::STORE_POLYMORPHIC_IC_TAG;
     } else {
-      ASSERT_EQ(Code::KEYED_STORE_IC, kind());
+      DCHECK_EQ(Code::KEYED_STORE_IC, kind());
       return code->ic_state() == MONOMORPHIC
                  ? Logger::KEYED_STORE_IC_TAG
                  : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
     }
   }
 
   const ExtraICState extra_ic_state_;
 };
 
 
@@ skipping 265 matching lines @@
  public:
   explicit CallOptimization(LookupResult* lookup);
 
   explicit CallOptimization(Handle<JSFunction> function);
 
   bool is_constant_call() const {
     return !constant_function_.is_null();
   }
 
   Handle<JSFunction> constant_function() const {
-    ASSERT(is_constant_call());
+    DCHECK(is_constant_call());
     return constant_function_;
   }
 
   bool is_simple_api_call() const {
     return is_simple_api_call_;
   }
 
   Handle<FunctionTemplateInfo> expected_receiver_type() const {
-    ASSERT(is_simple_api_call());
+    DCHECK(is_simple_api_call());
     return expected_receiver_type_;
   }
 
   Handle<CallHandlerInfo> api_call_info() const {
-    ASSERT(is_simple_api_call());
+    DCHECK(is_simple_api_call());
     return api_call_info_;
   }
 
   enum HolderLookup {
     kHolderNotFound,
     kHolderIsReceiver,
     kHolderFound
   };
   Handle<JSObject> LookupHolderOfExpectedType(
       Handle<Map> receiver_map,
@@ skipping 13 matching lines @@
   Handle<JSFunction> constant_function_;
   bool is_simple_api_call_;
   Handle<FunctionTemplateInfo> expected_receiver_type_;
   Handle<CallHandlerInfo> api_call_info_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_