[wasm] Encode function signatures, bodies, and names as separate sections.

test/mjsunit/wasm/wasm-module-builder.js

 // Copyright 2016 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.
 
 function WasmFunctionBuilder(name, sig_index) {
     this.name = name;
     this.sig_index = sig_index;
     this.exports = [];
 }
 
@@ skipping 107 matching lines @@
         var v = val & 0xff;
         val = val >>> 7;
         if (val == 0) {
             bytes.push(v);
             break;
         }
         bytes.push(v | 0x80);
     }
 }
 
+function emit_bytes(bytes, data) {
+  for (var i = 0; i < data.length; i++) {
+    bytes.push(data[i] & 0xff);
+  }
+}
+
 WasmModuleBuilder.prototype.toArray = function(debug) {
     // Add header bytes
     var bytes = [];
     bytes = bytes.concat([kWasmH0, kWasmH1, kWasmH2, kWasmH3,
                           kWasmV0, kWasmV1, kWasmV2, kWasmV3]);
 
     // Add memory section
     if (this.memory != undefined) {
         if (debug) print("emitting memory @ " + bytes.length);
         emit_u8(bytes, kDeclMemory);
@@ skipping 25 matching lines @@
             emit_varint(bytes, imp.sig_index);
             emit_string(bytes, imp.module);
             emit_string(bytes, imp.name || '');
         }
     }
 
     // Add functions section
     var names = false;
     var exports = 0;
     if (this.functions.length > 0) {
-        if (debug) print("emitting functions @ " + bytes.length);
-        emit_u8(bytes, kDeclFunctions);
+        var has_names = false;
+
+        // emit function signatures
+        if (debug) print("emitting function sigs @ " + bytes.length);
+        emit_u8(bytes, kDeclFunctionSignatures);
         emit_varint(bytes, this.functions.length);
-        var index = 0;
         for (func of this.functions) {
-            var flags = 0;
-            var hasName = func.name != undefined && func.name.length > 0;
-            names = names || hasName;
-            if (hasName) flags |= kDeclFunctionName;
-            exports += func.exports.length;
+          has_names = has_names || (func.name != undefined &&
+                                    func.name.length > 0);
+          exports += func.exports.length;
 
-            emit_u8(bytes, flags);
-            emit_u16(bytes, func.sig_index);
+          emit_varint(bytes, func.sig_index);
+        }
 
-            if (hasName) emit_string(bytes, func.name);
-
+        // emit function bodies
+        if (debug) print("emitting function bodies @ " + bytes.length);
+        emit_u8(bytes, kDeclFunctionBodies);
+        emit_varint(bytes, this.functions.length);
+        for (func of this.functions) {
             // Function body length will be patched later.
-            var length_pos = bytes.length;
-            emit_u16(bytes, 0);
-
             var local_decls = [];
             var l = func.locals;
             if (l != undefined) {
               var local_decls_count = 0;
               if (l.i32_count > 0) {
                 local_decls.push({count: l.i32_count, type: kAstI32});
               }
               if (l.i64_count > 0) {
                 local_decls.push({count: l.i64_count, type: kAstI64});
               }
               if (l.f32_count > 0) {
                 local_decls.push({count: l.f32_count, type: kAstF32});
               }
               if (l.f64_count > 0) {
                 local_decls.push({count: l.f64_count, type: kAstF64});
               }
             }
-            emit_varint(bytes, local_decls.length);
+            var header = new Array();
+
+            emit_varint(header, local_decls.length);
             for (decl of local_decls) {
-              emit_varint(bytes, decl.count);
-              emit_u8(bytes, decl.type);
+              emit_varint(header, decl.count);
+              emit_u8(header, decl.type);
             }
 
-            for (var i = 0; i < func.body.length; i++) {
-                emit_u8(bytes, func.body[i]);
-            }
-            var length = bytes.length - length_pos - 2;
-            bytes[length_pos] = length & 0xff;
-            bytes[length_pos + 1] = (length >> 8) & 0xff;
+            emit_varint(bytes, header.length + func.body.length);
+            emit_bytes(bytes, header);
+            emit_bytes(bytes, func.body);
+        }
+    }
 
-            index++;
+    // emit function names
+    if (has_names) {
+        if (debug) print("emitting names @ " + bytes.length);
+        emit_u8(bytes, kDeclNames);
+        emit_varint(bytes, this.functions.length);
+        for (func of this.functions) {
+            var name = func.name == undefined ? "" : func.name;
+           emit_string(bytes, name);
+           emit_u8(bytes, 0);  // local names count == 0
         }
     }
 
     // Add start function section.
     if (this.start_index != undefined) {
         if (debug) print("emitting start function @ " + bytes.length);
-      emit_u8(bytes, kDeclStartFunction);
-      emit_varint(bytes, this.start_index);
+        emit_u8(bytes, kDeclStartFunction);
+        emit_varint(bytes, this.start_index);
     }
 
     if (this.function_table.length > 0) {
         if (debug) print("emitting function table @ " + bytes.length);
         emit_u8(bytes, kDeclFunctionTable);
         emit_varint(bytes, this.function_table.length);
         for (index of this.function_table) {
             emit_varint(bytes, index);
         }
     }
@@ skipping 10 matching lines @@
         }
     }
 
     if (this.data_segments.length > 0) {
         if (debug) print("emitting data segments @ " + bytes.length);
         emit_u8(bytes, kDeclDataSegments);
         emit_varint(bytes, this.data_segments.length);
         for (seg of this.data_segments) {
             emit_varint(bytes, seg.addr);
             emit_varint(bytes, seg.data.length);
-            for (var i = 0; i < seg.data.length; i++) {
-                emit_u8(bytes, seg.data[i]);
-            }
+            emit_bytes(bytes, seg.data);
         }
     }
 
     // Emit any explicitly added sections
     for (exp of this.explicit) {
         if (debug) print("emitting explicit @ " + bytes.length);
-        for (var i = 0; i < exp.length; i++) {
-            emit_u8(bytes, exp[i]);
-        }
+        emit_bytes(bytes, exp);
     }
 
     // End the module.
     if (debug) print("emitting end @ " + bytes.length);
     emit_u8(bytes, kDeclEnd);
 
     return bytes;
 }
 
 WasmModuleBuilder.prototype.toBuffer = function(debug) {
     var bytes = this.toArray(debug);
     var buffer = new ArrayBuffer(bytes.length);
     var view = new Uint8Array(buffer);
     for (var i = 0; i < bytes.length; i++) {
         var val = bytes[i];
         if ((typeof val) == "string") val = val.charCodeAt(0);
         view[i] = val | 0;
     }
     return buffer;
 }
 
 WasmModuleBuilder.prototype.instantiate = function(ffi, memory) {
     var buffer = this.toBuffer();
     if (memory != undefined) {
       return Wasm.instantiateModule(buffer, ffi, memory);
     } else {
       return Wasm.instantiateModule(buffer, ffi);
     }
 }