Add __init__ function to all modules created in asm-to-wasm

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 45 matching lines @@
 }
 }  // namespace
 
 
 struct WasmFunctionBuilder::Type {
   bool param_;
   LocalType type_;
 };
 
 
-WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone, const unsigned char* name,
-                                         int name_length)
+WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone)
     : return_type_(kAstI32),
       locals_(zone),
       exported_(0),
       external_(0),
       body_(zone),
       local_indices_(zone),
-      name_(zone) {
-  if (name_length > 0) {
-    for (int i = 0; i < name_length; i++) {
-      name_.push_back(*(name + i));
-    }
-    name_.push_back('\0');
-  }
-}
+      name_(zone) {}
 
 
 uint16_t WasmFunctionBuilder::AddParam(LocalType type) {
   return AddVar(type, true);
 }
 
 
 uint16_t WasmFunctionBuilder::AddLocal(LocalType type) {
   return AddVar(type, false);
 }
@@ skipping 53 matching lines @@
   DCHECK(offset < body_.size());
   body_[offset] = immediate;
 }
 
 
 void WasmFunctionBuilder::Exported(uint8_t flag) { exported_ = flag; }
 
 
 void WasmFunctionBuilder::External(uint8_t flag) { external_ = flag; }
 
+void WasmFunctionBuilder::SetName(const unsigned char* name, int name_length) {
+  name_.clear();
+  if (name_length > 0) {
+    for (int i = 0; i < name_length; i++) {
+      name_.push_back(*(name + i));
+    }
+    name_.push_back('\0');
+  }
+}
+
 
 WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
                                                 WasmModuleBuilder* mb) const {
   WasmFunctionEncoder* e =
       new (zone) WasmFunctionEncoder(zone, return_type_, exported_, external_);
   uint16_t* var_index = zone->NewArray<uint16_t>(locals_.size());
   IndexVars(e, var_index);
   if (body_.size() > 0) {
     // TODO(titzer): iterate over local indexes, not the bytes.
     const byte* start = &body_[0];
@@ skipping 176 matching lines @@
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
       signature_map_(zone) {}
 
 
-uint16_t WasmModuleBuilder::AddFunction(const unsigned char* name,
-                                        int name_length) {
-  functions_.push_back(new (zone_)
-                           WasmFunctionBuilder(zone_, name, name_length));
+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);
   } else {
     return nullptr;
   }
@@ skipping 218 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8