[wasm] All strings are length-prefixed and inline

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 162 matching lines @@
 
 
 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);
@@ skipping 86 matching lines @@
     : params_(zone),
       exported_(exported),
       external_(external),
       body_(zone),
       name_(zone) {}
 
 
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
   if (!external_) size += 2;
-  if (HasName()) size += 4;
+  if (HasName()) {
+    uint32_t name_size = NameSize();
+    size += static_cast<uint32_t>(SizeOfVarInt(name_size)) + name_size;
+  }
   return size;
 }
 
 
 uint32_t WasmFunctionEncoder::BodySize(void) const {
   // TODO(titzer): embed a LocalDeclEncoder in the WasmFunctionEncoder
   LocalDeclEncoder local_decl;
   local_decl.AddLocals(local_i32_count_, kAstI32);
   local_decl.AddLocals(local_i64_count_, kAstI64);
   local_decl.AddLocals(local_f32_count_, kAstF32);
@@ skipping 12 matching lines @@
 void WasmFunctionEncoder::Serialize(byte* buffer, byte** header,
                                     byte** body) const {
   uint8_t decl_bits = (exported_ ? kDeclFunctionExport : 0) |
                       (external_ ? kDeclFunctionImport : 0) |
                       (HasName() ? kDeclFunctionName : 0);
 
   EmitUint8(header, decl_bits);
   EmitUint16(header, signature_index_);
 
   if (HasName()) {
-    uint32_t name_offset = static_cast<uint32_t>(*body - buffer);
-    EmitUint32(header, name_offset);
-    std::memcpy(*body, &name_[0], name_.size());
-    (*body) += name_.size();
+    EmitVarInt(header, NameSize());
+    for (size_t i = 0; i < name_.size(); ++i) {
+      EmitUint8(header, name_[i]);
+    }
   }
 
 
   if (!external_) {
     // TODO(titzer): embed a LocalDeclEncoder in the WasmFunctionEncoder
     LocalDeclEncoder local_decl;
     local_decl.AddLocals(local_i32_count_, kAstI32);
     local_decl.AddLocals(local_i64_count_, kAstI64);
     local_decl.AddLocals(local_f32_count_, kAstF32);
     local_decl.AddLocals(local_f64_count_, kAstF64);
@@ skipping 173 matching lines @@
   sizes.Add(kDeclMemorySize, 0);
 
   sizes.AddSection(signatures_.size());
   for (auto sig : signatures_) {
     sizes.Add(1 + SizeOfVarInt(sig->parameter_count()) + sig->parameter_count(),
               0);
   }
 
   sizes.AddSection(globals_.size());
   if (globals_.size() > 0) {
-    sizes.Add(kDeclGlobalSize * globals_.size(), 0);
+    /* These globals never have names, so are always 3 bytes. */
+    sizes.Add(3 * 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);
@@ skipping 26 matching lines @@
   EmitVarInt(&header, 16);  // min memory size
   EmitVarInt(&header, 16);  // max memory size
   EmitUint8(&header, 0);    // memory export
 
   // -- emit globals -----------------------------------------------------------
   if (globals_.size() > 0) {
     EmitUint8(&header, kDeclGlobals);
     EmitVarInt(&header, globals_.size());
 
     for (auto global : globals_) {
-      EmitUint32(&header, 0);
+      EmitVarInt(&header, 0);  // Length of the global name.
       EmitUint8(&header, WasmOpcodes::MemTypeCodeFor(global.first));
       EmitUint8(&header, global.second);
     }
   }
 
   // -- emit signatures --------------------------------------------------------
   if (signatures_.size() > 0) {
     EmitUint8(&header, kDeclSignatures);
     EmitVarInt(&header, signatures_.size());
 
@@ skipping 62 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8