Rename ASSERT* to DCHECK*.

src/type-info.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/ast.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/ic.h"
 #include "src/macro-assembler.h"
 #include "src/stub-cache.h"
 #include "src/type-info.h"
 
 #include "src/ic-inl.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 TypeFeedbackOracle::TypeFeedbackOracle(Handle<Code> code,
                                        Handle<FixedArray> feedback_vector,
                                        Handle<Context> native_context,
                                        Zone* zone)
     : native_context_(native_context),
       zone_(zone) {
   BuildDictionary(code);
-  ASSERT(dictionary_->IsDictionary());
+  DCHECK(dictionary_->IsDictionary());
   // We make a copy of the feedback vector because a GC could clear
   // the type feedback info contained therein.
   // TODO(mvstanton): revisit the decision to copy when we weakly
   // traverse the feedback vector at GC time.
   feedback_vector_ = isolate()->factory()->CopyFixedArray(feedback_vector);
 }
 
 
 static uint32_t IdToKey(TypeFeedbackId ast_id) {
   return static_cast<uint32_t>(ast_id.ToInt());
 }
 
 
 Handle<Object> TypeFeedbackOracle::GetInfo(TypeFeedbackId ast_id) {
   int entry = dictionary_->FindEntry(IdToKey(ast_id));
   if (entry != UnseededNumberDictionary::kNotFound) {
     Object* value = dictionary_->ValueAt(entry);
     if (value->IsCell()) {
       Cell* cell = Cell::cast(value);
       return Handle<Object>(cell->value(), isolate());
     } else {
       return Handle<Object>(value, isolate());
     }
   }
   return Handle<Object>::cast(isolate()->factory()->undefined_value());
 }
 
 
 Handle<Object> TypeFeedbackOracle::GetInfo(int slot) {
-  ASSERT(slot >= 0 && slot < feedback_vector_->length());
+  DCHECK(slot >= 0 && slot < feedback_vector_->length());
   Object* obj = feedback_vector_->get(slot);
   if (!obj->IsJSFunction() ||
       !CanRetainOtherContext(JSFunction::cast(obj), *native_context_)) {
     return Handle<Object>(obj, isolate());
   }
   return Handle<Object>::cast(isolate()->factory()->undefined_value());
 }
 
 
 bool TypeFeedbackOracle::LoadIsUninitialized(TypeFeedbackId id) {
@@ skipping 69 matching lines @@
   return Handle<JSFunction>::cast(info);
 }
 
 
 Handle<JSFunction> TypeFeedbackOracle::GetCallNewTarget(int slot) {
   Handle<Object> info = GetInfo(slot);
   if (FLAG_pretenuring_call_new || info->IsJSFunction()) {
     return Handle<JSFunction>::cast(info);
   }
 
-  ASSERT(info->IsAllocationSite());
+  DCHECK(info->IsAllocationSite());
   return Handle<JSFunction>(isolate()->native_context()->array_function());
 }
 
 
 Handle<AllocationSite> TypeFeedbackOracle::GetCallAllocationSite(int slot) {
   Handle<Object> info = GetInfo(slot);
   if (info->IsAllocationSite()) {
     return Handle<AllocationSite>::cast(info);
   }
   return Handle<AllocationSite>::null();
@@ skipping 51 matching lines @@
                                     Type** left,
                                     Type** right,
                                     Type** result,
                                     Maybe<int>* fixed_right_arg,
                                     Handle<AllocationSite>* allocation_site,
                                     Token::Value op) {
   Handle<Object> object = GetInfo(id);
   if (!object->IsCode()) {
     // For some binary ops we don't have ICs, e.g. Token::COMMA, but for the
     // operations covered by the BinaryOpIC we should always have them.
-    ASSERT(op < BinaryOpIC::State::FIRST_TOKEN ||
+    DCHECK(op < BinaryOpIC::State::FIRST_TOKEN ||
            op > BinaryOpIC::State::LAST_TOKEN);
     *left = *right = *result = Type::None(zone());
     *fixed_right_arg = Maybe<int>();
     *allocation_site = Handle<AllocationSite>::null();
     return;
   }
   Handle<Code> code = Handle<Code>::cast(object);
-  ASSERT_EQ(Code::BINARY_OP_IC, code->kind());
+  DCHECK_EQ(Code::BINARY_OP_IC, code->kind());
   BinaryOpIC::State state(isolate(), code->extra_ic_state());
-  ASSERT_EQ(op, state.op());
+  DCHECK_EQ(op, state.op());
 
   *left = state.GetLeftType(zone());
   *right = state.GetRightType(zone());
   *result = state.GetResultType(zone());
   *fixed_right_arg = state.fixed_right_arg();
 
   AllocationSite* first_allocation_site = code->FindFirstAllocationSite();
   if (first_allocation_site != NULL) {
     *allocation_site = handle(first_allocation_site);
   } else {
     *allocation_site = Handle<AllocationSite>::null();
   }
 }
 
 
 Type* TypeFeedbackOracle::CountType(TypeFeedbackId id) {
   Handle<Object> object = GetInfo(id);
   if (!object->IsCode()) return Type::None(zone());
   Handle<Code> code = Handle<Code>::cast(object);
-  ASSERT_EQ(Code::BINARY_OP_IC, code->kind());
+  DCHECK_EQ(Code::BINARY_OP_IC, code->kind());
   BinaryOpIC::State state(isolate(), code->extra_ic_state());
   return state.GetLeftType(zone());
 }
 
 
 void TypeFeedbackOracle::PropertyReceiverTypes(TypeFeedbackId id,
                                                Handle<String> name,
                                                SmallMapList* receiver_types) {
   receiver_types->Clear();
   Code::Flags flags = Code::ComputeHandlerFlags(Code::LOAD_IC);
@@ skipping 37 matching lines @@
 }
 
 
 void TypeFeedbackOracle::CollectReceiverTypes(TypeFeedbackId ast_id,
                                               Handle<String> name,
                                               Code::Flags flags,
                                               SmallMapList* types) {
   Handle<Object> object = GetInfo(ast_id);
   if (object->IsUndefined() || object->IsSmi()) return;
 
-  ASSERT(object->IsCode());
+  DCHECK(object->IsCode());
   Handle<Code> code(Handle<Code>::cast(object));
 
   if (FLAG_collect_megamorphic_maps_from_stub_cache &&
       code->ic_state() == MEGAMORPHIC) {
     types->Reserve(4, zone());
     isolate()->stub_cache()->CollectMatchingMaps(
         types, name, flags, native_context_, zone());
   } else {
     CollectReceiverTypes(ast_id, types);
   }
@@ skipping 130 matching lines @@
         break;
 
       default:
         break;
     }
   }
 }
 
 
 void TypeFeedbackOracle::SetInfo(TypeFeedbackId ast_id, Object* target) {
-  ASSERT(dictionary_->FindEntry(IdToKey(ast_id)) ==
+  DCHECK(dictionary_->FindEntry(IdToKey(ast_id)) ==
          UnseededNumberDictionary::kNotFound);
   // Dictionary has been allocated with sufficient size for all elements.
   DisallowHeapAllocation no_need_to_resize_dictionary;
   HandleScope scope(isolate());
   USE(UnseededNumberDictionary::AtNumberPut(
       dictionary_, IdToKey(ast_id), handle(target, isolate())));
 }
 
 
 } }  // namespace v8::internal