Rename ASSERT* to DCHECK*.

src/compiler.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_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/zone.h"
@@ skipping 22 matching lines @@
  public:
   ScriptData(const byte* data, int length);
   ~ScriptData() {
     if (owns_data_) DeleteArray(data_);
   }
 
   const byte* data() const { return data_; }
   int length() const { return length_; }
 
   void AcquireDataOwnership() {
-    ASSERT(!owns_data_);
+    DCHECK(!owns_data_);
     owns_data_ = true;
   }
 
   void ReleaseDataOwnership() {
-    ASSERT(owns_data_);
+    DCHECK(owns_data_);
     owns_data_ = false;
   }
 
  private:
   bool owns_data_;
   const byte* data_;
   int length_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptData);
 };
@@ skipping 31 matching lines @@
   }
   Handle<Context> context() const { return context_; }
   BailoutId osr_ast_id() const { return osr_ast_id_; }
   Handle<Code> unoptimized_code() const { return unoptimized_code_; }
   int opt_count() const { return opt_count_; }
   int num_parameters() const;
   int num_heap_slots() const;
   Code::Flags flags() const;
 
   void MarkAsEval() {
-    ASSERT(!is_lazy());
+    DCHECK(!is_lazy());
     flags_ |= IsEval::encode(true);
   }
 
   void MarkAsGlobal() {
-    ASSERT(!is_lazy());
+    DCHECK(!is_lazy());
     flags_ |= IsGlobal::encode(true);
   }
 
   void set_parameter_count(int parameter_count) {
-    ASSERT(IsStub());
+    DCHECK(IsStub());
     parameter_count_ = parameter_count;
   }
 
   void set_this_has_uses(bool has_no_uses) {
     this_has_uses_ = has_no_uses;
   }
 
   bool this_has_uses() {
     return this_has_uses_;
   }
 
   void SetStrictMode(StrictMode strict_mode) {
-    ASSERT(this->strict_mode() == SLOPPY || this->strict_mode() == strict_mode);
+    DCHECK(this->strict_mode() == SLOPPY || this->strict_mode() == strict_mode);
     flags_ = StrictModeField::update(flags_, strict_mode);
   }
 
   void MarkAsNative() {
     flags_ |= IsNative::encode(true);
   }
 
   bool is_native() const {
     return IsNative::decode(flags_);
   }
@@ skipping 63 matching lines @@
 
   void SetParseRestriction(ParseRestriction restriction) {
     flags_ = ParseRestricitonField::update(flags_, restriction);
   }
 
   ParseRestriction parse_restriction() const {
     return ParseRestricitonField::decode(flags_);
   }
 
   void SetFunction(FunctionLiteral* literal) {
-    ASSERT(function_ == NULL);
+    DCHECK(function_ == NULL);
     function_ = literal;
   }
   void PrepareForCompilation(Scope* scope);
   void SetGlobalScope(Scope* global_scope) {
-    ASSERT(global_scope_ == NULL);
+    DCHECK(global_scope_ == NULL);
     global_scope_ = global_scope;
   }
   Handle<FixedArray> feedback_vector() const {
     return feedback_vector_;
   }
   void SetCode(Handle<Code> code) { code_ = code; }
   void SetExtension(v8::Extension* extension) {
-    ASSERT(!is_lazy());
+    DCHECK(!is_lazy());
     extension_ = extension;
   }
   void SetCachedData(ScriptData** cached_data,
                      ScriptCompiler::CompileOptions compile_options) {
     compile_options_ = compile_options;
     if (compile_options == ScriptCompiler::kNoCompileOptions) {
       cached_data_ = NULL;
     } else {
-      ASSERT(!is_lazy());
+      DCHECK(!is_lazy());
       cached_data_ = cached_data;
     }
   }
   void SetContext(Handle<Context> context) {
     context_ = context;
   }
 
   void MarkCompilingForDebugging() {
     flags_ |= IsCompilingForDebugging::encode(true);
   }
@@ skipping 16 matching lines @@
 
   GlobalObject* global_object() const {
     return has_global_object() ? closure()->context()->global_object() : NULL;
   }
 
   // Accessors for the different compilation modes.
   bool IsOptimizing() const { return mode_ == OPTIMIZE; }
   bool IsOptimizable() const { return mode_ == BASE; }
   bool IsStub() const { return mode_ == STUB; }
   void SetOptimizing(BailoutId osr_ast_id, Handle<Code> unoptimized) {
-    ASSERT(!shared_info_.is_null());
+    DCHECK(!shared_info_.is_null());
     SetMode(OPTIMIZE);
     osr_ast_id_ = osr_ast_id;
     unoptimized_code_ = unoptimized;
     optimization_id_ = isolate()->NextOptimizationId();
   }
   void DisableOptimization();
 
   // Deoptimization support.
   bool HasDeoptimizationSupport() const {
     return SupportsDeoptimization::decode(flags_);
   }
   void EnableDeoptimizationSupport() {
-    ASSERT(IsOptimizable());
+    DCHECK(IsOptimizable());
     flags_ |= SupportsDeoptimization::encode(true);
   }
 
   // Determines whether or not to insert a self-optimization header.
   bool ShouldSelfOptimize();
 
   void set_deferred_handles(DeferredHandles* deferred_handles) {
-    ASSERT(deferred_handles_ == NULL);
+    DCHECK(deferred_handles_ == NULL);
     deferred_handles_ = deferred_handles;
   }
 
   ZoneList<Handle<HeapObject> >* dependencies(
       DependentCode::DependencyGroup group) {
     if (dependencies_[group] == NULL) {
       dependencies_[group] = new(zone_) ZoneList<Handle<HeapObject> >(2, zone_);
     }
     return dependencies_[group];
   }
 
   void CommitDependencies(Handle<Code> code);
 
   void RollbackDependencies();
 
   void SaveHandles() {
     SaveHandle(&closure_);
     SaveHandle(&shared_info_);
     SaveHandle(&context_);
     SaveHandle(&script_);
     SaveHandle(&unoptimized_code_);
   }
 
   BailoutReason bailout_reason() const { return bailout_reason_; }
   void set_bailout_reason(BailoutReason reason) { bailout_reason_ = reason; }
 
   int prologue_offset() const {
-    ASSERT_NE(Code::kPrologueOffsetNotSet, prologue_offset_);
+    DCHECK_NE(Code::kPrologueOffsetNotSet, prologue_offset_);
     return prologue_offset_;
   }
 
   void set_prologue_offset(int prologue_offset) {
-    ASSERT_EQ(Code::kPrologueOffsetNotSet, prologue_offset_);
+    DCHECK_EQ(Code::kPrologueOffsetNotSet, prologue_offset_);
     prologue_offset_ = prologue_offset;
   }
 
   // Adds offset range [from, to) where fp register does not point
   // to the current frame base. Used in CPU profiler to detect stack
   // samples where top frame is not set up.
   inline void AddNoFrameRange(int from, int to) {
     if (no_frame_ranges_) no_frame_ranges_->Add(OffsetRange(from, to));
   }
 
   List<OffsetRange>* ReleaseNoFrameRanges() {
     List<OffsetRange>* result = no_frame_ranges_;
     no_frame_ranges_ = NULL;
     return result;
   }
 
   Handle<Foreign> object_wrapper() {
     if (object_wrapper_.is_null()) {
       object_wrapper_ =
           isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
     }
     return object_wrapper_;
   }
 
   void AbortDueToDependencyChange() {
-    ASSERT(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
+    DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
     abort_due_to_dependency_ = true;
   }
 
   bool HasAbortedDueToDependencyChange() {
-    ASSERT(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
+    DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
     return abort_due_to_dependency_;
   }
 
   bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
     return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure_);
   }
 
   int optimization_id() const { return optimization_id_; }
 
   AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
@@ skipping 241 matching lines @@
   MUST_USE_RESULT Status AbortAndDisableOptimization(
       BailoutReason reason = kNoReason) {
     if (reason != kNoReason) info_->set_bailout_reason(reason);
     // Reference to shared function info does not change between phases.
     AllowDeferredHandleDereference allow_handle_dereference;
     info_->shared_info()->DisableOptimization(info_->bailout_reason());
     return SetLastStatus(BAILED_OUT);
   }
 
   void WaitForInstall() {
-    ASSERT(info_->is_osr());
+    DCHECK(info_->is_osr());
     awaiting_install_ = true;
   }
 
   bool IsWaitingForInstall() { return awaiting_install_; }
 
  private:
   CompilationInfo* info_;
   HOptimizedGraphBuilder* graph_builder_;
   HGraph* graph_;
   LChunk* chunk_;
   base::TimeDelta time_taken_to_create_graph_;
   base::TimeDelta time_taken_to_optimize_;
   base::TimeDelta time_taken_to_codegen_;
   Status last_status_;
   bool awaiting_install_;
 
   MUST_USE_RESULT Status SetLastStatus(Status status) {
     last_status_ = status;
     return last_status_;
   }
   void RecordOptimizationStats();
 
   struct Timer {
     Timer(OptimizedCompileJob* job, base::TimeDelta* location)
         : job_(job), location_(location) {
-      ASSERT(location_ != NULL);
+      DCHECK(location_ != NULL);
       timer_.Start();
     }
 
     ~Timer() {
       *location_ += timer_.Elapsed();
     }
 
     OptimizedCompileJob* job_;
     base::ElapsedTimer timer_;
     base::TimeDelta* location_;
@@ skipping 86 matching lines @@
   Zone zone_;
   unsigned info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_