Replace __init__ function in asm-wasm-builder with the start function section

src/wasm/encoder.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-containers.h"
 
@@ skipping 315 matching lines @@
   uint32_t body_offset = static_cast<uint32_t>(*body - buffer);
   EmitUint32(header, dest_);
   EmitUint32(header, body_offset);
   EmitUint32(header, static_cast<uint32_t>(data_.size()));
   EmitUint8(header, 1);  // init
 
   std::memcpy(*body, &data_[0], data_.size());
   (*body) += data_.size();
 }
 
-
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
-      signature_map_(zone) {}
-
+      signature_map_(zone),
+      start_function_index_(-1) {}
 
 uint16_t WasmModuleBuilder::AddFunction() {
   functions_.push_back(new (zone_) WasmFunctionBuilder(zone_));
   return static_cast<uint16_t>(functions_.size() - 1);
 }
 
 
 WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
   if (functions_.size() > index) {
     return functions_.at(index);
@@ skipping 36 matching lines @@
     signatures_.push_back(sig);
     return index;
   }
 }
 
 
 void WasmModuleBuilder::AddIndirectFunction(uint16_t index) {
   indirect_functions_.push_back(index);
 }
 
+void WasmModuleBuilder::MarkStartFunction(uint16_t index) {
+  start_function_index_ = index;
+}
 
 WasmModuleWriter* WasmModuleBuilder::Build(Zone* zone) {
   WasmModuleWriter* writer = new (zone) WasmModuleWriter(zone);
   for (auto function : functions_) {
     writer->functions_.push_back(function->Build(zone, this));
   }
   for (auto segment : data_segments_) {
     writer->data_segments_.push_back(segment);
   }
   for (auto sig : signatures_) {
     writer->signatures_.push_back(sig);
   }
   for (auto index : indirect_functions_) {
     writer->indirect_functions_.push_back(index);
   }
   for (auto global : globals_) {
     writer->globals_.push_back(global);
   }
+  writer->start_function_index_ = start_function_index_;
   return writer;
 }
 
 
 uint32_t WasmModuleBuilder::AddGlobal(MachineType type, bool exported) {
   globals_.push_back(std::make_pair(type, exported));
   return static_cast<uint32_t>(globals_.size() - 1);
 }
 
 
 WasmModuleWriter::WasmModuleWriter(Zone* zone)
     : functions_(zone),
       data_segments_(zone),
       signatures_(zone),
       indirect_functions_(zone),
       globals_(zone) {}
 
+size_t SizeOfVarInt(size_t value) {
+  size_t size = 0;
+  do {
+    size++;
+    value = value >> 7;
+  } while (value > 0);
+  return size;
+}
 
 struct Sizes {
   size_t header_size;
   size_t body_size;
 
   size_t total() { return header_size + body_size; }
 
   void Add(size_t header, size_t body) {
     header_size += header;
     body_size += body;
   }
 
   void AddSection(size_t size) {
     if (size > 0) {
       Add(1, 0);
-      while (size > 0) {
-        Add(1, 0);
-        size = size >> 7;
-      }
+      Add(SizeOfVarInt(size), 0);
     }
   }
 };
 
 
 WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
   Sizes sizes = {0, 0};
 
   sizes.Add(2 * sizeof(uint32_t), 0);  // header
 
   sizes.Add(1, 0);
   sizes.Add(kDeclMemorySize, 0);
 
   sizes.AddSection(signatures_.size());
   for (auto sig : signatures_) {
     sizes.Add(2 + sig->parameter_count(), 0);
   }
 
   sizes.AddSection(globals_.size());
   if (globals_.size() > 0) {
     sizes.Add(kDeclGlobalSize * globals_.size(), 0);
   }
 
   sizes.AddSection(functions_.size());
   for (auto function : functions_) {
     sizes.Add(function->HeaderSize() + function->BodySize(),
               function->NameSize());
   }
 
+  if (start_function_index_ >= 0) {
+    sizes.Add(1, 0);
+    sizes.Add(SizeOfVarInt(start_function_index_), 0);
+  }
+
   sizes.AddSection(data_segments_.size());
   for (auto segment : data_segments_) {
     sizes.Add(segment->HeaderSize(), segment->BodySize());
   }
 
   sizes.AddSection(indirect_functions_.size());
   sizes.Add(2 * static_cast<uint32_t>(indirect_functions_.size()), 0);
 
   if (sizes.body_size > 0) sizes.Add(1, 0);
 
@@ skipping 45 matching lines @@
   // -- emit functions ---------------------------------------------------------
   if (functions_.size() > 0) {
     EmitUint8(&header, kDeclFunctions);
     EmitVarInt(&header, functions_.size());
 
     for (auto func : functions_) {
       func->Serialize(buffer, &header, &body);
     }
   }
 
+  // -- emit start function index ----------------------------------------------
+  if (start_function_index_ >= 0) {
+    EmitUint8(&header, kDeclStartFunction);
+    EmitVarInt(&header, start_function_index_);
+  }
+
   // -- emit data segments -----------------------------------------------------
   if (data_segments_.size() > 0) {
     EmitUint8(&header, kDeclDataSegments);
     EmitVarInt(&header, data_segments_.size());
 
     for (auto segment : data_segments_) {
       segment->Serialize(buffer, &header, &body);
     }
   }
 
@@ skipping 23 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8