Rename ASSERT* to DCHECK*.

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 35 matching lines @@
     Operator* op = common()->Parameter(info()->num_parameters() + 1);
     Node* node = NewNode(op);
     function_context_.set(node);
   }
   return function_context_.get();
 }
 
 
 bool AstGraphBuilder::CreateGraph() {
   Scope* scope = info()->scope();
-  ASSERT(graph() != NULL);
+  DCHECK(graph() != NULL);
 
   SourcePositionTable::Scope start_pos(
       source_positions(),
       SourcePosition(info()->shared_info()->start_position()));
 
   // Set up the basic structure of the graph.
   graph()->SetStart(graph()->NewNode(common()->Start()));
 
   // Initialize the top-level environment.
   Environment env(this, scope, graph()->start());
@@ skipping 53 matching lines @@
 }
 
 
 // Left-hand side can only be a property, a global or a variable slot.
 enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
 
 
 // Determine the left-hand side kind of an assignment.
 static LhsKind DetermineLhsKind(Expression* expr) {
   Property* property = expr->AsProperty();
-  ASSERT(expr->IsValidReferenceExpression());
+  DCHECK(expr->IsValidReferenceExpression());
   LhsKind lhs_kind =
       (property == NULL) ? VARIABLE : (property->key()->IsPropertyName())
                                           ? NAMED_PROPERTY
                                           : KEYED_PROPERTY;
   return lhs_kind;
 }
 
 
 // Helper to find an existing shared function info in the baseline code for the
 // given function literal. Used to canonicalize SharedFunctionInfo objects.
@@ skipping 26 matching lines @@
                                           Node* control_dependency)
     : StructuredGraphBuilder::Environment(builder, control_dependency),
       parameters_count_(scope->num_parameters() + 1),
       locals_count_(scope->num_stack_slots()),
       parameters_node_(NULL),
       locals_node_(NULL),
       stack_node_(NULL),
       parameters_dirty_(false),
       locals_dirty_(false),
       stack_dirty_(false) {
-  ASSERT_EQ(scope->num_parameters() + 1, parameters_count());
+  DCHECK_EQ(scope->num_parameters() + 1, parameters_count());
 
   // Bind the receiver variable.
   Node* receiver = builder->graph()->NewNode(common()->Parameter(0));
   values()->push_back(receiver);
 
   // Bind all parameter variables. The parameter indices are shifted by 1
   // (receiver is parameter index -1 but environment index 0).
   for (int i = 0; i < scope->num_parameters(); ++i) {
     Node* parameter = builder->graph()->NewNode(common()->Parameter(i + 1));
     values()->push_back(parameter);
@@ skipping 47 matching lines @@
 #endif
 }
 
 
 AstGraphBuilder::AstContext::~AstContext() {
   owner()->set_ast_context(outer_);  // Pop.
 }
 
 
 AstGraphBuilder::AstEffectContext::~AstEffectContext() {
-  ASSERT(environment()->stack_height() == original_height_);
+  DCHECK(environment()->stack_height() == original_height_);
 }
 
 
 AstGraphBuilder::AstValueContext::~AstValueContext() {
-  ASSERT(environment()->stack_height() == original_height_ + 1);
+  DCHECK(environment()->stack_height() == original_height_ + 1);
 }
 
 
 AstGraphBuilder::AstTestContext::~AstTestContext() {
-  ASSERT(environment()->stack_height() == original_height_ + 1);
+  DCHECK(environment()->stack_height() == original_height_ + 1);
 }
 
 
 void AstGraphBuilder::AstEffectContext::ProduceValue(Node* value) {
   // The value is ignored.
 }
 
 
 void AstGraphBuilder::AstValueContext::ProduceValue(Node* value) {
   environment()->Push(value);
@@ skipping 18 matching lines @@
 }
 
 
 AstGraphBuilder::BreakableScope* AstGraphBuilder::BreakableScope::FindBreakable(
     BreakableStatement* target) {
   BreakableScope* current = this;
   while (current != NULL && current->target_ != target) {
     owner_->environment()->Drop(current->drop_extra_);
     current = current->next_;
   }
-  ASSERT(current != NULL);  // Always found (unless stack is malformed).
+  DCHECK(current != NULL);  // Always found (unless stack is malformed).
   return current;
 }
 
 
 void AstGraphBuilder::BreakableScope::BreakTarget(BreakableStatement* stmt) {
   FindBreakable(stmt)->control_->Break();
 }
 
 
 void AstGraphBuilder::BreakableScope::ContinueTarget(BreakableStatement* stmt) {
@@ skipping 563 matching lines @@
   AccessorTable accessor_table(zone());
   for (int i = 0; i < expr->properties()->length(); i++) {
     ObjectLiteral::Property* property = expr->properties()->at(i);
     if (property->IsCompileTimeValue()) continue;
 
     Literal* key = property->key();
     switch (property->kind()) {
       case ObjectLiteral::Property::CONSTANT:
         UNREACHABLE();
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:
-        ASSERT(!CompileTimeValue::IsCompileTimeValue(property->value()));
+        DCHECK(!CompileTimeValue::IsCompileTimeValue(property->value()));
       // Fall through.
       case ObjectLiteral::Property::COMPUTED: {
         // It is safe to use [[Put]] here because the boilerplate already
         // contains computed properties with an uninitialized value.
         if (key->value()->IsInternalizedString()) {
           if (property->emit_store()) {
             VisitForValue(property->value());
             Node* value = environment()->Pop();
             PrintableUnique<Name> name = MakeUnique(key->AsPropertyName());
             NewNode(javascript()->StoreNamed(name), literal, value);
@@ skipping 89 matching lines @@
     Node* index = jsgraph()->Constant(i);
     NewNode(javascript()->StoreProperty(), literal, index, value);
   }
 
   environment()->Pop();  // Array literal index.
   ast_context()->ProduceValue(environment()->Pop());
 }
 
 
 void AstGraphBuilder::VisitForInAssignment(Expression* expr, Node* value) {
-  ASSERT(expr->IsValidReferenceExpression());
+  DCHECK(expr->IsValidReferenceExpression());
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->AsProperty();
   LhsKind assign_type = DetermineLhsKind(expr);
 
   // Evaluate LHS expression and store the value.
   switch (assign_type) {
     case VARIABLE: {
       Variable* var = expr->AsVariableProxy()->var();
       BuildVariableAssignment(var, value, Token::ASSIGN);
@@ skipping 17 matching lines @@
       Node* object = environment()->Pop();
       value = environment()->Pop();
       NewNode(javascript()->StoreProperty(), object, key, value);
       break;
     }
   }
 }
 
 
 void AstGraphBuilder::VisitAssignment(Assignment* expr) {
-  ASSERT(expr->target()->IsValidReferenceExpression());
+  DCHECK(expr->target()->IsValidReferenceExpression());
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->target()->AsProperty();
   LhsKind assign_type = DetermineLhsKind(expr->target());
 
   // Evaluate LHS expression.
   switch (assign_type) {
     case VARIABLE:
       // Nothing to do here.
       break;
@@ skipping 118 matching lines @@
   bool possibly_eval = false;
   switch (call_type) {
     case Call::GLOBAL_CALL: {
       Variable* variable = callee->AsVariableProxy()->var();
       callee_value = BuildVariableLoad(variable);
       receiver_value = jsgraph()->UndefinedConstant();
       break;
     }
     case Call::LOOKUP_SLOT_CALL: {
       Variable* variable = callee->AsVariableProxy()->var();
-      ASSERT(variable->location() == Variable::LOOKUP);
+      DCHECK(variable->location() == Variable::LOOKUP);
       Node* name = jsgraph()->Constant(variable->name());
       Operator* op = javascript()->Runtime(Runtime::kLoadLookupSlot, 2);
       Node* pair = NewNode(op, current_context(), name);
       callee_value = NewNode(common()->Projection(0), pair);
       receiver_value = NewNode(common()->Projection(1), pair);
       break;
     }
     case Call::PROPERTY_CALL: {
       Property* property = callee->AsProperty();
       VisitForValue(property->obj());
@@ skipping 101 matching lines @@
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
   const Runtime::Function* function = expr->function();
 
   // Handle calls to runtime functions implemented in JavaScript separately as
   // the call follows JavaScript ABI and the callee is statically unknown.
   if (expr->is_jsruntime()) {
-    ASSERT(function == NULL && expr->name()->length() > 0);
+    DCHECK(function == NULL && expr->name()->length() > 0);
     return VisitCallJSRuntime(expr);
   }
 
   // Evaluate all arguments to the runtime call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the runtime call.
   Runtime::FunctionId functionId = function->function_id;
   Operator* call = javascript()->Runtime(functionId, args->length());
@@ skipping 14 matching lines @@
       return VisitTypeof(expr);
     case Token::NOT:
       return VisitNot(expr);
     default:
       UNREACHABLE();
   }
 }
 
 
 void AstGraphBuilder::VisitCountOperation(CountOperation* expr) {
-  ASSERT(expr->expression()->IsValidReferenceExpression());
+  DCHECK(expr->expression()->IsValidReferenceExpression());
 
   // Left-hand side can only be a property, a global or a variable slot.
   Property* property = expr->expression()->AsProperty();
   LhsKind assign_type = DetermineLhsKind(expr->expression());
 
   // Reserve space for result of postfix operation.
   bool is_postfix = expr->is_postfix() && !ast_context()->IsEffect();
   if (is_postfix) environment()->Push(jsgraph()->UndefinedConstant());
 
   // Evaluate LHS expression and get old value.
@@ skipping 133 matching lines @@
 void AstGraphBuilder::VisitThisFunction(ThisFunction* expr) {
   Node* value = GetFunctionClosure();
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitCaseClause(CaseClause* expr) { UNREACHABLE(); }
 
 
 void AstGraphBuilder::VisitDeclarations(ZoneList<Declaration*>* declarations) {
-  ASSERT(globals()->is_empty());
+  DCHECK(globals()->is_empty());
   AstVisitor::VisitDeclarations(declarations);
   if (globals()->is_empty()) return;
   Handle<FixedArray> data =
       isolate()->factory()->NewFixedArray(globals()->length(), TENURED);
   for (int i = 0; i < globals()->length(); ++i) data->set(i, *globals()->at(i));
   int encoded_flags = DeclareGlobalsEvalFlag::encode(info()->is_eval()) |
                       DeclareGlobalsNativeFlag::encode(info()->is_native()) |
                       DeclareGlobalsStrictMode::encode(info()->strict_mode());
   Node* flags = jsgraph()->Constant(encoded_flags);
   Node* pairs = jsgraph()->Constant(data);
@@ skipping 15 matching lines @@
   Visit(stmt->body());
 }
 
 
 void AstGraphBuilder::VisitDelete(UnaryOperation* expr) {
   Node* value;
   if (expr->expression()->IsVariableProxy()) {
     // Delete of an unqualified identifier is only allowed in classic mode but
     // deleting "this" is allowed in all language modes.
     Variable* variable = expr->expression()->AsVariableProxy()->var();
-    ASSERT(strict_mode() == SLOPPY || variable->is_this());
+    DCHECK(strict_mode() == SLOPPY || variable->is_this());
     value = BuildVariableDelete(variable);
   } else if (expr->expression()->IsProperty()) {
     Property* property = expr->expression()->AsProperty();
     VisitForValue(property->obj());
     VisitForValue(property->key());
     Node* key = environment()->Pop();
     Node* object = environment()->Pop();
     value = NewNode(javascript()->DeleteProperty(strict_mode()), object, key);
   } else {
     VisitForEffect(expr->expression());
@@ skipping 61 matching lines @@
     Visit(expr->right());
   } else if (ast_context()->IsEffect()) {
     environment()->Pop();
   }
   compare_if.End();
   ast_context()->ReplaceValue();
 }
 
 
 Node* AstGraphBuilder::ProcessArguments(Operator* op, int arity) {
-  ASSERT(environment()->stack_height() >= arity);
+  DCHECK(environment()->stack_height() >= arity);
   Node** all = info()->zone()->NewArray<Node*>(arity);  // XXX: alloca?
   for (int i = arity - 1; i >= 0; --i) {
     all[i] = environment()->Pop();
   }
   Node* value = NewNode(op, arity, all);
   return value;
 }
 
 
 Node* AstGraphBuilder::BuildLocalFunctionContext(Node* context, Node* closure) {
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots <= 0) return context;
   set_current_context(context);
 
   // Allocate a new local context.
   Operator* op = javascript()->CreateFunctionContext();
   Node* local_context = NewNode(op, closure);
   set_current_context(local_context);
 
   // Copy parameters into context if necessary.
   int num_parameters = info()->scope()->num_parameters();
   for (int i = 0; i < num_parameters; i++) {
     Variable* variable = info()->scope()->parameter(i);
     if (!variable->IsContextSlot()) continue;
     // Temporary parameter node. The parameter indices are shifted by 1
     // (receiver is parameter index -1 but environment index 0).
     Node* parameter = NewNode(common()->Parameter(i + 1));
     // Context variable (at bottom of the context chain).
-    ASSERT_EQ(0, info()->scope()->ContextChainLength(variable->scope()));
+    DCHECK_EQ(0, info()->scope()->ContextChainLength(variable->scope()));
     Operator* op = javascript()->StoreContext(0, variable->index());
     NewNode(op, local_context, parameter);
   }
 
   return local_context;
 }
 
 
 Node* AstGraphBuilder::BuildArgumentsObject(Variable* arguments) {
   if (arguments == NULL) return NULL;
 
   // Allocate and initialize a new arguments object.
   Node* callee = GetFunctionClosure();
   Operator* op = javascript()->Runtime(Runtime::kNewArguments, 1);
   Node* object = NewNode(op, callee);
 
   // Assign the object to the arguments variable.
-  ASSERT(arguments->IsContextSlot() || arguments->IsStackAllocated());
+  DCHECK(arguments->IsContextSlot() || arguments->IsStackAllocated());
   BuildVariableAssignment(arguments, object, Token::ASSIGN);
 
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildHoleCheckSilent(Node* value, Node* for_hole,
                                             Node* not_hole) {
   IfBuilder hole_check(this);
   Node* the_hole = jsgraph()->TheHoleConstant();
@@ skipping 298 matching lines @@
       UNREACHABLE();
       js_op = NULL;
   }
   return NewNode(js_op, left, right);
 }
 
 
 void AstGraphBuilder::BuildLazyBailout(Node* node, BailoutId ast_id) {
   if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
     // The deopting node should have an outgoing control dependency.
-    ASSERT(GetControlDependency() == node);
+    DCHECK(GetControlDependency() == node);
 
     StructuredGraphBuilder::Environment* continuation_env =
         environment_internal();
     // Create environment for the deoptimization block, and build the block.
     StructuredGraphBuilder::Environment* deopt_env =
         CopyEnvironment(continuation_env);
     set_environment(deopt_env);
 
     NewNode(common()->LazyDeoptimization());
 
     FrameStateDescriptor stateDescriptor(ast_id);
     Node* state_node = NewNode(common()->FrameState(stateDescriptor));
 
     Node* deoptimize_node = NewNode(common()->Deoptimize(), state_node);
 
     UpdateControlDependencyToLeaveFunction(deoptimize_node);
 
     // Continue with the original environment.
     set_environment(continuation_env);
 
     NewNode(common()->Continuation());
   }
 }
 }
 }
 }  // namespace v8::internal::compiler