[wasm] Add a BytecodeIterator and use in non-performance-critical situations.

src/wasm/ast-decoder.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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 1446 matching lines @@
 
 bool DecodeLocalDecls(AstLocalDecls& decls, const byte* start,
                       const byte* end) {
   base::AccountingAllocator allocator;
   Zone tmp(&allocator);
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   WasmFullDecoder decoder(&tmp, nullptr, body);
   return decoder.DecodeLocalDecls(decls);
 }
 
+BytecodeIterator::BytecodeIterator(const byte* start, const byte* end,
+                                   AstLocalDecls* decls)
+    : Decoder(start, end) {
+  if (decls != nullptr) {
+    if (DecodeLocalDecls(*decls, start, end)) {
+      pc_ += decls->decls_encoded_size;
+      if (pc_ > end_) pc_ = end_;
+    }
+  }
+}
+
 DecodeResult VerifyWasmCode(base::AccountingAllocator* allocator,
                             FunctionBody& body) {
   Zone zone(allocator);
   WasmFullDecoder decoder(&zone, nullptr, body);
   decoder.Decode();
   return decoder.toResult<DecodeStruct*>(nullptr);
 }
 
 DecodeResult BuildTFGraph(base::AccountingAllocator* allocator,
                           TFBuilder* builder, FunctionBody& body) {
@@ skipping 27 matching lines @@
   int line_nr = 0;
 
   // Print the function signature.
   if (body.sig) {
     os << "// signature: " << *body.sig << std::endl;
     ++line_nr;
   }
 
   // Print the local declarations.
   AstLocalDecls decls(&zone);
-  decoder.DecodeLocalDecls(decls);
-  const byte* pc = decoder.pc();
-  if (body.start != decoder.pc()) {
+  BytecodeIterator i(body.start, body.end, &decls);
+  if (body.start != i.pc()) {
     os << "// locals: ";
     for (auto p : decls.local_types) {
       LocalType type = p.first;
       uint32_t count = p.second;
       os << " " << count << " " << WasmOpcodes::TypeName(type);
     }
     os << std::endl;
     ++line_nr;
 
-    for (const byte* locals = body.start; locals < pc; locals++) {
+    for (const byte* locals = body.start; locals < i.pc(); locals++) {
       os << (locals == body.start ? "0x" : " 0x") << AsHex(*locals, 2) << ",";
     }
     os << std::endl;
     ++line_nr;
   }
 
   os << "// body: " << std::endl;
   ++line_nr;
   unsigned control_depth = 0;
-  while (pc < body.end) {
-    unsigned length = decoder.OpcodeLength(pc);
+  for (; i.has_next(); i.next()) {
+    unsigned length = decoder.OpcodeLength(i.pc());
 
-    WasmOpcode opcode = static_cast<WasmOpcode>(*pc);
+    WasmOpcode opcode = i.current();
     if (opcode == kExprElse) control_depth--;
 
     int num_whitespaces = control_depth < 32 ? 2 * control_depth : 64;
     if (offset_table) {
       offset_table->push_back(
-          std::make_tuple(pc - body.start, line_nr, num_whitespaces));
+          std::make_tuple(i.pc_offset(), line_nr, num_whitespaces));
     }
 
     // 64 whitespaces
     const char* padding =
         "                                                                ";
     os.write(padding, num_whitespaces);
     os << "k" << WasmOpcodes::OpcodeName(opcode) << ",";
 
-    for (size_t i = 1; i < length; ++i) {
-      os << " " << AsHex(pc[i], 2) << ",";
+    for (size_t j = 1; j < length; ++j) {
+      os << " " << AsHex(i.pc()[j], 2) << ",";
     }
 
     switch (opcode) {
       case kExprIf:
       case kExprElse:
       case kExprLoop:
       case kExprBlock:
-        os << "   // @" << static_cast<int>(pc - body.start);
+        os << "   // @" << i.pc_offset();
         control_depth++;
         break;
       case kExprEnd:
-        os << "   // @" << static_cast<int>(pc - body.start);
+        os << "   // @" << i.pc_offset();
         control_depth--;
         break;
       case kExprBr: {
-        BreakDepthOperand operand(&decoder, pc);
+        BreakDepthOperand operand(&i, i.pc());
         os << "   // arity=" << operand.arity << " depth=" << operand.depth;
         break;
       }
       case kExprBrIf: {
-        BreakDepthOperand operand(&decoder, pc);
+        BreakDepthOperand operand(&i, i.pc());
         os << "   // arity=" << operand.arity << " depth" << operand.depth;
         break;
       }
       case kExprBrTable: {
-        BranchTableOperand operand(&decoder, pc);
+        BranchTableOperand operand(&i, i.pc());
         os << "   // arity=" << operand.arity
            << " entries=" << operand.table_count;
         break;
       }
       case kExprCallIndirect: {
-        CallIndirectOperand operand(&decoder, pc);
-        if (decoder.Complete(pc, operand)) {
+        CallIndirectOperand operand(&i, i.pc());
+        if (decoder.Complete(i.pc(), operand)) {
           os << "   // sig #" << operand.index << ": " << *operand.sig;
         } else {
           os << " // arity=" << operand.arity << " sig #" << operand.index;
         }
         break;
       }
       case kExprCallImport: {
-        CallImportOperand operand(&decoder, pc);
-        if (decoder.Complete(pc, operand)) {
+        CallImportOperand operand(&i, i.pc());
+        if (decoder.Complete(i.pc(), operand)) {
           os << "   // import #" << operand.index << ": " << *operand.sig;
         } else {
           os << " // arity=" << operand.arity << " import #" << operand.index;
         }
         break;
       }
       case kExprCallFunction: {
-        CallFunctionOperand operand(&decoder, pc);
-        if (decoder.Complete(pc, operand)) {
+        CallFunctionOperand operand(&i, i.pc());
+        if (decoder.Complete(i.pc(), operand)) {
           os << "   // function #" << operand.index << ": " << *operand.sig;
         } else {
           os << " // arity=" << operand.arity << " function #" << operand.index;
         }
         break;
       }
       case kExprReturn: {
-        ReturnArityOperand operand(&decoder, pc);
+        ReturnArityOperand operand(&i, i.pc());
         os << "   // arity=" << operand.arity;
         break;
       }
       default:
         break;
       }
-
-    pc += length;
     os << std::endl;
     ++line_nr;
   }
 
   return decoder.ok();
 }
 
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, nullptr, start, end};
   WasmFullDecoder decoder(zone, nullptr, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8