Templatize AstVisitor with its subclass

src/asmjs/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"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 21 matching lines @@
   } while (false)
 
 enum AsmScope { kModuleScope, kInitScope, kFuncScope, kExportScope };
 
 struct ForeignVariable {
   Handle<Name> name;
   Variable* var;
   LocalType type;
 };
 
-class AsmWasmBuilderImpl : public AstVisitor {
+class AsmWasmBuilderImpl final : public AstVisitor<AsmWasmBuilderImpl> {
  public:
   AsmWasmBuilderImpl(Isolate* isolate, Zone* zone, FunctionLiteral* literal,
                      AsmTyper* typer)
       : local_variables_(base::HashMap::PointersMatch,
                          ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
         functions_(base::HashMap::PointersMatch,
                    ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
         global_variables_(base::HashMap::PointersMatch,
@@ skipping 61 matching lines @@
     }
     return ret;
   }
 
   void Build() {
     InitializeInitFunction();
     RECURSE(VisitFunctionLiteral(literal_));
     BuildForeignInitFunction();
   }
 
-  void VisitVariableDeclaration(VariableDeclaration* decl) override {}
+  void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
-  void VisitFunctionDeclaration(FunctionDeclaration* decl) override {
+  void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK_EQ(kModuleScope, scope_);
     DCHECK_NULL(current_function_builder_);
     uint32_t index = LookupOrInsertFunction(decl->proxy()->var());
     current_function_builder_ = builder_->FunctionAt(index);
     scope_ = kFuncScope;
     RECURSE(Visit(decl->fun()));
     scope_ = kModuleScope;
     current_function_builder_ = nullptr;
     local_variables_.Clear();
   }
 
-  void VisitImportDeclaration(ImportDeclaration* decl) override {}
+  void VisitImportDeclaration(ImportDeclaration* decl) {}
 
-  void VisitStatements(ZoneList<Statement*>* stmts) override {
+  void VisitStatements(ZoneList<Statement*>* stmts) {
     for (int i = 0; i < stmts->length(); ++i) {
       Statement* stmt = stmts->at(i);
       ExpressionStatement* e = stmt->AsExpressionStatement();
       if (e != nullptr && e->expression()->IsUndefinedLiteral()) {
         continue;
       }
       RECURSE(Visit(stmt));
       if (stmt->IsJump()) break;
     }
   }
 
-  void VisitBlock(Block* stmt) override {
+  void VisitBlock(Block* stmt) {
     if (stmt->statements()->length() == 1) {
       ExpressionStatement* expr =
           stmt->statements()->at(0)->AsExpressionStatement();
       if (expr != nullptr) {
         if (expr->expression()->IsAssignment()) {
           RECURSE(VisitExpressionStatement(expr));
           return;
         }
       }
     }
@@ skipping 16 matching lines @@
         : builder_(builder) {
       builder_->breakable_blocks_.push_back(std::make_pair(stmt, is_loop));
       builder_->current_function_builder_->Emit(opcode);
     }
     ~BlockVisitor() {
       builder_->current_function_builder_->Emit(kExprEnd);
       builder_->breakable_blocks_.pop_back();
     }
   };
 
-  void VisitExpressionStatement(ExpressionStatement* stmt) override {
+  void VisitExpressionStatement(ExpressionStatement* stmt) {
     RECURSE(Visit(stmt->expression()));
   }
 
-  void VisitEmptyStatement(EmptyStatement* stmt) override {}
+  void VisitEmptyStatement(EmptyStatement* stmt) {}
 
-  void VisitEmptyParentheses(EmptyParentheses* paren) override {
-    UNREACHABLE();
-  }
+  void VisitEmptyParentheses(EmptyParentheses* paren) { UNREACHABLE(); }
 
-  void VisitIfStatement(IfStatement* stmt) override {
+  void VisitIfStatement(IfStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     RECURSE(Visit(stmt->condition()));
     current_function_builder_->Emit(kExprIf);
     // WASM ifs come with implement blocks for both arms.
     breakable_blocks_.push_back(std::make_pair(nullptr, false));
     if (stmt->HasThenStatement()) {
       RECURSE(Visit(stmt->then_statement()));
     }
     if (stmt->HasElseStatement()) {
       current_function_builder_->Emit(kExprElse);
       RECURSE(Visit(stmt->else_statement()));
     }
     current_function_builder_->Emit(kExprEnd);
     breakable_blocks_.pop_back();
   }
 
-  void VisitContinueStatement(ContinueStatement* stmt) override {
+  void VisitContinueStatement(ContinueStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     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, ARITY_0);
     current_function_builder_->EmitVarInt(block_distance);
   }
 
-  void VisitBreakStatement(BreakStatement* stmt) override {
+  void VisitBreakStatement(BreakStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     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) {
         block_distance += 2;
       } else {
         block_distance += 1;
       }
     }
     DCHECK(i >= 0);
     current_function_builder_->EmitWithU8(kExprBr, ARITY_0);
     current_function_builder_->EmitVarInt(block_distance);
   }
 
-  void VisitReturnStatement(ReturnStatement* stmt) override {
+  void VisitReturnStatement(ReturnStatement* stmt) {
     if (scope_ == kModuleScope) {
       scope_ = kExportScope;
       RECURSE(Visit(stmt->expression()));
       scope_ = kModuleScope;
     } else if (scope_ == kFuncScope) {
       RECURSE(Visit(stmt->expression()));
       uint8_t arity =
           TypeOf(stmt->expression()) == kAstStmt ? ARITY_0 : ARITY_1;
       current_function_builder_->EmitWithU8(kExprReturn, arity);
     } else {
       UNREACHABLE();
     }
   }
 
-  void VisitWithStatement(WithStatement* stmt) override { UNREACHABLE(); }
+  void VisitWithStatement(WithStatement* stmt) { UNREACHABLE(); }
 
   void HandleCase(CaseNode* node,
                   const ZoneMap<int, unsigned int>& case_to_block,
                   VariableProxy* tag, int default_block, int if_depth) {
     int prev_if_depth = if_depth;
     if (node->left != nullptr) {
       VisitVariableProxy(tag);
       current_function_builder_->EmitI32Const(node->begin);
       current_function_builder_->Emit(kExprI32LtS);
       current_function_builder_->Emit(kExprIf);
@@ skipping 47 matching lines @@
       byte break_code[] = {BR_TARGET(if_depth + default_block)};
       current_function_builder_->EmitCode(break_code, sizeof(break_code));
     }
 
     while (if_depth-- != prev_if_depth) {
       breakable_blocks_.pop_back();
       current_function_builder_->Emit(kExprEnd);
     }
   }
 
-  void VisitSwitchStatement(SwitchStatement* stmt) override {
+  void VisitSwitchStatement(SwitchStatement* stmt) {
     VariableProxy* tag = stmt->tag()->AsVariableProxy();
     DCHECK_NOT_NULL(tag);
     ZoneList<CaseClause*>* clauses = stmt->cases();
     int case_count = clauses->length();
     if (case_count == 0) {
       return;
     }
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false);
     ZoneVector<BlockVisitor*> blocks(zone_);
     ZoneVector<int32_t> cases(zone_);
@@ skipping 31 matching lines @@
     }
     for (int i = 0; i < case_count; ++i) {
       CaseClause* clause = clauses->at(i);
       RECURSE(VisitStatements(clause->statements()));
       BlockVisitor* v = blocks.at(case_count - i - 1);
       blocks.pop_back();
       delete v;
     }
   }
 
-  void VisitCaseClause(CaseClause* clause) override { UNREACHABLE(); }
+  void VisitCaseClause(CaseClause* clause) { UNREACHABLE(); }
 
-  void VisitDoWhileStatement(DoWhileStatement* stmt) override {
+  void VisitDoWhileStatement(DoWhileStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
     RECURSE(Visit(stmt->body()));
     RECURSE(Visit(stmt->cond()));
     current_function_builder_->Emit(kExprIf);
     current_function_builder_->EmitWithU8U8(kExprBr, ARITY_0, 1);
     current_function_builder_->Emit(kExprEnd);
   }
 
-  void VisitWhileStatement(WhileStatement* stmt) override {
+  void VisitWhileStatement(WhileStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
     RECURSE(Visit(stmt->cond()));
     breakable_blocks_.push_back(std::make_pair(nullptr, false));
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->body()));
     current_function_builder_->EmitWithU8U8(kExprBr, ARITY_0, 1);
     current_function_builder_->Emit(kExprEnd);
     breakable_blocks_.pop_back();
   }
 
-  void VisitForStatement(ForStatement* stmt) override {
+  void VisitForStatement(ForStatement* stmt) {
     DCHECK_EQ(kFuncScope, scope_);
     if (stmt->init() != nullptr) {
       RECURSE(Visit(stmt->init()));
     }
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
     if (stmt->cond() != nullptr) {
       RECURSE(Visit(stmt->cond()));
       current_function_builder_->Emit(kExprI32Eqz);
       current_function_builder_->Emit(kExprIf);
       current_function_builder_->Emit(kExprNop);
       current_function_builder_->EmitWithU8U8(kExprBr, ARITY_0, 2);
       current_function_builder_->Emit(kExprEnd);
     }
     if (stmt->body() != nullptr) {
       RECURSE(Visit(stmt->body()));
     }
     if (stmt->next() != nullptr) {
       RECURSE(Visit(stmt->next()));
     }
     current_function_builder_->Emit(kExprNop);
     current_function_builder_->EmitWithU8U8(kExprBr, ARITY_0, 0);
   }
 
-  void VisitForInStatement(ForInStatement* stmt) override { UNREACHABLE(); }
+  void VisitForInStatement(ForInStatement* stmt) { UNREACHABLE(); }
 
-  void VisitForOfStatement(ForOfStatement* stmt) override { UNREACHABLE(); }
+  void VisitForOfStatement(ForOfStatement* stmt) { UNREACHABLE(); }
 
-  void VisitTryCatchStatement(TryCatchStatement* stmt) override {
-    UNREACHABLE();
-  }
+  void VisitTryCatchStatement(TryCatchStatement* stmt) { UNREACHABLE(); }
 
-  void VisitTryFinallyStatement(TryFinallyStatement* stmt) override {
-    UNREACHABLE();
-  }
+  void VisitTryFinallyStatement(TryFinallyStatement* stmt) { UNREACHABLE(); }
 
-  void VisitDebuggerStatement(DebuggerStatement* stmt) override {
-    UNREACHABLE();
-  }
+  void VisitDebuggerStatement(DebuggerStatement* stmt) { UNREACHABLE(); }
 
-  void VisitFunctionLiteral(FunctionLiteral* expr) override {
+  void VisitFunctionLiteral(FunctionLiteral* expr) {
     Scope* scope = expr->scope();
     if (scope_ == kFuncScope) {
       if (bounds_->get(expr).lower->IsFunction()) {
         // Build the signature for the function.
         FunctionType* func_type = bounds_->get(expr).lower->AsFunction();
         LocalType return_type = TypeFrom(func_type->Result());
         FunctionSig::Builder b(zone(), return_type == kAstStmt ? 0 : 1,
                                func_type->Arity());
         if (return_type != kAstStmt) b.AddReturn(return_type);
         for (int i = 0; i < expr->parameter_count(); ++i) {
           LocalType type = TypeFrom(func_type->Parameter(i));
           DCHECK_NE(kAstStmt, type);
           b.AddParam(type);
           InsertParameter(scope->parameter(i), type, i);
         }
         current_function_builder_->SetSignature(b.Build());
       } else {
         UNREACHABLE();
       }
     }
     RECURSE(VisitStatements(expr->body()));
     RECURSE(VisitDeclarations(scope->declarations()));
   }
 
-  void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) override {
+  void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
     UNREACHABLE();
   }
 
-  void VisitConditional(Conditional* expr) override {
+  void VisitConditional(Conditional* expr) {
     DCHECK_EQ(kFuncScope, scope_);
     RECURSE(Visit(expr->condition()));
     // WASM ifs come with implicit blocks for both arms.
     breakable_blocks_.push_back(std::make_pair(nullptr, false));
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(expr->then_expression()));
     current_function_builder_->Emit(kExprElse);
     RECURSE(Visit(expr->else_expression()));
     current_function_builder_->Emit(kExprEnd);
     breakable_blocks_.pop_back();
@@ skipping 44 matching lines @@
         value = M_SQRT2;
         break;
       }
       default: { return false; }
     }
     byte code[] = {WASM_F64(value)};
     current_function_builder_->EmitCode(code, sizeof(code));
     return true;
   }
 
-  void VisitVariableProxy(VariableProxy* expr) override {
+  void VisitVariableProxy(VariableProxy* expr) {
     if (scope_ == kFuncScope || scope_ == kInitScope) {
       Variable* var = expr->var();
       if (VisitStdlibConstant(var)) {
         return;
       }
       LocalType var_type = TypeOf(expr);
       DCHECK_NE(kAstStmt, var_type);
       if (var->IsContextSlot()) {
         current_function_builder_->EmitWithVarInt(
             kExprLoadGlobal, LookupOrInsertGlobal(var, var_type));
       } else {
         current_function_builder_->EmitGetLocal(
             LookupOrInsertLocal(var, var_type));
       }
     }
   }
 
-  void VisitLiteral(Literal* expr) override {
+  void VisitLiteral(Literal* expr) {
     Handle<Object> value = expr->value();
     if (!value->IsNumber() || (scope_ != kFuncScope && scope_ != kInitScope)) {
       return;
     }
     Type* type = bounds_->get(expr).upper;
     if (type->Is(cache_.kAsmSigned)) {
       int32_t i = 0;
       if (!value->ToInt32(&i)) {
         UNREACHABLE();
       }
       byte code[] = {WASM_I32V(i)};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else if (type->Is(cache_.kAsmUnsigned) || type->Is(cache_.kAsmFixnum)) {
       uint32_t u = 0;
       if (!value->ToUint32(&u)) {
         UNREACHABLE();
       }
       int32_t i = static_cast<int32_t>(u);
       byte code[] = {WASM_I32V(i)};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else if (type->Is(cache_.kAsmDouble)) {
       double val = expr->raw_value()->AsNumber();
       byte code[] = {WASM_F64(val)};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else {
       UNREACHABLE();
     }
   }
 
-  void VisitRegExpLiteral(RegExpLiteral* expr) override { UNREACHABLE(); }
+  void VisitRegExpLiteral(RegExpLiteral* expr) { UNREACHABLE(); }
 
-  void VisitObjectLiteral(ObjectLiteral* expr) override {
+  void VisitObjectLiteral(ObjectLiteral* expr) {
     ZoneList<ObjectLiteralProperty*>* props = expr->properties();
     for (int i = 0; i < props->length(); ++i) {
       ObjectLiteralProperty* prop = props->at(i);
       DCHECK_EQ(kExportScope, scope_);
       VariableProxy* expr = prop->value()->AsVariableProxy();
       DCHECK_NOT_NULL(expr);
       Variable* var = expr->var();
       Literal* name = prop->key()->AsLiteral();
       DCHECK_NOT_NULL(name);
       DCHECK(name->IsPropertyName());
       const AstRawString* raw_name = name->AsRawPropertyName();
       if (var->is_function()) {
         uint32_t index = LookupOrInsertFunction(var);
         builder_->FunctionAt(index)->SetExported();
         builder_->FunctionAt(index)->SetName(
             reinterpret_cast<const char*>(raw_name->raw_data()),
             raw_name->length());
       }
     }
   }
 
-  void VisitArrayLiteral(ArrayLiteral* expr) override { UNREACHABLE(); }
+  void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
 
   void LoadInitFunction() {
     current_function_builder_ = builder_->FunctionAt(init_function_index_);
     scope_ = kInitScope;
   }
 
   void UnLoadInitFunction() {
     scope_ = kModuleScope;
     current_function_builder_ = nullptr;
   }
@@ skipping 194 matching lines @@
         UNREACHABLE();
       }
       current_function_builder_->Emit(opcode);
     }
 
     if (target_var == nullptr && target_prop == nullptr) {
       UNREACHABLE();  // invalid assignment.
     }
   }
 
-  void VisitAssignment(Assignment* expr) override {
+  void VisitAssignment(Assignment* expr) {
     bool as_init = false;
     if (scope_ == kModuleScope) {
       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 (bounds_->get(target).lower->Is(Type::Function())) {
             const AstRawString* name =
@@ skipping 26 matching lines @@
     MachineType mtype;
     bool is_nop = false;
     EmitAssignmentLhs(expr->target(), &mtype);
     EmitAssignmentRhs(expr->target(), expr->value(), &is_nop);
     if (!is_nop) {
       EmitAssignment(expr, mtype);
     }
     if (as_init) UnLoadInitFunction();
   }
 
-  void VisitYield(Yield* expr) override { UNREACHABLE(); }
+  void VisitYield(Yield* expr) { UNREACHABLE(); }
 
-  void VisitThrow(Throw* expr) override { UNREACHABLE(); }
+  void VisitThrow(Throw* expr) { UNREACHABLE(); }
 
   void VisitForeignVariable(bool is_float, Variable* var, Property* expr) {
     DCHECK(expr->obj()->AsVariableProxy());
     DCHECK(VariableLocation::PARAMETER ==
            expr->obj()->AsVariableProxy()->var()->location());
     DCHECK_EQ(1, expr->obj()->AsVariableProxy()->var()->index());
     Literal* key_literal = expr->key()->AsLiteral();
     DCHECK_NOT_NULL(key_literal);
     if (!key_literal->value().is_null()) {
       Handle<Name> name =
@@ skipping 67 matching lines @@
       // Mask bottom bits to match asm.js behavior.
       byte mask = static_cast<byte>(~(size - 1));
       RECURSE(Visit(binop->left()));
       current_function_builder_->EmitWithU8(kExprI8Const, mask);
       current_function_builder_->Emit(kExprI32And);
       return;
     }
     UNREACHABLE();
   }
 
-  void VisitProperty(Property* expr) override {
+  void VisitProperty(Property* expr) {
     MachineType type;
     VisitPropertyAndEmitIndex(expr, &type);
     WasmOpcode opcode;
     if (type == MachineType::Int8()) {
       opcode = kExprI32AsmjsLoadMem8S;
     } else if (type == MachineType::Uint8()) {
       opcode = kExprI32AsmjsLoadMem8U;
     } else if (type == MachineType::Int16()) {
       opcode = kExprI32AsmjsLoadMem16S;
     } else if (type == MachineType::Uint16()) {
@@ skipping 267 matching lines @@
   }
 
   void VisitCallArgs(Call* expr) {
     ZoneList<Expression*>* args = expr->arguments();
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(Visit(arg));
     }
   }
 
-  void VisitCall(Call* expr) override {
+  void VisitCall(Call* expr) {
     Call::CallType call_type = expr->GetCallType(isolate_);
     switch (call_type) {
       case Call::OTHER_CALL: {
         DCHECK_EQ(kFuncScope, scope_);
         VariableProxy* proxy = expr->expression()->AsVariableProxy();
         if (proxy != nullptr) {
           if (VisitStdlibFunction(expr, proxy)) {
             return;
           }
         }
@@ skipping 40 matching lines @@
         current_function_builder_->Emit(kExprCallIndirect);
         current_function_builder_->EmitVarInt(expr->arguments()->length());
         current_function_builder_->EmitVarInt(indices->signature_index);
         break;
       }
       default:
         UNREACHABLE();
     }
   }
 
-  void VisitCallNew(CallNew* expr) override { UNREACHABLE(); }
+  void VisitCallNew(CallNew* expr) { UNREACHABLE(); }
 
-  void VisitCallRuntime(CallRuntime* expr) override { UNREACHABLE(); }
+  void VisitCallRuntime(CallRuntime* expr) { UNREACHABLE(); }
 
-  void VisitUnaryOperation(UnaryOperation* expr) override {
+  void VisitUnaryOperation(UnaryOperation* expr) {
     RECURSE(Visit(expr->expression()));
     switch (expr->op()) {
       case Token::NOT: {
         DCHECK_EQ(kAstI32, TypeOf(expr->expression()));
         current_function_builder_->Emit(kExprI32Eqz);
         break;
       }
       default:
         UNREACHABLE();
     }
   }
 
-  void VisitCountOperation(CountOperation* expr) override { UNREACHABLE(); }
+  void VisitCountOperation(CountOperation* expr) { UNREACHABLE(); }
 
   bool MatchIntBinaryOperation(BinaryOperation* expr, Token::Value op,
                                int32_t val) {
     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;
@@ skipping 116 matching lines @@
   }
 
   Expression* GetLeft(BinaryOperation* expr) {
     if (expr->op() == Token::BIT_XOR) {
       return expr->left()->AsBinaryOperation()->left();
     } else {
       return expr->left();
     }
   }
 
-  void VisitBinaryOperation(BinaryOperation* expr) override {
+  void VisitBinaryOperation(BinaryOperation* expr) {
     ConvertOperation convertOperation = MatchBinaryOperation(expr);
     if (convertOperation == kToDouble) {
       RECURSE(Visit(expr->left()));
       TypeIndex type = TypeIndexOf(expr->left());
       if (type == kInt32 || type == kFixnum) {
         current_function_builder_->Emit(kExprF64SConvertI32);
       } else if (type == kUint32) {
         current_function_builder_->Emit(kExprF64UConvertI32);
       } else if (type == kFloat32) {
         current_function_builder_->Emit(kExprF64ConvertF32);
@@ skipping 57 matching lines @@
         }
         case Token::COMMA: {
           break;
         }
         default:
           UNREACHABLE();
       }
     }
   }
 
-  void VisitCompareOperation(CompareOperation* expr) override {
+  void VisitCompareOperation(CompareOperation* expr) {
     RECURSE(Visit(expr->left()));
     RECURSE(Visit(expr->right()));
     switch (expr->op()) {
       BINOP_CASE(Token::EQ, Eq, NON_SIGNED_BINOP, false);
       BINOP_CASE(Token::LT, Lt, SIGNED_BINOP, false);
       BINOP_CASE(Token::LTE, Le, SIGNED_BINOP, false);
       BINOP_CASE(Token::GT, Gt, SIGNED_BINOP, false);
       BINOP_CASE(Token::GTE, Ge, SIGNED_BINOP, false);
       default:
         UNREACHABLE();
@@ skipping 50 matching lines @@
       UNREACHABLE();
       return kInt32;
     }
   }
 
 #undef CASE
 #undef NON_SIGNED_INT
 #undef SIGNED
 #undef NON_SIGNED
 
-  void VisitThisFunction(ThisFunction* expr) override { UNREACHABLE(); }
+  void VisitThisFunction(ThisFunction* expr) { UNREACHABLE(); }
 
-  void VisitDeclarations(ZoneList<Declaration*>* decls) override {
+  void VisitDeclarations(ZoneList<Declaration*>* decls) {
     for (int i = 0; i < decls->length(); ++i) {
       Declaration* decl = decls->at(i);
       RECURSE(Visit(decl));
     }
   }
 
-  void VisitClassLiteral(ClassLiteral* expr) override { UNREACHABLE(); }
+  void VisitClassLiteral(ClassLiteral* expr) { UNREACHABLE(); }
 
-  void VisitSpread(Spread* expr) override { UNREACHABLE(); }
+  void VisitSpread(Spread* expr) { UNREACHABLE(); }
 
-  void VisitSuperPropertyReference(SuperPropertyReference* expr) override {
+  void VisitSuperPropertyReference(SuperPropertyReference* expr) {
     UNREACHABLE();
   }
 
-  void VisitSuperCallReference(SuperCallReference* expr) override {
+  void VisitSuperCallReference(SuperCallReference* expr) { UNREACHABLE(); }
+
+  void VisitSloppyBlockFunctionStatement(SloppyBlockFunctionStatement* expr) {
     UNREACHABLE();
   }
 
-  void VisitSloppyBlockFunctionStatement(
-      SloppyBlockFunctionStatement* expr) override {
-    UNREACHABLE();
-  }
+  void VisitDoExpression(DoExpression* expr) { UNREACHABLE(); }
 
-  void VisitDoExpression(DoExpression* expr) override { UNREACHABLE(); }
-
-  void VisitRewritableExpression(RewritableExpression* expr) override {
-    UNREACHABLE();
-  }
+  void VisitRewritableExpression(RewritableExpression* expr) { UNREACHABLE(); }
 
   struct IndexContainer : public ZoneObject {
     uint32_t index;
   };
 
   uint32_t LookupOrInsertLocal(Variable* v, LocalType type) {
     DCHECK_NOT_NULL(current_function_builder_);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
     if (entry == nullptr) {
@@ skipping 106 matching lines @@
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, typer_);
   impl.Build();
   *foreign_args = impl.GetForeignArgs();
   ZoneBuffer* buffer = new (zone_) ZoneBuffer(zone_);
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8