[wasm] Fix empty asm.js function in ASM->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 139 matching lines @@
 void WasmFunctionBuilder::Exported(uint8_t flag) { exported_ = flag; }
 
 
 void WasmFunctionBuilder::External(uint8_t flag) { external_ = flag; }
 
 
 WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
                                                 WasmModuleBuilder* mb) const {
   WasmFunctionEncoder* e =
       new (zone) WasmFunctionEncoder(zone, return_type_, exported_, external_);
-  auto var_index = new uint16_t[locals_.size()];
+  uint16_t* var_index = zone->NewArray<uint16_t>(locals_.size());
   IndexVars(e, var_index);
-  const byte* start = &body_[0];
-  const byte* end = start + body_.size();
-  size_t local_index = 0;
-  for (size_t i = 0; i < body_.size();) {
-    if (local_index < local_indices_.size() &&
-        i == local_indices_[local_index]) {
-      int length = 0;
-      uint32_t index;
-      ReadUnsignedLEB128Operand(start + i, end, &length, &index);
-      uint16_t new_index = var_index[index];
-      const std::vector<uint8_t>& index_vec = UnsignedLEB128From(new_index);
-      for (size_t j = 0; j < index_vec.size(); j++) {
-        e->body_.push_back(index_vec.at(j));
+  if (body_.size() > 0) {
+    // TODO(titzer): iterate over local indexes, not the bytes.
+    const byte* start = &body_[0];
+    const byte* end = start + body_.size();
+    size_t local_index = 0;
+    for (size_t i = 0; i < body_.size();) {
+      if (local_index < local_indices_.size() &&
+          i == local_indices_[local_index]) {
+        int length = 0;
+        uint32_t index;
+        ReadUnsignedLEB128Operand(start + i, end, &length, &index);
+        uint16_t new_index = var_index[index];
+        const std::vector<uint8_t>& index_vec = UnsignedLEB128From(new_index);
+        for (size_t j = 0; j < index_vec.size(); j++) {
+          e->body_.push_back(index_vec.at(j));
+        }
+        i += length;
+        local_index++;
+      } else {
+        e->body_.push_back(*(start + i));
+        i++;
       }
-      i += length;
-      local_index++;
-    } else {
-      e->body_.push_back(*(start + i));
-      i++;
     }
   }
   FunctionSig::Builder sig(zone, return_type_ == kAstStmt ? 0 : 1,
                            e->params_.size());
   if (return_type_ != kAstStmt) {
     sig.AddReturn(static_cast<LocalType>(return_type_));
   }
   for (size_t i = 0; i < e->params_.size(); i++) {
     sig.AddParam(static_cast<LocalType>(e->params_[i]));
   }
   e->signature_index_ = mb->AddSignature(sig.Build());
-  delete[] var_index;
   e->name_.insert(e->name_.begin(), name_.begin(), name_.end());
   return e;
 }
 
 
 void WasmFunctionBuilder::IndexVars(WasmFunctionEncoder* e,
                                     uint16_t* var_index) const {
   uint16_t param = 0;
   uint16_t int32 = 0;
   uint16_t int64 = 0;
@@ skipping 85 matching lines @@
 
   if (HasLocals()) {
     EmitUint16(header, local_int32_count_);
     EmitUint16(header, local_int64_count_);
     EmitUint16(header, local_float32_count_);
     EmitUint16(header, local_float64_count_);
   }
 
   if (!external_) {
     EmitUint16(header, static_cast<uint16_t>(body_.size()));
-    std::memcpy(*header, &body_[0], body_.size());
-    (*header) += body_.size();
+    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)
     : data_(zone), dest_(dest) {
   for (size_t i = 0; i < size; i++) {
     data_.push_back(data[i]);
   }
@@ skipping 269 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8