[wasm] Provide better stack traces for asm.js code

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/flags.h"
 #include "src/macro-assembler.h"
@@ skipping 13 matching lines @@
   } while (false)
 #else
 #define TRACE(...)
 #endif
 
 namespace {
 
 const char* kNameString = "name";
 const size_t kNameStringLength = 4;
 
+const char* kAsmOffsetsString = "asm_offsets";
+const size_t kAsmOffsetsLength = 11;
+
 LocalType TypeOf(const WasmModule* module, const WasmInitExpr& expr) {
   switch (expr.kind) {
     case WasmInitExpr::kNone:
       return kAstStmt;
     case WasmInitExpr::kGlobalIndex:
       return expr.val.global_index < module->globals.size()
                  ? module->globals[expr.val.global_index].type
                  : kAstStmt;
     case WasmInitExpr::kI32Const:
       return kAstI32;
@@ skipping 26 matching lines @@
   }
 
   inline WasmSectionCode section_code() const { return section_code_; }
 
   inline const byte* section_start() const { return section_start_; }
 
   inline uint32_t section_length() const {
     return static_cast<uint32_t>(section_end_ - section_start_);
   }
 
+  inline const byte* payload_start() const { return payload_start_; }
+
+  inline uint32_t payload_length() const {
+    return static_cast<uint32_t>(section_end_ - payload_start_);
+  }
+
   inline const byte* section_end() const { return section_end_; }
 
   // Advances to the next section, checking that decoding the current section
   // stopped at {section_end_}.
   void advance() {
     if (decoder_.pc() != section_end_) {
       const char* msg = decoder_.pc() < section_end_ ? "shorter" : "longer";
       decoder_.error(decoder_.pc(), decoder_.pc(),
                      "section was %s than expected size "
                      "(%u bytes expected, %zu decoded)",
                      msg, section_length(),
                      static_cast<size_t>(decoder_.pc() - section_start_));
     }
     next();
   }
 
  private:
   Decoder& decoder_;
   WasmSectionCode section_code_;
   const byte* section_start_;
+  const byte* payload_start_;
   const byte* section_end_;
 
   // Reads the section code/name at the current position and sets up
   // the internal fields.
   void next() {
     while (true) {
       if (!decoder_.more()) {
         section_code_ = kUnknownSectionCode;
         return;
       }
       uint8_t section_code = decoder_.consume_u8("section code");
       // Read and check the section size.
       uint32_t section_length = decoder_.consume_u32v("section length");
       section_start_ = decoder_.pc();
+      payload_start_ = section_start_;
       if (decoder_.checkAvailable(section_length)) {
         // Get the limit of the section within the module.
         section_end_ = section_start_ + section_length;
       } else {
         // The section would extend beyond the end of the module.
         section_end_ = section_start_;
       }
 
       if (section_code == kUnknownSectionCode) {
-        // Check for the known "names" section.
+        // Check for the known "name" or "asm_offsets" section.
         uint32_t string_length = decoder_.consume_u32v("section name length");
         const byte* section_name_start = decoder_.pc();
         decoder_.consume_bytes(string_length, "section name");
         if (decoder_.failed() || decoder_.pc() > section_end_) {
           TRACE("Section name of length %u couldn't be read\n", string_length);
           section_code_ = kUnknownSectionCode;
           return;
         }
+        payload_start_ = decoder_.pc();
 
         TRACE("  +%d  section name        : \"%.*s\"\n",
               static_cast<int>(section_name_start - decoder_.start()),
               string_length < 20 ? string_length : 20, section_name_start);
 
         if (string_length == kNameStringLength &&
-            strncmp(reinterpret_cast<const char*>(section_name_start),
-                    kNameString, kNameStringLength) == 0) {
+            memcmp(reinterpret_cast<const char*>(section_name_start),
+                   kNameString, kNameStringLength) == 0) {
           section_code = kNameSectionCode;
+        } else if (string_length == kAsmOffsetsLength &&
+                   memcmp(reinterpret_cast<const char*>(section_name_start),
+                          kAsmOffsetsString, kAsmOffsetsLength) == 0) {
+          section_code = kAsmOffsetsSectionCode;
         } else {
           section_code = kUnknownSectionCode;
         }
       } else if (!IsValidSectionCode(section_code)) {
         decoder_.error(decoder_.pc(), decoder_.pc(),
                        "unknown section code #0x%02x", section_code);
         section_code = kUnknownSectionCode;
       }
       section_code_ = static_cast<WasmSectionCode>(section_code);
 
@@ skipping 432 matching lines @@
               functions_count, module->num_declared_functions);
       }
 
       for (uint32_t i = 0; ok() && i < functions_count; ++i) {
         WasmFunction* function =
             &module->functions[i + module->num_imported_functions];
         function->name_offset = consume_string(&function->name_length, false);
 
         uint32_t local_names_count = consume_u32v("local names count");
         for (uint32_t j = 0; ok() && j < local_names_count; j++) {
-          uint32_t unused = 0;
-          uint32_t offset = consume_string(&unused, false);
-          USE(unused);
-          USE(offset);
+          skip_string();
         }
       }
       section_iter.advance();
     }
 
+    // ===== Wasm to asm.js offset table =====================================
+    if (section_iter.section_code() == kAsmOffsetsSectionCode) {
+      const byte* pos = pc_;
+      uint32_t functions_count = consume_u32v("functions count");
+      if (functions_count != module->num_declared_functions) {
+        error(pos, pos, "function name count %u mismatch (%u expected)",
+              functions_count, module->num_declared_functions);
+      }
+
+      for (uint32_t i = 0; ok() && i < functions_count; ++i) {
+        // Do not store anything yet. Data will be decoded on-demand in
+        // WasmDebugInfo.
+        skip_string();
+      }
+      section_iter.advance();
+    }
+
     // ===== Remaining sections ==============================================
     if (section_iter.more() && ok()) {
       error(pc(), pc(), "unexpected section: %s",
             SectionName(section_iter.section_code()));
     }
 
     if (ok()) {
       CalculateGlobalOffsets(module);
       PreinitializeIndirectFunctionTables(module);
     }
@@ skipping 180 matching lines @@
     const byte* string_start = pc_;
     // Consume bytes before validation to guarantee that the string is not oob.
     if (*length > 0) consume_bytes(*length, "string");
     if (ok() && validate_utf8 &&
         !unibrow::Utf8::Validate(string_start, *length)) {
       error(string_start, "no valid UTF-8 string");
     }
     return offset;
   }
 
+  // Skips over a length-prefixed string, but checks that it is within bounds.
+  void skip_string() {
+    uint32_t length = consume_u32v("string length");
+    consume_bytes(length, "string");
+  }
+
   uint32_t consume_sig_index(WasmModule* module, FunctionSig** sig) {
     const byte* pos = pc_;
     uint32_t sig_index = consume_u32v("signature index");
     if (sig_index >= module->signatures.size()) {
       error(pos, pos, "signature index %u out of bounds (%d signatures)",
             sig_index, static_cast<int>(module->signatures.size()));
       *sig = nullptr;
       return 0;
     }
     *sig = module->signatures[sig_index];
@@ skipping 210 matching lines @@
   explicit FunctionError(const char* msg) {
     error_code = kError;
     size_t len = strlen(msg) + 1;
     char* result = new char[len];
     strncpy(result, msg, len);
     result[len - 1] = 0;
     error_msg.reset(result);
   }
 };
 
+// Find section with given section code. Return Vector of the payload, or null
+// Vector if section is not found or module bytes are invalid.
 Vector<const byte> FindSection(const byte* module_start, const byte* module_end,
                                WasmSectionCode code) {
   Decoder decoder(module_start, module_end);
 
   uint32_t magic_word = decoder.consume_u32("wasm magic");
   if (magic_word != kWasmMagic) decoder.error("wrong magic word");
 
   uint32_t magic_version = decoder.consume_u32("wasm version");
   if (magic_version != kWasmVersion) decoder.error("wrong wasm version");
 
   WasmSectionIterator section_iter(decoder);
   while (section_iter.more()) {
     if (section_iter.section_code() == code) {
-      return Vector<const uint8_t>(section_iter.section_start(),
-                                   section_iter.section_length());
+      return Vector<const uint8_t>(section_iter.payload_start(),
+                                   section_iter.payload_length());
     }
-    decoder.consume_bytes(section_iter.section_length(), "section payload");
+    decoder.consume_bytes(section_iter.payload_length(), "section payload");
     section_iter.advance();
   }
 
   return Vector<const uint8_t>();
 }
 
 }  // namespace
 
 ModuleResult DecodeWasmModule(Isolate* isolate, Zone* zone,
                               const byte* module_start, const byte* module_end,
@@ skipping 52 matching lines @@
   // Find and decode the code section.
   Vector<const byte> code_section =
       FindSection(module_start, module_end, kCodeSectionCode);
   Decoder decoder(code_section.start(), code_section.end());
   FunctionOffsets table;
   if (!code_section.start()) {
     decoder.error("no code section");
     return decoder.toResult(std::move(table));
   }
 
-  // Reserve entries for the imported functions.
-  table.reserve(num_imported_functions);
-  for (uint32_t i = 0; i < num_imported_functions; i++) {
-    table.push_back(std::make_pair(0, 0));
-  }
-
   uint32_t functions_count = decoder.consume_u32v("functions count");
-  // Take care of invalid input here.
+  // Reserve space for the entries, taking care of invalid input.
   if (functions_count < static_cast<unsigned>(code_section.length()) / 2)
     table.reserve(num_imported_functions + functions_count);
+
+  // Add null entries for the imported functions.
+  table.resize(num_imported_functions);
+
   int section_offset = static_cast<int>(code_section.start() - module_start);
   DCHECK_LE(0, section_offset);
   for (uint32_t i = 0; i < functions_count && decoder.ok(); ++i) {
     uint32_t size = decoder.consume_u32v("body size");
     int offset = static_cast<int>(section_offset + decoder.pc_offset());
     table.push_back(std::make_pair(offset, static_cast<int>(size)));
     DCHECK(table.back().first >= 0 && table.back().second >= 0);
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
+AsmJsOffsetsResult DecodeAsmJsOffsets(const byte* module_start,
+                                      const byte* module_end,
+                                      uint32_t num_imported_functions) {
+  // Find and decode the code section.
+  Vector<const byte> asm_offset_section =
+      FindSection(module_start, module_end, kAsmOffsetsSectionCode);
+  Decoder decoder(asm_offset_section.start(), asm_offset_section.end());
+  AsmJsOffsets table;
+  if (!asm_offset_section.start()) {
+    decoder.error("no asm.js offsets section");
+    return decoder.toResult(std::move(table));
+  }
+
+  uint32_t functions_count = decoder.consume_u32v("functions count");
+  // Reserve space for the entries, taking care of invalid input.
+  if (functions_count < static_cast<unsigned>(asm_offset_section.length()))
+    table.reserve(num_imported_functions + functions_count);
+
+  // Add null entries for the imported functions.
+  table.resize(num_imported_functions);
+
+  for (uint32_t i = 0; i < functions_count && decoder.ok(); ++i) {
+    uint32_t size = decoder.consume_u32v("table size");
+    if (size == 0) {
+      table.push_back(std::vector<std::pair<int, int>>());
+      continue;
+    }
+    if (!decoder.checkAvailable(size)) {
+      decoder.error("illegal asm function offset table size");
+    }
+    const byte* table_end = decoder.pc() + size;
+    uint32_t locals_size = decoder.consume_u32("locals size");
+    int last_byte_offset = locals_size;
+    int last_asm_position = 0;
+    std::vector<std::pair<int, int>> func_asm_offsets;
+    func_asm_offsets.reserve(size / 4);  // conservative estimation
+    while (decoder.ok() && decoder.pc() < table_end) {
+      last_byte_offset += decoder.consume_u32v("byte offset delta");
+      last_asm_position += decoder.consume_i32v("asm position delta");
+      func_asm_offsets.push_back({last_byte_offset, last_asm_position});
+    }
+    if (decoder.pc() != table_end) {
+      decoder.error("broken asm offset table");
+    }
+    table.push_back(std::move(func_asm_offsets));
+  }
+  if (decoder.more()) decoder.error("unexpected additional bytes");
+
+  return decoder.toResult(std::move(table));
+}
+
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8