[wasm] Support undefined indirect table entries, behind a flag.

src/wasm/module-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/wasm/module-decoder.h"
 
 #include "src/base/functional.h"
 #include "src/base/platform/platform.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
@@ skipping 252 matching lines @@
                   static_cast<int>(pc_ - start_));
             module->data_segments.push_back({0,        // dest_addr
                                              0,        // source_offset
                                              0,        // source_size
                                              false});  // init
             WasmDataSegment* segment = &module->data_segments.back();
             DecodeDataSegmentInModule(module, segment);
           }
           break;
         }
+        case WasmSection::Code::FunctionTablePad: {
+          if (!FLAG_wasm_jit_prototype) {
+            error("FunctionTablePad section without jiting enabled");
+          }
+          // An indirect function table requires functions first.
+          int length;
+          module->indirect_table_size =
+              consume_u32v(&length, "indirect entry count");
+          if (module->indirect_table_size > 0 &&
+              module->indirect_table_size < module->function_table.size()) {
+            error("more predefined indirect entries than table can hold");
+          }
+          break;
+        }
         case WasmSection::Code::FunctionTable: {
           // An indirect function table requires functions first.
           CheckForFunctions(module, section);
           int length;
           uint32_t function_table_count =
               consume_u32v(&length, "function table count");
           module->function_table.reserve(SafeReserve(function_table_count));
           // Decode function table.
           for (uint32_t i = 0; i < function_table_count; i++) {
             if (failed()) break;
             TRACE("DecodeFunctionTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
             uint16_t index = consume_u32v(&length);
             if (index >= module->functions.size()) {
               error(pc_ - 2, "invalid function index");
               break;
             }
             module->function_table.push_back(index);
           }
+          if (module->indirect_table_size > 0 &&
+              module->indirect_table_size < module->function_table.size()) {
+            error("more predefined indirect entries than table can hold");
+          }
           break;
         }
         case WasmSection::Code::StartFunction: {
           // Declares a start function for a module.
           CheckForFunctions(module, section);
           if (module->start_function_index >= 0) {
             error("start function already declared");
             break;
           }
           WasmFunction* func;
@@ skipping 82 matching lines @@
                       it->name_length, pc, last->func_index, it->func_index);
                 break;
               }
             }
           }
           break;
         }
         case WasmSection::Code::Max:
           // Skip unknown sections.
           TRACE("Unknown section: '");
-          for (uint32_t i = 0; i != string_length; ++i) {
+          for (uint32_t i = 0; i != string_length; i++) {
             TRACE("%c", *(section_name_start + i));
           }
           TRACE("'\n");
           consume_bytes(section_length);
           break;
       }
 
       if (pc_ != expected_section_end) {
         const char* diff = pc_ < expected_section_end ? "shorter" : "longer";
         size_t expected_length = static_cast<size_t>(section_length);
@@ skipping 448 matching lines @@
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8