Rename ASSERT* to DCHECK*.

src/compiler/js-operator.h

 // Copyright 2013 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_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Defines the location of a context slot relative to a specific scope. This is
 // used as a parameter by JSLoadContext and JSStoreContext operators and allows
 // accessing a context-allocated variable without keeping track of the scope.
 class ContextAccess {
  public:
   ContextAccess(int depth, int index, bool immutable)
       : immutable_(immutable), depth_(depth), index_(index) {
-    ASSERT(0 <= depth && depth <= kMaxUInt16);
-    ASSERT(0 <= index && static_cast<uint32_t>(index) <= kMaxUInt32);
+    DCHECK(0 <= depth && depth <= kMaxUInt16);
+    DCHECK(0 <= index && static_cast<uint32_t>(index) <= kMaxUInt32);
   }
   int depth() const { return depth_; }
   int index() const { return index_; }
   bool immutable() const { return immutable_; }
 
  private:
   // For space reasons, we keep this tightly packed, otherwise we could just use
   // a simple int/int/bool POD.
   const bool immutable_;
   const uint16_t depth_;
@@ skipping 111 matching lines @@
     OP1(JSCreateCatchContext, PrintableUnique<String>, name,
         Operator::kNoProperties, 1, 1);
   }
   Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
   Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
   Operator* CreateModuleContext() { NOPROPS(JSCreateModuleContext, 2, 1); }
   Operator* CreateGlobalContext() { NOPROPS(JSCreateGlobalContext, 2, 1); }
 
   Operator* Runtime(Runtime::FunctionId function, int arguments) {
     const Runtime::Function* f = Runtime::FunctionForId(function);
-    ASSERT(f->nargs == -1 || f->nargs == arguments);
+    DCHECK(f->nargs == -1 || f->nargs == arguments);
     OP1(JSCallRuntime, Runtime::FunctionId, function, Operator::kNoProperties,
         arguments, f->result_size);
   }
 
 #undef SIMPLE
 #undef NOPROPS
 #undef OP1
 #undef BINOP
 #undef UNOP
 
@@ skipping 27 matching lines @@
   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
     return a == b;
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_