[wasm] Rework encoding of local declarations.

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 177 matching lines @@
     sig.AddParam(static_cast<LocalType>(e->params_[i]));
   }
   e->signature_index_ = mb->AddSignature(sig.Build());
   e->name_.insert(e->name_.begin(), name_.begin(), name_.end());
   return e;
 }
 
 
 void WasmFunctionBuilder::IndexVars(WasmFunctionEncoder* e,
                                     uint16_t* var_index) const {
+  // TODO(titzer): all of this is unnecessary now.
   uint16_t param = 0;
   uint16_t i32 = 0;
   uint16_t i64 = 0;
   uint16_t f32 = 0;
   uint16_t f64 = 0;
   for (size_t i = 0; i < locals_.size(); i++) {
     if (locals_.at(i).param_) {
       param++;
     } else if (locals_.at(i).type_ == kAstI32) {
       i32++;
     } else if (locals_.at(i).type_ == kAstI64) {
       i64++;
     } else if (locals_.at(i).type_ == kAstF32) {
       f32++;
     } else if (locals_.at(i).type_ == kAstF64) {
       f64++;
     }
   }
-  e->local_i32_count_ = i32;
-  e->local_i64_count_ = i64;
-  e->local_f32_count_ = f32;
-  e->local_f64_count_ = f64;
+  e->local_decls_.AddLocals(i32, kAstI32);
+  e->local_decls_.AddLocals(i64, kAstI64);
+  e->local_decls_.AddLocals(f32, kAstF32);
+  e->local_decls_.AddLocals(f64, kAstF64);
   f64 = param + i32 + i64 + f32;
   f32 = param + i32 + i64;
   i64 = param + i32;
   i32 = param;
   param = 0;
   for (size_t i = 0; i < locals_.size(); i++) {
     if (locals_.at(i).param_) {
       e->params_.push_back(locals_.at(i).type_);
       var_index[i] = param++;
     } else if (locals_.at(i).type_ == kAstI32) {
@@ skipping 13 matching lines @@
                                          bool exported, bool external)
     : params_(zone),
       exported_(exported),
       external_(external),
       body_(zone),
       name_(zone) {}
 
 
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
-  if (HasLocals()) size += 8;
   if (!external_) size += 2;
   if (HasName()) size += 4;
   return size;
 }
 
 
 uint32_t WasmFunctionEncoder::BodySize(void) const {
-  return external_ ? 0 : static_cast<uint32_t>(body_.size());
+  return external_ ? 0
+                   : static_cast<uint32_t>(local_decls_.Size() + body_.size());
 }
 
 
 uint32_t WasmFunctionEncoder::NameSize() const {
   return HasName() ? static_cast<uint32_t>(name_.size()) : 0;
 }
 
 
 void WasmFunctionEncoder::Serialize(byte* buffer, byte** header,
                                     byte** body) const {
   uint8_t decl_bits = (exported_ ? kDeclFunctionExport : 0) |
                       (external_ ? kDeclFunctionImport : 0) |
-                      (HasLocals() ? kDeclFunctionLocals : 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();
   }
 
-  if (HasLocals()) {
-    EmitUint16(header, local_i32_count_);
-    EmitUint16(header, local_i64_count_);
-    EmitUint16(header, local_f32_count_);
-    EmitUint16(header, local_f64_count_);
-  }
-
   if (!external_) {
-    EmitUint16(header, static_cast<uint16_t>(body_.size()));
+    size_t size = body_.size() + local_decls_.Size();
+    EmitUint16(header, static_cast<uint16_t>(size));

[bradnelson, 2016/03/02 21:51:15]

I assume this will change to a leb in a later change?

[titzer, 2016/03/02 22:43:41]

Yeah, we'll just update everything to be LEB in one go.

+    (*header) += local_decls_.Emit(*header);
     if (body_.size() > 0) {
       std::memcpy(*header, &body_[0], body_.size());
       (*header) += body_.size();
     }
   }
 }
 
 
 WasmDataSegmentEncoder::WasmDataSegmentEncoder(Zone* zone, const byte* data,
                                                uint32_t size, uint32_t dest)
@@ skipping 296 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8