[wasm][asm.js] Asm.js -> wasm custom parser.

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/objects-inl.h"
 #include "src/v8.h"
 #include "src/zone/zone-containers.h"
@@ skipping 167 matching lines @@
 
 void WasmFunctionBuilder::SetAsmFunctionStartPosition(int position) {
   DCHECK_EQ(0, asm_func_start_source_position_);
   DCHECK_LE(0, position);
   // Must be called before emitting any asm.js source position.
   DCHECK_EQ(0, asm_offsets_.size());
   asm_func_start_source_position_ = position;
   last_asm_source_position_ = position;
 }
 
+void WasmFunctionBuilder::StashCode(std::vector<byte>* dst, size_t position) {
+  if (dst == nullptr) {
+    body_.resize(position);
+    return;
+  }
+  size_t len = body_.size() - position;
+  dst->resize(len);
+  memcpy(dst->data(), &body_[position], len);
+  body_.resize(position);
+}
+
 void WasmFunctionBuilder::WriteSignature(ZoneBuffer& buffer) const {
   buffer.write_u32v(signature_index_);
 }
 
 void WasmFunctionBuilder::WriteExports(ZoneBuffer& buffer) const {
   for (auto name : exported_names_) {
     buffer.write_size(name.size());
     buffer.write(reinterpret_cast<const byte*>(name.data()), name.size());
     buffer.write_u8(kExternalFunction);
-    buffer.write_u32v(func_index_ +
-                      static_cast<uint32_t>(builder_->imports_.size()));
+    buffer.write_u32v(func_index_ + static_cast<uint32_t>(
+                                        builder_->function_imports_.size()));
   }
 }
 
 void WasmFunctionBuilder::WriteBody(ZoneBuffer& buffer) const {
   size_t locals_size = locals_.Size();
   buffer.write_size(locals_size + body_.size());
   buffer.EnsureSpace(locals_size);
   byte** ptr = buffer.pos_ptr();
   locals_.Emit(*ptr);
   (*ptr) += locals_size;  // UGLY: manual bump of position pointer
   if (body_.size() > 0) {
     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()));
+          call.direct_index +
+              static_cast<uint32_t>(builder_->function_imports_.size()));
     }
   }
 }
 
 void WasmFunctionBuilder::WriteAsmWasmOffsetTable(ZoneBuffer& buffer) const {
   if (asm_func_start_source_position_ == 0 && asm_offsets_.size() == 0) {
     buffer.write_size(0);
     return;
   }
   size_t locals_enc_size = LEBHelper::sizeof_u32v(locals_.Size());
   size_t func_start_size =
       LEBHelper::sizeof_u32v(asm_func_start_source_position_);
   buffer.write_size(asm_offsets_.size() + locals_enc_size + func_start_size);
   // Offset of the recorded byte offsets.
   DCHECK_GE(kMaxUInt32, locals_.Size());
   buffer.write_u32v(static_cast<uint32_t>(locals_.Size()));
   // Start position of the function.
   buffer.write_u32v(asm_func_start_source_position_);
   buffer.write(asm_offsets_.begin(), asm_offsets_.size());
 }
 
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
-      imports_(zone),
+      function_imports_(zone),
+      global_imports_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
       signature_map_(zone),
       start_function_index_(-1) {}
 
 WasmFunctionBuilder* WasmModuleBuilder::AddFunction(FunctionSig* sig) {
   functions_.push_back(new (zone_) WasmFunctionBuilder(this));
   // Add the signature if one was provided here.
@@ skipping 45 matching lines @@
   return ret;
 }
 
 void WasmModuleBuilder::SetIndirectFunction(uint32_t indirect,
                                             uint32_t direct) {
   indirect_functions_[indirect] = direct;
 }
 
 uint32_t WasmModuleBuilder::AddImport(const char* name, int name_length,
                                       FunctionSig* sig) {
-  imports_.push_back({AddSignature(sig), name, name_length});
-  return static_cast<uint32_t>(imports_.size() - 1);
+  function_imports_.push_back({AddSignature(sig), name, name_length});
+  return static_cast<uint32_t>(function_imports_.size() - 1);
+}
+
+uint32_t WasmModuleBuilder::AddGlobalImport(const char* name, int name_length,
+                                            ValueType type) {
+  global_imports_.push_back(
+      {WasmOpcodes::ValueTypeCodeFor(type), name, name_length});
+  return static_cast<uint32_t>(global_imports_.size() - 1);
 }
 
 void WasmModuleBuilder::MarkStartFunction(WasmFunctionBuilder* function) {
   start_function_index_ = function->func_index();
 }
 
 uint32_t WasmModuleBuilder::AddGlobal(ValueType type, bool exported,
                                       bool mutability,
                                       const WasmInitExpr& init) {
   globals_.push_back({type, exported, mutability, init});
@@ skipping 21 matching lines @@
       }
       buffer.write_size(sig->return_count());
       for (auto ret : sig->returns()) {
         buffer.write_u8(WasmOpcodes::ValueTypeCodeFor(ret));
       }
     }
     FixupSection(buffer, start);
   }
 
   // == Emit imports ===========================================================
-  if (imports_.size() > 0) {
+  if (global_imports_.size() + function_imports_.size() > 0) {
     size_t start = EmitSection(kImportSectionCode, buffer);
-    buffer.write_size(imports_.size());
-    for (auto import : imports_) {
+    buffer.write_size(global_imports_.size() + function_imports_.size());
+    for (auto import : global_imports_) {
       buffer.write_u32v(0);                   // module name length
       buffer.write_u32v(import.name_length);  // field name length
       buffer.write(reinterpret_cast<const byte*>(import.name),  // field name
+                   import.name_length);
+      buffer.write_u8(kExternalGlobal);
+      buffer.write_u8(import.type_code);
+      buffer.write_u8(0);  // immutable
+    }
+    for (auto import : function_imports_) {
+      buffer.write_u32v(0);                   // module name length
+      buffer.write_u32v(import.name_length);  // field name length
+      buffer.write(reinterpret_cast<const byte*>(import.name),  // field name
                    import.name_length);
       buffer.write_u8(kExternalFunction);
       buffer.write_u32v(import.sig_index);
     }
     FixupSection(buffer, start);
   }
 
   // == Emit function signatures ===============================================
   bool has_names = false;
   if (functions_.size() > 0) {
@@ skipping 105 matching lines @@
     size_t start = EmitSection(kExportSectionCode, buffer);
     buffer.write_u32v(exports);
     for (auto function : functions_) function->WriteExports(buffer);
     FixupSection(buffer, start);
   }
 
   // == emit start function index ==============================================
   if (start_function_index_ >= 0) {
     size_t start = EmitSection(kStartSectionCode, buffer);
     buffer.write_u32v(start_function_index_ +
-                      static_cast<uint32_t>(imports_.size()));
+                      static_cast<uint32_t>(function_imports_.size()));
     FixupSection(buffer, start);
   }
 
   // == emit function table elements ===========================================
   if (indirect_functions_.size() > 0) {
     size_t start = EmitSection(kElementSectionCode, buffer);
     buffer.write_u8(1);              // count of entries
     buffer.write_u8(0);              // table index
     buffer.write_u8(kExprI32Const);  // offset
     buffer.write_u32v(0);
     buffer.write_u8(kExprEnd);
     buffer.write_size(indirect_functions_.size());  // element count
 
     for (auto index : indirect_functions_) {
-      buffer.write_u32v(index + static_cast<uint32_t>(imports_.size()));
+      buffer.write_u32v(index +
+                        static_cast<uint32_t>(function_imports_.size()));
     }
 
     FixupSection(buffer, start);
   }
 
   // == emit code ==============================================================
   if (functions_.size() > 0) {
     size_t start = EmitSection(kCodeSectionCode, buffer);
     buffer.write_size(functions_.size());
     for (auto function : functions_) {
@@ skipping 21 matching lines @@
   // == Emit names =============================================================
   if (has_names) {
     // Emit the section code.
     buffer.write_u8(kUnknownSectionCode);
     // Emit a placeholder for the length.
     size_t start = buffer.reserve_u32v();
     // Emit the section string.
     buffer.write_size(4);
     buffer.write(reinterpret_cast<const byte*>("name"), 4);
     // Emit the names.
-    size_t count = functions_.size() + imports_.size();
+    size_t count = functions_.size() + function_imports_.size();
     buffer.write_size(count);
-    for (size_t i = 0; i < imports_.size(); i++) {
+    for (size_t i = 0; i < function_imports_.size(); i++) {
       buffer.write_u8(0);  // empty name for import
       buffer.write_u8(0);  // no local variables
     }
     for (auto function : functions_) {
       buffer.write_size(function->name_.size());
       buffer.write(reinterpret_cast<const byte*>(function->name_.data()),
                    function->name_.size());
       buffer.write_u8(0);
     }
     FixupSection(buffer, start);
   }
 }
 
 void WasmModuleBuilder::WriteAsmJsOffsetTable(ZoneBuffer& buffer) const {
   // == Emit asm.js offset table ===============================================
   buffer.write_size(functions_.size());
   // Emit the offset table per function.
   for (auto function : functions_) {
     function->WriteAsmWasmOffsetTable(buffer);
   }
   // Append a 0 to indicate that this is an encoded table.
   buffer.write_u8(0);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8