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

src/wasm/wasm-module-builder.h

 // 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.
 
 #ifndef V8_WASM_WASM_MODULE_BUILDER_H_
 #define V8_WASM_WASM_MODULE_BUILDER_H_
 
 #include "src/signature.h"
 #include "src/zone/zone-containers.h"
 
@@ skipping 70 matching lines @@
       byte out = static_cast<byte>(val & 0x7f);
       if (pos != kPaddedVarInt32Size - 1) {
         *(ptr++) = 0x80 | out;
         val = next;
       } else {
         *(ptr++) = out;
       }
     }
   }
 
-  size_t offset() { return static_cast<size_t>(pos_ - buffer_); }
-  size_t size() { return static_cast<size_t>(pos_ - buffer_); }
-  const byte* begin() { return buffer_; }
-  const byte* end() { return pos_; }
+  size_t offset() const { return static_cast<size_t>(pos_ - buffer_); }
+  size_t size() const { return static_cast<size_t>(pos_ - buffer_); }
+  const byte* begin() const { return buffer_; }
+  const byte* end() const { return pos_; }
 
   void EnsureSpace(size_t size) {
     if ((pos_ + size) > end_) {
       size_t new_size = 4096 + size + (end_ - buffer_) * 3;
       byte* new_buffer = reinterpret_cast<byte*>(zone_->New(new_size));
       memcpy(new_buffer, buffer_, (pos_ - buffer_));
       pos_ = new_buffer + (pos_ - buffer_);
       buffer_ = new_buffer;
       end_ = new_buffer + new_size;
     }
@@ skipping 23 matching lines @@
   void EmitSetLocal(uint32_t index);
   void EmitTeeLocal(uint32_t index);
   void EmitI32Const(int32_t val);
   void EmitWithU8(WasmOpcode opcode, const byte immediate);
   void EmitWithU8U8(WasmOpcode opcode, const byte imm1, const byte imm2);
   void EmitWithVarInt(WasmOpcode opcode, uint32_t immediate);
   void EmitDirectCallIndex(uint32_t index);
   void Export();
   void ExportAs(Vector<const char> name);
   void SetName(Vector<const char> name);
+  void AddAsmWasmOffset(int asm_position);
 
   void WriteSignature(ZoneBuffer& buffer) const;
   void WriteExport(ZoneBuffer& buffer) const;
   void WriteBody(ZoneBuffer& buffer) const;
+  void WriteAsmWasmOffsetTable(ZoneBuffer& buffer) const;
 
   bool exported() { return exported_; }
   uint32_t func_index() { return func_index_; }
   FunctionSig* signature();
 
  private:
   explicit WasmFunctionBuilder(WasmModuleBuilder* builder);
   friend class WasmModuleBuilder;
   friend class WasmTemporary;
 
   struct DirectCallIndex {
     size_t offset;
     uint32_t direct_index;
   };
 
   WasmModuleBuilder* builder_;
   LocalDeclEncoder locals_;
   uint32_t signature_index_;
   bool exported_;
   uint32_t func_index_;
   ZoneVector<uint8_t> body_;
   ZoneVector<char> name_;
   ZoneVector<char> exported_name_;
   ZoneVector<uint32_t> i32_temps_;
   ZoneVector<uint32_t> i64_temps_;
   ZoneVector<uint32_t> f32_temps_;
   ZoneVector<uint32_t> f64_temps_;
   ZoneVector<DirectCallIndex> direct_calls_;
+
+  // Delta-encoded mapping from wasm bytes to asm.js source positions.
+  ZoneBuffer asm_offsets_;
+  uint32_t last_asm_byte_offset_ = 0;
+  uint32_t last_asm_source_position_ = 0;
 };
 
 class WasmTemporary {
  public:
   WasmTemporary(WasmFunctionBuilder* builder, LocalType type) {
     switch (type) {
       case kAstI32:
         temporary_ = &builder->i32_temps_;
         break;
       case kAstI64:
@@ skipping 41 matching lines @@
   WasmFunctionBuilder* AddFunction(FunctionSig* sig = nullptr);
   uint32_t AddGlobal(LocalType type, bool exported, bool mutability = true,
                      const WasmInitExpr& init = WasmInitExpr());
   void AddDataSegment(const byte* data, uint32_t size, uint32_t dest);
   uint32_t AddSignature(FunctionSig* sig);
   void AddIndirectFunction(uint32_t index);
   void MarkStartFunction(WasmFunctionBuilder* builder);
 
   // Writing methods.
   void WriteTo(ZoneBuffer& buffer) const;
+  void WriteAsmJsOffsetTable(ZoneBuffer& buffer) const;
 
   // TODO(titzer): use SignatureMap from signature-map.h here.
   // This signature map is zone-allocated, but the other is heap allocated.
   struct CompareFunctionSigs {
     bool operator()(FunctionSig* a, FunctionSig* b) const;
   };
   typedef ZoneMap<FunctionSig*, uint32_t, CompareFunctionSigs> SignatureMap;
 
   Zone* zone() { return zone_; }
 
@@ skipping 32 matching lines @@
 
 inline FunctionSig* WasmFunctionBuilder::signature() {
   return builder_->signatures_[signature_index_];
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_WASM_MODULE_BUILDER_H_