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),
+      has_start_function_(false),
+      start_function_index_(0) {}
 
 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) {
+  has_start_function_ = true;
+  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->has_start_function_ = has_start_function_;
+  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);
 }
 
 
@@ skipping 45 matching lines @@
   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 (has_start_function_) {
+    sizes.Add(1, 0);
+    uint16_t size = start_function_index_;
+    do {

[titzer, 2016/03/01 02:09:33]

Let's lift out this varint encoding into a helper and use it elsewhere (we
currently create temporary std::vectors for LEB encodings!)

[aseemgarg, 2016/03/01 02:37:34]

This is enclosed in AddSection for other. Just for this one since the section
might be created even with a 0 value is it separate. This is smaller than adding
a flag to the existing method.

[titzer, 2016/03/01 02:43:58]

At least lift it out to a helper that computes the size of the varint for
documentation.

[aseemgarg, 2016/03/01 03:00:24]

Done.

+      sizes.Add(1, 0);
+      size = size >> 7;
+    } while (size > 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 (has_start_function_) {
+    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