[wasm] Clean up some DCHECKS in asm->wasm.

src/wasm/asm-wasm-builder.cc

 // Copyright 2015 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/wasm/asm-wasm-builder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
@@ skipping 59 matching lines @@
 
   void Compile() {
     InitializeInitFunction();
     RECURSE(VisitFunctionLiteral(literal_));
   }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK(!in_function_);
-    DCHECK(current_function_builder_ == nullptr);
+    DCHECK_NULL(current_function_builder_);
     uint16_t index = LookupOrInsertFunction(decl->proxy()->var());
     current_function_builder_ = builder_->FunctionAt(index);
     in_function_ = true;
     RECURSE(Visit(decl->fun()));
     in_function_ = false;
     current_function_builder_ = nullptr;
     local_variables_.Clear();
   }
 
   void VisitImportDeclaration(ImportDeclaration* decl) {}
@@ skipping 71 matching lines @@
     } else {
       current_function_builder_->Emit(kExprNop);
     }
     if (stmt->HasElseStatement()) {
       RECURSE(Visit(stmt->else_statement()));
     }
   }
 
   void VisitContinueStatement(ContinueStatement* stmt) {
     DCHECK(in_function_);
-    DCHECK(stmt->target() != NULL);
+    DCHECK_NOT_NULL(stmt->target());
     int i = static_cast<int>(breakable_blocks_.size()) - 1;
     int block_distance = 0;
     for (; i >= 0; i--) {
       auto elem = breakable_blocks_.at(i);
       if (elem.first == stmt->target()) {
         DCHECK(elem.second);
         break;
       } else if (elem.second) {
         block_distance += 2;
       } else {
         block_distance += 1;
       }
     }
     DCHECK(i >= 0);
     current_function_builder_->EmitWithU8(kExprBr, block_distance);
     current_function_builder_->Emit(kExprNop);
   }
 
   void VisitBreakStatement(BreakStatement* stmt) {
     DCHECK(in_function_);
-    DCHECK(stmt->target() != NULL);
+    DCHECK_NOT_NULL(stmt->target());
     int i = static_cast<int>(breakable_blocks_.size()) - 1;
     int block_distance = 0;
     for (; i >= 0; i--) {
       auto elem = breakable_blocks_.at(i);
       if (elem.first == stmt->target()) {
         if (elem.second) {
           block_distance++;
         }
         break;
       } else if (elem.second) {
@@ skipping 25 matching lines @@
     current_function_builder_->Emit(kExprSetLocal);
     AddLeb128(index, true);
     byte code[] = {WASM_I32(value)};
     current_function_builder_->EmitCode(code, sizeof(code));
     block_size_++;
   }
 
   void CompileCase(CaseClause* clause, uint16_t fall_through,
                    VariableProxy* tag) {
     Literal* label = clause->label()->AsLiteral();
-    DCHECK(label != nullptr);
+    DCHECK_NOT_NULL(label);
     block_size_++;
     current_function_builder_->Emit(kExprIf);
     current_function_builder_->Emit(kExprI32Ior);
     current_function_builder_->Emit(kExprI32Eq);
     VisitVariableProxy(tag);
     VisitLiteral(label);
     current_function_builder_->Emit(kExprGetLocal);
     AddLeb128(fall_through, true);
     BlockVisitor visitor(this, nullptr, kExprBlock, false, 0);
     SetLocalTo(fall_through, 1);
     ZoneList<Statement*>* stmts = clause->statements();
     block_size_ += stmts->length();
     RECURSE(VisitStatements(stmts));
   }
 
   void VisitSwitchStatement(SwitchStatement* stmt) {
     VariableProxy* tag = stmt->tag()->AsVariableProxy();
-    DCHECK(tag != NULL);
+    DCHECK_NOT_NULL(tag);
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false,
                          0);
     uint16_t fall_through = current_function_builder_->AddLocal(kAstI32);
     SetLocalTo(fall_through, 0);
 
     ZoneList<CaseClause*>* clauses = stmt->cases();
     for (int i = 0; i < clauses->length(); ++i) {
       CaseClause* clause = clauses->at(i);
       if (!clause->is_default()) {
         CompileCase(clause, fall_through, tag);
@@ skipping 69 matching lines @@
 
   void VisitFunctionLiteral(FunctionLiteral* expr) {
     Scope* scope = expr->scope();
     if (in_function_) {
       if (expr->bounds().lower->IsFunction()) {
         FunctionType* func_type = expr->bounds().lower->AsFunction();
         LocalType return_type = TypeFrom(func_type->Result());
         current_function_builder_->ReturnType(return_type);
         for (int i = 0; i < expr->parameter_count(); i++) {
           LocalType type = TypeFrom(func_type->Parameter(i));
-          DCHECK(type != kAstStmt);
+          DCHECK_NE(kAstStmt, type);
           LookupOrInsertLocal(scope->parameter(i), type);
         }
       } else {
         UNREACHABLE();
       }
     }
     RECURSE(VisitStatements(expr->body()));
     RECURSE(VisitDeclarations(scope->declarations()));
   }
 
@@ skipping 20 matching lines @@
         }
         is_set_op_ = false;
       } else {
         if (var->IsContextSlot()) {
           current_function_builder_->Emit(kExprLoadGlobal);
         } else {
           current_function_builder_->Emit(kExprGetLocal);
         }
       }
       LocalType var_type = TypeOf(expr);
-      DCHECK(var_type != kAstStmt);
+      DCHECK_NE(kAstStmt, var_type);
       if (var->IsContextSlot()) {
         AddLeb128(LookupOrInsertGlobal(var, var_type), false);
       } else {
         AddLeb128(LookupOrInsertLocal(var, var_type), true);
       }
     }
   }
 
   void VisitLiteral(Literal* expr) {
     if (in_function_) {
@@ skipping 26 matching lines @@
   }
 
   void VisitRegExpLiteral(RegExpLiteral* expr) { UNREACHABLE(); }
 
   void VisitObjectLiteral(ObjectLiteral* expr) {
     ZoneList<ObjectLiteralProperty*>* props = expr->properties();
     for (int i = 0; i < props->length(); ++i) {
       ObjectLiteralProperty* prop = props->at(i);
       DCHECK(marking_exported);
       VariableProxy* expr = prop->value()->AsVariableProxy();
-      DCHECK(expr != nullptr);
+      DCHECK_NOT_NULL(expr);
       Variable* var = expr->var();
       Literal* name = prop->key()->AsLiteral();
-      DCHECK(name != nullptr);
+      DCHECK_NOT_NULL(name);
       DCHECK(name->IsPropertyName());
       const AstRawString* raw_name = name->AsRawPropertyName();
       if (var->is_function()) {
         uint16_t index = LookupOrInsertFunction(var);
         builder_->FunctionAt(index)->Exported(1);
         builder_->FunctionAt(index)
             ->SetName(raw_name->raw_data(), raw_name->length());
       }
     }
   }
@@ skipping 20 matching lines @@
       sig.AddReturn(static_cast<LocalType>(return_type));
     }
     for (int i = 0; i < func_type->Arity(); i++) {
       sig.AddParam(TypeFrom(func_type->Parameter(i)));
     }
     uint16_t signature_index = builder_->AddSignature(sig.Build());
     InsertFunctionTable(table->var(), next_table_index_, signature_index);
     next_table_index_ += funcs->values()->length();
     for (int i = 0; i < funcs->values()->length(); i++) {
       VariableProxy* func = funcs->values()->at(i)->AsVariableProxy();
-      DCHECK(func != nullptr);
+      DCHECK_NOT_NULL(func);
       builder_->AddIndirectFunction(LookupOrInsertFunction(func->var()));
     }
   }
 
   struct FunctionTableIndices : public ZoneObject {
     uint32_t start_index;
     uint16_t signature_index;
   };
 
   void InsertFunctionTable(Variable* v, uint32_t start_index,
                            uint16_t signature_index) {
     FunctionTableIndices* container = new (zone()) FunctionTableIndices();
     container->start_index = start_index;
     container->signature_index = signature_index;
     ZoneHashMap::Entry* entry = function_tables_.LookupOrInsert(
         v, ComputePointerHash(v), ZoneAllocationPolicy(zone()));
     entry->value = container;
   }
 
   FunctionTableIndices* LookupFunctionTable(Variable* v) {
     ZoneHashMap::Entry* entry =
         function_tables_.Lookup(v, ComputePointerHash(v));
-    DCHECK(entry != nullptr);
+    DCHECK_NOT_NULL(entry);
     return reinterpret_cast<FunctionTableIndices*>(entry->value);
   }
 
   class ImportedFunctionTable {
    private:
     class ImportedFunctionIndices : public ZoneObject {
      public:
       const unsigned char* name_;
       int name_length_;
       WasmModuleBuilder::SignatureMap signature_to_index_;
@@ skipping 14 matching lines @@
     void AddImport(Variable* v, const unsigned char* name, int name_length) {
       ImportedFunctionIndices* indices = new (builder_->zone())
           ImportedFunctionIndices(name, name_length, builder_->zone());
       ZoneHashMap::Entry* entry = table_.LookupOrInsert(
           v, ComputePointerHash(v), ZoneAllocationPolicy(builder_->zone()));
       entry->value = indices;
     }
 
     uint16_t GetFunctionIndex(Variable* v, FunctionSig* sig) {
       ZoneHashMap::Entry* entry = table_.Lookup(v, ComputePointerHash(v));
-      DCHECK(entry != nullptr);
+      DCHECK_NOT_NULL(entry);
       ImportedFunctionIndices* indices =
           reinterpret_cast<ImportedFunctionIndices*>(entry->value);
       WasmModuleBuilder::SignatureMap::iterator pos =
           indices->signature_to_index_.find(sig);
       if (pos != indices->signature_to_index_.end()) {
         return pos->second;
       } else {
         uint16_t index = builder_->builder_->AddFunction();
         indices->signature_to_index_[sig] = index;
         WasmFunctionBuilder* function = builder_->builder_->FunctionAt(index);
         function->External(1);
         function->SetName(indices->name_, indices->name_length_);
         if (sig->return_count() > 0) {
           function->ReturnType(sig->GetReturn());
         }
         for (size_t i = 0; i < sig->parameter_count(); i++) {
           function->AddParam(sig->GetParam(i));
         }
         return index;
       }
     }
   };
 
   void VisitAssignment(Assignment* expr) {
     bool in_init = false;
     if (!in_function_) {
       BinaryOperation* binop = expr->value()->AsBinaryOperation();
       if (binop != nullptr) {
         Property* prop = binop->left()->AsProperty();
-        DCHECK(prop != nullptr);
+        DCHECK_NOT_NULL(prop);
         LoadInitFunction();
         is_set_op_ = true;
         RECURSE(Visit(expr->target()));
         DCHECK(!is_set_op_);
         if (binop->op() == Token::MUL) {
           DCHECK(binop->right()->IsLiteral());
-          DCHECK(binop->right()->AsLiteral()->raw_value()->AsNumber() == 1.0);
+          DCHECK_EQ(1.0, binop->right()->AsLiteral()->raw_value()->AsNumber());
           DCHECK(binop->right()->AsLiteral()->raw_value()->ContainsDot());
           VisitForeignVariable(true, prop);
         } else if (binop->op() == Token::BIT_OR) {
           DCHECK(binop->right()->IsLiteral());
-          DCHECK(binop->right()->AsLiteral()->raw_value()->AsNumber() == 0.0);
+          DCHECK_EQ(0.0, binop->right()->AsLiteral()->raw_value()->AsNumber());
           DCHECK(!binop->right()->AsLiteral()->raw_value()->ContainsDot());
           VisitForeignVariable(false, prop);
         } else {
           UNREACHABLE();
         }
         UnLoadInitFunction();
         return;
       }
       // TODO(bradnelson): Get rid of this.
       if (TypeOf(expr->value()) == kAstStmt) {
         Property* prop = expr->value()->AsProperty();
         if (prop != nullptr) {
           VariableProxy* vp = prop->obj()->AsVariableProxy();
           if (vp != nullptr && vp->var()->IsParameter() &&
               vp->var()->index() == 1) {
             VariableProxy* target = expr->target()->AsVariableProxy();
             if (target->bounds().lower->Is(Type::Function())) {
               const AstRawString* name =
                   prop->key()->AsLiteral()->AsRawPropertyName();
               imported_function_table_.AddImport(
                   target->var(), name->raw_data(), name->length());
             }
           }
         }
         ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
         if (funcs != nullptr &&
             funcs->bounds().lower->AsArray()->Element()->IsFunction()) {
           VariableProxy* target = expr->target()->AsVariableProxy();
-          DCHECK(target != nullptr);
+          DCHECK_NOT_NULL(target);
           AddFunctionTable(target, funcs);
         }
         return;
       }
       in_init = true;
       LoadInitFunction();
     }
     BinaryOperation* value_op = expr->value()->AsBinaryOperation();
     if (value_op != nullptr && MatchBinaryOperation(value_op) == kAsIs) {
       VariableProxy* target_var = expr->target()->AsVariableProxy();
@@ skipping 12 matching lines @@
       UnLoadInitFunction();
     }
   }
 
   void VisitYield(Yield* expr) { UNREACHABLE(); }
 
   void VisitThrow(Throw* expr) { UNREACHABLE(); }
 
   void VisitForeignVariable(bool is_float, Property* expr) {
     DCHECK(expr->obj()->AsVariableProxy());
-    DCHECK(expr->obj()->AsVariableProxy()->var()->location() ==
-           VariableLocation::PARAMETER);
-    DCHECK(expr->obj()->AsVariableProxy()->var()->index() == 1);
+    DCHECK(VariableLocation::PARAMETER ==
+           expr->obj()->AsVariableProxy()->var()->location());
+    DCHECK_EQ(1, expr->obj()->AsVariableProxy()->var()->index());
     Literal* key_literal = expr->key()->AsLiteral();
-    DCHECK(key_literal != nullptr);
+    DCHECK_NOT_NULL(key_literal);
     if (!key_literal->value().is_null() && !foreign_.is_null() &&
         foreign_->IsObject()) {
       Handle<Name> name =
           i::Object::ToName(isolate_, key_literal->value()).ToHandleChecked();
       MaybeHandle<Object> maybe_value = i::Object::GetProperty(foreign_, name);
       if (!maybe_value.is_null()) {
         Handle<Object> value = maybe_value.ToHandleChecked();
         if (is_float) {
           MaybeHandle<Object> maybe_nvalue = i::Object::ToNumber(value);
           if (!maybe_nvalue.is_null()) {
@@ skipping 24 matching lines @@
       byte code[] = {WASM_F64(std::numeric_limits<double>::quiet_NaN())};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else {
       byte code[] = {WASM_I32(0)};
       current_function_builder_->EmitCode(code, sizeof(code));
     }
   }
 
   void VisitProperty(Property* expr) {
     Expression* obj = expr->obj();
-    DCHECK(obj->bounds().lower == obj->bounds().upper);
+    DCHECK_EQ(obj->bounds().lower, obj->bounds().upper);
     Type* type = obj->bounds().lower;
     MachineType mtype;
     int size;
     if (type->Is(cache_.kUint8Array)) {
       mtype = MachineType::Uint8();
       size = 1;
     } else if (type->Is(cache_.kInt8Array)) {
       mtype = MachineType::Int8();
       size = 1;
     } else if (type->Is(cache_.kUint16Array)) {
@@ skipping 28 matching lines @@
       // Allow more general expression in byte arrays than the spec
       // strictly permits.
       // Early versions of Emscripten emit HEAP8[HEAP32[..]|0] in
       // places that strictly should be HEAP8[HEAP32[..]>>0].
       RECURSE(Visit(expr->key()));
       return;
     } else {
       Literal* value = expr->key()->AsLiteral();
       if (value) {
         DCHECK(value->raw_value()->IsNumber());
-        DCHECK(kAstI32 == TypeOf(value));
+        DCHECK_EQ(kAstI32, TypeOf(value));
         int val = static_cast<int>(value->raw_value()->AsNumber());
         byte code[] = {WASM_I32(val * size)};
         current_function_builder_->EmitCode(code, sizeof(code));
         return;
       }
       BinaryOperation* binop = expr->key()->AsBinaryOperation();
       if (binop) {
-        DCHECK(Token::SAR == binop->op());
+        DCHECK_EQ(Token::SAR, binop->op());
         DCHECK(binop->right()->AsLiteral()->raw_value()->IsNumber());
         DCHECK(kAstI32 == TypeOf(binop->right()->AsLiteral()));
-        DCHECK(size ==
-               1 << static_cast<int>(
-                   binop->right()->AsLiteral()->raw_value()->AsNumber()));
+        DCHECK_EQ(size,
+                  1 << static_cast<int>(
+                      binop->right()->AsLiteral()->raw_value()->AsNumber()));
         // Mask bottom bits to match asm.js behavior.
         current_function_builder_->Emit(kExprI32And);
         byte code[] = {WASM_I8(~(size - 1))};
         current_function_builder_->EmitCode(code, sizeof(code));
         RECURSE(Visit(binop->left()));
         return;
       }
     }
     UNREACHABLE();
   }
@@ skipping 24 matching lines @@
         }
         current_function_builder_->Emit(kExprCallFunction);
         std::vector<uint8_t> index_arr = UnsignedLEB128From(index);
         current_function_builder_->EmitCode(
             &index_arr[0], static_cast<uint32_t>(index_arr.size()));
         break;
       }
       case Call::KEYED_PROPERTY_CALL: {
         DCHECK(in_function_);
         Property* p = expr->expression()->AsProperty();
-        DCHECK(p != nullptr);
+        DCHECK_NOT_NULL(p);
         VariableProxy* var = p->obj()->AsVariableProxy();
-        DCHECK(var != nullptr);
+        DCHECK_NOT_NULL(var);
         FunctionTableIndices* indices = LookupFunctionTable(var->var());
         current_function_builder_->EmitWithU8(kExprCallIndirect,
                                               indices->signature_index);
         current_function_builder_->Emit(kExprI32Add);
         byte code[] = {WASM_I32(indices->start_index)};
         current_function_builder_->EmitCode(code, sizeof(code));
         RECURSE(Visit(p->key()));
         break;
       }
       default:
         UNREACHABLE();
     }
     ZoneList<Expression*>* args = expr->arguments();
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(Visit(arg));
     }
   }
 
   void VisitCallNew(CallNew* expr) { UNREACHABLE(); }
 
   void VisitCallRuntime(CallRuntime* expr) { UNREACHABLE(); }
 
   void VisitUnaryOperation(UnaryOperation* expr) {
     switch (expr->op()) {
       case Token::NOT: {
-        DCHECK(TypeOf(expr->expression()) == kAstI32);
+        DCHECK_EQ(kAstI32, TypeOf(expr->expression()));
         current_function_builder_->Emit(kExprBoolNot);
         break;
       }
       default:
         UNREACHABLE();
     }
     RECURSE(Visit(expr->expression()));
   }
 
   void VisitCountOperation(CountOperation* expr) { UNREACHABLE(); }
 
   bool MatchIntBinaryOperation(BinaryOperation* expr, Token::Value op,
                                int32_t val) {
-    DCHECK(expr->right() != nullptr);
+    DCHECK_NOT_NULL(expr->right());
     if (expr->op() == op && expr->right()->IsLiteral() &&
         TypeOf(expr) == kAstI32) {
       Literal* right = expr->right()->AsLiteral();
       DCHECK(right->raw_value()->IsNumber());
       if (static_cast<int32_t>(right->raw_value()->AsNumber()) == val) {
         return true;
       }
     }
     return false;
   }
 
   bool MatchDoubleBinaryOperation(BinaryOperation* expr, Token::Value op,
                                   double val) {
-    DCHECK(expr->right() != nullptr);
+    DCHECK_NOT_NULL(expr->right());
     if (expr->op() == op && expr->right()->IsLiteral() &&
         TypeOf(expr) == kAstF64) {
       Literal* right = expr->right()->AsLiteral();
       DCHECK(right->raw_value()->IsNumber());
       if (right->raw_value()->AsNumber() == val) {
         return true;
       }
     }
     return false;
   }
@@ skipping 14 matching lines @@
     if (MatchIntBinaryOperation(expr, Token::SHR, 0)) {
       // TODO(titzer): this probably needs to be kToUint
       return (TypeOf(expr->left()) == kAstI32) ? kAsIs : kToInt;
     } else {
       return kNone;
     }
   }
 
   ConvertOperation MatchXor(BinaryOperation* expr) {
     if (MatchIntBinaryOperation(expr, Token::BIT_XOR, 0xffffffff)) {
-      DCHECK(TypeOf(expr->left()) == kAstI32);
-      DCHECK(TypeOf(expr->right()) == kAstI32);
+      DCHECK_EQ(kAstI32, TypeOf(expr->left()));
+      DCHECK_EQ(kAstI32, TypeOf(expr->right()));
       BinaryOperation* op = expr->left()->AsBinaryOperation();
       if (op != nullptr) {
         if (MatchIntBinaryOperation(op, Token::BIT_XOR, 0xffffffff)) {
-          DCHECK(TypeOf(op->right()) == kAstI32);
+          DCHECK_EQ(kAstI32, TypeOf(op->right()));
           if (TypeOf(op->left()) != kAstI32) {
             return kToInt;
           } else {
             return kAsIs;
           }
         }
       }
     }
     return kNone;
   }
 
   ConvertOperation MatchMul(BinaryOperation* expr) {
     if (MatchDoubleBinaryOperation(expr, Token::MUL, 1.0)) {
-      DCHECK(TypeOf(expr->right()) == kAstF64);
+      DCHECK_EQ(kAstF64, TypeOf(expr->right()));
       if (TypeOf(expr->left()) != kAstF64) {
         return kToDouble;
       } else {
         return kAsIs;
       }
     } else {
       return kNone;
     }
   }
 
@@ skipping 193 matching lines @@
     if (left_index == kFixnum && right_index == kFixnum) {
       left_index = kInt32;
       right_index = kInt32;
     }
     DCHECK((left_index == right_index) ||
            (ignore_sign && (left_index <= 1) && (right_index <= 1)));
     return left_index;
   }
 
   TypeIndex TypeIndexOf(Expression* expr) {
-    DCHECK(expr->bounds().lower == expr->bounds().upper);
+    DCHECK_EQ(expr->bounds().lower, expr->bounds().upper);
     Type* type = expr->bounds().lower;
     if (type->Is(cache_.kAsmFixnum)) {
       return kFixnum;
     } else if (type->Is(cache_.kAsmSigned)) {
       return kInt32;
     } else if (type->Is(cache_.kAsmUnsigned)) {
       return kUint32;
     } else if (type->Is(cache_.kAsmInt)) {
       return kInt32;
     } else if (type->Is(cache_.kAsmFloat)) {
@@ skipping 39 matching lines @@
   void VisitRewritableAssignmentExpression(
       RewritableAssignmentExpression* expr) {
     UNREACHABLE();
   }
 
   struct IndexContainer : public ZoneObject {
     uint16_t index;
   };
 
   uint16_t LookupOrInsertLocal(Variable* v, LocalType type) {
-    DCHECK(current_function_builder_ != nullptr);
+    DCHECK_NOT_NULL(current_function_builder_);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
       uint16_t index;
       if (v->IsParameter()) {
         index = current_function_builder_->AddParam(type);
       } else {
         index = current_function_builder_->AddLocal(type);
       }
       IndexContainer* container = new (zone()) IndexContainer();
@@ skipping 14 matching lines @@
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v),
                                                ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   uint16_t LookupOrInsertFunction(Variable* v) {
-    DCHECK(builder_ != nullptr);
+    DCHECK_NOT_NULL(builder_);
     ZoneHashMap::Entry* entry = functions_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
       uint16_t index = builder_->AddFunction();
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
                                         ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   LocalType TypeOf(Expression* expr) {
-    DCHECK(expr->bounds().lower == expr->bounds().upper);
+    DCHECK_EQ(expr->bounds().lower, expr->bounds().upper);
     return TypeFrom(expr->bounds().lower);
   }
 
   LocalType TypeFrom(Type* type) {
     if (type->Is(cache_.kAsmInt)) {
       return kAstI32;
     } else if (type->Is(cache_.kAsmFloat)) {
       return kAstF32;
     } else if (type->Is(cache_.kAsmDouble)) {
       return kAstF64;
@@ skipping 38 matching lines @@
 // that zone in constructor may be thrown away once wasm module is written.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, foreign_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8