Rename ASSERT* to DCHECK*.

src/liveedit.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/liveedit.h"
 
 #include "src/code-stubs.h"
@@ skipping 143 matching lines @@
       return (len2_ - pos2) << kDirectionSizeBits;
     }
   }
 
   inline int& get_cell(int i1, int i2) {
     return buffer_[i1 + i2 * len1_];
   }
 
   // Each cell keeps a value plus direction. Value is multiplied by 4.
   void set_value4_and_dir(int i1, int i2, int value4, Direction dir) {
-    ASSERT((value4 & kDirectionMask) == 0);
+    DCHECK((value4 & kDirectionMask) == 0);
     get_cell(i1, i2) = value4 | dir;
   }
 
   int get_value4(int i1, int i2) {
     return get_cell(i1, i2) & (kMaxUInt32 ^ kDirectionMask);
   }
   Direction get_direction(int i1, int i2) {
     return static_cast<Direction>(get_cell(i1, i2) & kDirectionMask);
   }
 
@@ skipping 794 matching lines @@
 static void ReplaceCodeObject(Handle<Code> original,
                               Handle<Code> substitution) {
   // Perform a full GC in order to ensure that we are not in the middle of an
   // incremental marking phase when we are replacing the code object.
   // Since we are not in an incremental marking phase we can write pointers
   // to code objects (that are never in new space) without worrying about
   // write barriers.
   Heap* heap = original->GetHeap();
   HeapIterator iterator(heap);
 
-  ASSERT(!heap->InNewSpace(*substitution));
+  DCHECK(!heap->InNewSpace(*substitution));
 
   ReplacingVisitor visitor(*original, *substitution);
 
   // Iterate over all roots. Stack frames may have pointer into original code,
   // so temporary replace the pointers with offset numbers
   // in prologue/epilogue.
   heap->IterateRoots(&visitor, VISIT_ALL);
 
   // Now iterate over all pointers of all objects, including code_target
   // implicit pointers.
@@ skipping 163 matching lines @@
   SharedFunctionInfo* shared_info_;
   bool found_;
 
   explicit DependentFunctionMarker(SharedFunctionInfo* shared_info)
     : shared_info_(shared_info), found_(false) { }
 
   virtual void EnterContext(Context* context) { }  // Don't care.
   virtual void LeaveContext(Context* context)  { }  // Don't care.
   virtual void VisitFunction(JSFunction* function) {
     // It should be guaranteed by the iterator that everything is optimized.
-    ASSERT(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
+    DCHECK(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
     if (shared_info_ == function->shared() ||
         IsInlined(function, shared_info_)) {
       // Mark the code for deoptimization.
       function->code()->set_marked_for_deoptimization(true);
       found_ = true;
     }
   }
 };
 
 
@@ skipping 98 matching lines @@
     CHECK(element->IsSmi());
     int chunk_start = Handle<Smi>::cast(element)->value();
     if (original_position < chunk_start) {
       break;
     }
     element = Object::GetElement(
         isolate, position_change_array, i + 1).ToHandleChecked();
     CHECK(element->IsSmi());
     int chunk_end = Handle<Smi>::cast(element)->value();
     // Position mustn't be inside a chunk.
-    ASSERT(original_position >= chunk_end);
+    DCHECK(original_position >= chunk_end);
     element = Object::GetElement(
         isolate, position_change_array, i + 2).ToHandleChecked();
     CHECK(element->IsSmi());
     int chunk_changed_end = Handle<Smi>::cast(element)->value();
     position_diff = chunk_changed_end - chunk_end;
   }
 
   return original_position + position_diff;
 }
 
@@ skipping 279 matching lines @@
 // the value that is called 'restarter_frame_function_pointer'. The value
 // at this address (possibly updated by GC) may be used later when preparing
 // 'step in' operation.
 // Frame structure (conforms InternalFrame structure):
 //   -- code
 //   -- SMI maker
 //   -- function (slot is called "context")
 //   -- frame base
 static Object** SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
                                        Handle<Code> code) {
-  ASSERT(bottom_js_frame->is_java_script());
+  DCHECK(bottom_js_frame->is_java_script());
 
   Address fp = bottom_js_frame->fp();
 
   // Move function pointer into "context" slot.
   Memory::Object_at(fp + StandardFrameConstants::kContextOffset) =
       Memory::Object_at(fp + JavaScriptFrameConstants::kFunctionOffset);
 
   Memory::Object_at(fp + InternalFrameConstants::kCodeOffset) = *code;
   Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset) =
       Smi::FromInt(StackFrame::INTERNAL);
@@ skipping 13 matching lines @@
                               LiveEdit::FrameDropMode* mode,
                               Object*** restarter_frame_function_pointer) {
   if (!LiveEdit::kFrameDropperSupported) {
     return "Stack manipulations are not supported in this architecture.";
   }
 
   StackFrame* pre_top_frame = frames[top_frame_index - 1];
   StackFrame* top_frame = frames[top_frame_index];
   StackFrame* bottom_js_frame = frames[bottom_js_frame_index];
 
-  ASSERT(bottom_js_frame->is_java_script());
+  DCHECK(bottom_js_frame->is_java_script());
 
   // Check the nature of the top frame.
   Isolate* isolate = bottom_js_frame->isolate();
   Code* pre_top_frame_code = pre_top_frame->LookupCode();
   bool frame_has_padding = true;
   if (pre_top_frame_code->is_inline_cache_stub() &&
       pre_top_frame_code->is_debug_stub()) {
     // OK, we can drop inline cache calls.
     *mode = LiveEdit::FRAME_DROPPED_IN_IC_CALL;
   } else if (pre_top_frame_code ==
@@ skipping 15 matching lines @@
     // Entry from our unit tests on 'debugger' statement.
     // It's fine, we support this case.
     *mode = LiveEdit::FRAME_DROPPED_IN_DIRECT_CALL;
     // We don't have a padding from 'debugger' statement call.
     // Here the stub is CEntry, it's not debug-only and can't be padded.
     // If anyone would complain, a proxy padded stub could be added.
     frame_has_padding = false;
   } else if (pre_top_frame->type() == StackFrame::ARGUMENTS_ADAPTOR) {
     // This must be adaptor that remain from the frame dropping that
     // is still on stack. A frame dropper frame must be above it.
-    ASSERT(frames[top_frame_index - 2]->LookupCode() ==
+    DCHECK(frames[top_frame_index - 2]->LookupCode() ==
            isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit));
     pre_top_frame = frames[top_frame_index - 3];
     top_frame = frames[top_frame_index - 2];
     *mode = LiveEdit::CURRENTLY_SET_MODE;
     frame_has_padding = false;
   } else {
     return "Unknown structure of stack above changing function";
   }
 
   Address unused_stack_top = top_frame->sp();
   int new_frame_size = LiveEdit::kFrameDropperFrameSize * kPointerSize;
   Address unused_stack_bottom = bottom_js_frame->fp()
       - new_frame_size + kPointerSize;  // Bigger address end is exclusive.
 
   Address* top_frame_pc_address = top_frame->pc_address();
 
   // top_frame may be damaged below this point. Do not used it.
-  ASSERT(!(top_frame = NULL));
+  DCHECK(!(top_frame = NULL));
 
   if (unused_stack_top > unused_stack_bottom) {
     if (frame_has_padding) {
       int shortage_bytes =
           static_cast<int>(unused_stack_top - unused_stack_bottom);
 
       Address padding_start = pre_top_frame->fp() -
           LiveEdit::kFrameDropperFrameSize * kPointerSize;
 
       Address padding_pointer = padding_start;
@@ skipping 24 matching lines @@
       top_frame_pc_address -= shortage_bytes / kPointerSize;
     } else {
       return "Not enough space for frame dropper frame";
     }
   }
 
   // Committing now. After this point we should return only NULL value.
 
   FixTryCatchHandler(pre_top_frame, bottom_js_frame);
   // Make sure FixTryCatchHandler is idempotent.
-  ASSERT(!FixTryCatchHandler(pre_top_frame, bottom_js_frame));
+  DCHECK(!FixTryCatchHandler(pre_top_frame, bottom_js_frame));
 
   Handle<Code> code = isolate->builtins()->FrameDropper_LiveEdit();
   *top_frame_pc_address = code->entry();
   pre_top_frame->SetCallerFp(bottom_js_frame->fp());
 
   *restarter_frame_function_pointer =
       SetUpFrameDropperFrame(bottom_js_frame, code);
 
-  ASSERT((**restarter_frame_function_pointer)->IsJSFunction());
+  DCHECK((**restarter_frame_function_pointer)->IsJSFunction());
 
   for (Address a = unused_stack_top;
       a < unused_stack_bottom;
       a += kPointerSize) {
     Memory::Object_at(a) = Smi::FromInt(0);
   }
 
   return NULL;
 }
 
@@ skipping 153 matching lines @@
   return NULL;
 }
 
 
 bool LiveEdit::FindActiveGenerators(Handle<FixedArray> shared_info_array,
                                     Handle<FixedArray> result,
                                     int len) {
   Isolate* isolate = shared_info_array->GetIsolate();
   bool found_suspended_activations = false;
 
-  ASSERT_LE(len, result->length());
+  DCHECK_LE(len, result->length());
 
   FunctionPatchabilityStatus active = FUNCTION_BLOCKED_ACTIVE_GENERATOR;
 
   Heap* heap = isolate->heap();
   HeapIterator iterator(heap);
   HeapObject* obj = NULL;
   while ((obj = iterator.next()) != NULL) {
     if (!obj->IsJSGeneratorObject()) continue;
 
     JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
@@ skipping 41 matching lines @@
   Handle<JSArray> result_;
   bool has_blocked_functions_;
 };
 
 
 Handle<JSArray> LiveEdit::CheckAndDropActivations(
     Handle<JSArray> shared_info_array, bool do_drop) {
   Isolate* isolate = shared_info_array->GetIsolate();
   int len = GetArrayLength(shared_info_array);
 
-  ASSERT(shared_info_array->HasFastElements());
+  DCHECK(shared_info_array->HasFastElements());
   Handle<FixedArray> shared_info_array_elements(
       FixedArray::cast(shared_info_array->elements()));
 
   Handle<JSArray> result = isolate->factory()->NewJSArray(len);
   Handle<FixedArray> result_elements =
       JSObject::EnsureWritableFastElements(result);
 
   // Fill the default values.
   for (int i = 0; i < len; i++) {
     FunctionPatchabilityStatus status = FUNCTION_AVAILABLE_FOR_PATCH;
@@ skipping 107 matching lines @@
 void LiveEditFunctionTracker::RecordRootFunctionInfo(Handle<Code> code) {
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 } }  // namespace v8::internal