[wasm] Binary 11: Module changes.

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 62 matching lines @@
       val = next;
     } else {
       *(start++) = out;
       // TODO(jfb) check that the pre-allocated fixup size isn't overflowed.
     }
   }
 }
 
 // Returns the start of the section, where the section VarInt size is.
 byte* EmitSection(WasmSection::Code code, byte** b) {
-  // Emit a placeholder for the length.
-  byte* start = *b;
-  for (size_t padding = 0; padding != kPaddedVarintSize; ++padding) {
-    EmitUint8(b, 0xff);  // Will get fixed up later.
-  }
   // Emit the section name.
   const char* name = WasmSection::getName(code);
   TRACE("emit section: %s\n", name);
   size_t length = WasmSection::getNameLength(code);
   EmitVarInt(b, length);  // Section name string size.
   for (size_t i = 0; i != length; ++i) EmitUint8(b, name[i]);
 
+  // Emit a placeholder for the length.
+  byte* start = *b;
+  for (size_t padding = 0; padding != kPaddedVarintSize; ++padding) {
+    EmitUint8(b, 0xff);  // Will get fixed up later.
+  }
+
   return start;
 }
 }  // namespace
 
 struct WasmFunctionBuilder::Type {
   bool param_;
   LocalType type_;
 };
 
 
@@ skipping 474 matching lines @@
     /* These globals never have names, so are always 3 bytes. */
     sizes.Add(3 * globals_.size(), 0);
     TRACE("Size after globals: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (signatures_.size() > 0) {
     sizes.AddSection(WasmSection::Code::Signatures, signatures_.size());
     for (auto sig : signatures_) {
       sizes.Add(1 + LEBHelper::sizeof_u32v(sig->parameter_count()) +
-                    sig->parameter_count(),
+                    sig->parameter_count() +
+                    LEBHelper::sizeof_u32v(sig->return_count()) +
+                    sig->return_count(),
                 0);
     }
     TRACE("Size after signatures: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (functions_.size() > 0) {
-    sizes.AddSection(WasmSection::Code::Functions, functions_.size());
+    sizes.AddSection(WasmSection::Code::OldFunctions, functions_.size());
     for (auto function : functions_) {
       sizes.Add(function->HeaderSize() + function->BodySize(),
                 function->NameSize());
     }
     TRACE("Size after functions: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (indirect_functions_.size() > 0) {
     sizes.AddSection(WasmSection::Code::FunctionTable,
@@ skipping 54 matching lines @@
     }
     FixupSection(section, header);
   }
 
   // -- emit signatures --------------------------------------------------------
   if (signatures_.size() > 0) {
     byte* section = EmitSection(WasmSection::Code::Signatures, &header);
     EmitVarInt(&header, signatures_.size());
 
     for (FunctionSig* sig : signatures_) {
+      EmitUint8(&header, kWasmFunctionTypeForm);
       EmitVarInt(&header, sig->parameter_count());
-      if (sig->return_count() > 0) {
-        EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetReturn()));
-      } else {
-        EmitUint8(&header, kLocalVoid);
-      }
       for (size_t j = 0; j < sig->parameter_count(); j++) {
         EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetParam(j)));
       }
+      EmitVarInt(&header, sig->return_count());
+      for (size_t j = 0; j < sig->return_count(); j++) {
+        EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetReturn(j)));
+      }
     }
     FixupSection(section, header);
   }
 
   // -- emit functions ---------------------------------------------------------
   if (functions_.size() > 0) {
-    byte* section = EmitSection(WasmSection::Code::Functions, &header);
+    byte* section = EmitSection(WasmSection::Code::OldFunctions, &header);
     EmitVarInt(&header, functions_.size());
 
     for (auto func : functions_) {
       func->Serialize(buffer, &header, &body);
     }
     FixupSection(section, header);
   }
 
   // -- emit function table ----------------------------------------------------
   if (indirect_functions_.size() > 0) {
@@ skipping 37 matching lines @@
   if (sizes.body_size > 0) {
     byte* section = EmitSection(WasmSection::Code::End, &header);
     FixupSection(section, header);
   }
 
   return new (zone) WasmModuleIndex(buffer, buffer + sizes.total());
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8