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

src/wasm/wasm-module-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/signature.h"
 
 #include "src/handles.h"
 #include "src/v8.h"
 #include "src/zone/zone-containers.h"
 
@@ skipping 41 matching lines @@
       signature_index_(0),
       exported_(0),
       func_index_(static_cast<uint32_t>(builder->functions_.size())),
       body_(builder->zone()),
       name_(builder->zone()),
       exported_name_(builder->zone()),
       i32_temps_(builder->zone()),
       i64_temps_(builder->zone()),
       f32_temps_(builder->zone()),
       f64_temps_(builder->zone()),
-      direct_calls_(builder->zone()) {}
+      direct_calls_(builder->zone()),
+      asm_offsets_(builder->zone(), 8) {}
 
 void WasmFunctionBuilder::EmitVarInt(uint32_t val) {
   byte buffer[8];
   byte* ptr = buffer;
   LEBHelper::write_u32v(&ptr, val);
   for (byte* p = buffer; p < ptr; p++) {
     body_.push_back(*p);
   }
 }
 
@@ skipping 73 matching lines @@
   exported_ = true;
   exported_name_.resize(name.length());
   memcpy(exported_name_.data(), name.start(), name.length());
 }
 
 void WasmFunctionBuilder::SetName(Vector<const char> name) {
   name_.resize(name.length());
   memcpy(name_.data(), name.start(), name.length());
 }
 
+void WasmFunctionBuilder::AddAsmWasmOffset(int asm_position) {
+  // We only want to emit one mapping per byte offset:
+  DCHECK(asm_offsets_.size() == 0 || body_.size() > last_asm_byte_offset_);
+
+  DCHECK_LE(body_.size(), kMaxUInt32);
+  uint32_t byte_offset = static_cast<uint32_t>(body_.size());
+  asm_offsets_.write_u32v(byte_offset - last_asm_byte_offset_);
+  last_asm_byte_offset_ = byte_offset;
+
+  DCHECK_GE(asm_position, 0);
+  asm_offsets_.write_i32v(asm_position - last_asm_source_position_);
+  last_asm_source_position_ = asm_position;
+}
+
 void WasmFunctionBuilder::WriteSignature(ZoneBuffer& buffer) const {
   buffer.write_u32v(signature_index_);
 }
 
 void WasmFunctionBuilder::WriteExport(ZoneBuffer& buffer) const {
   if (exported_) {
     const ZoneVector<char>* exported_name =
         exported_name_.size() == 0 ? &name_ : &exported_name_;
     buffer.write_size(exported_name->size());
     buffer.write(reinterpret_cast<const byte*>(exported_name->data()),
@@ skipping 15 matching lines @@
     size_t base = buffer.offset();
     buffer.write(&body_[0], body_.size());
     for (DirectCallIndex call : direct_calls_) {
       buffer.patch_u32v(
           base + call.offset,
           call.direct_index + static_cast<uint32_t>(builder_->imports_.size()));
     }
   }
 }
 
+void WasmFunctionBuilder::WriteAsmWasmOffsetTable(ZoneBuffer& buffer) const {
+  if (asm_offsets_.size() == 0) {
+    buffer.write_size(0);
+    return;
+  }
+  buffer.write_size(asm_offsets_.size() + kInt32Size);
+  // Offset of the recorded byte offsets.
+  DCHECK_GE(kMaxUInt32, locals_.Size());
+  buffer.write_u32(static_cast<uint32_t>(locals_.Size()));
+  buffer.write(asm_offsets_.begin(), asm_offsets_.size());
+}
+
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
       imports_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
       signature_map_(zone),
       start_function_index_(-1) {}
@@ skipping 101 matching lines @@
                    import.name_length);
       buffer.write_u32v(0);  // field name length
       buffer.write_u8(kExternalFunction);
       buffer.write_u32v(import.sig_index);
     }
     FixupSection(buffer, start);
   }
 
   // == Emit function signatures ===============================================
   bool has_names = false;
+  bool has_asm_offsets = false;
   if (functions_.size() > 0) {
     size_t start = EmitSection(kFunctionSectionCode, buffer);
     buffer.write_size(functions_.size());
     for (auto function : functions_) {
       function->WriteSignature(buffer);
       if (function->exported()) exports++;
       if (function->name_.size() > 0) has_names = true;
+      if (function->asm_offsets_.size() > 0) has_asm_offsets = true;
     }
     FixupSection(buffer, start);
   }
 
   // == emit function table ====================================================
   if (indirect_functions_.size() > 0) {
     size_t start = EmitSection(kTableSectionCode, buffer);
     buffer.write_u8(1);  // table count
     buffer.write_u8(kWasmAnyFunctionTypeForm);
     buffer.write_u8(kResizableMaximumFlag);
@@ skipping 157 matching lines @@
     for (auto function : functions_) {
       buffer.write_size(function->name_.size());
       if (function->name_.size() > 0) {
         buffer.write(reinterpret_cast<const byte*>(&function->name_[0]),
                      function->name_.size());
       }
       buffer.write_u8(0);
     }
     FixupSection(buffer, start);
   }
+
+  // == Emit asm.js offset table ===============================================
+  if (has_asm_offsets) {
+    // Emit the section code.
+    buffer.write_u8(kUnknownSectionCode);
+    // Emit a placeholder for the length.
+    size_t start = buffer.reserve_u32v();
+    // Emit the section string.
+    const char* asm_offsets_name = "asm_offsets";
+    buffer.write_size(strlen(asm_offsets_name));
+    buffer.write(reinterpret_cast<const byte*>(asm_offsets_name),
+                 strlen(asm_offsets_name));
+    buffer.write_size(functions_.size());
+    // Emit the offset table per function.
+    for (auto function : functions_) {
+      function->WriteAsmWasmOffsetTable(buffer);
+    }
+    FixupSection(buffer, start);
+  }
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8