Fix several wasm warnings an a use after free.

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 141 matching lines @@
 
 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()];
   IndexVars(e, var_index);
-  const byte* start = body_.data();
+  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);
@@ skipping 102 matching lines @@
                       (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_.data(), name_.size());
+    std::memcpy(*body, &name_[0], name_.size());
     (*body) += name_.size();
   }
 
   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_.data(), body_.size());
+    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 13 matching lines @@
 
 
 void WasmDataSegmentEncoder::Serialize(byte* buffer, byte** header,
                                        byte** body) const {
   uint32_t body_offset = static_cast<uint32_t>(*body - buffer);
   EmitUint32(header, dest_);
   EmitUint32(header, body_offset);
   EmitUint32(header, static_cast<uint32_t>(data_.size()));
   EmitUint8(header, 1);  // init
 
-  std::memcpy(*body, data_.data(), data_.size());
+  std::memcpy(*body, &data_[0], data_.size());
   (*body) += data_.size();
 }
 
 
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
@@ skipping 17 matching lines @@
   }
 }
 
 
 void WasmModuleBuilder::AddDataSegment(WasmDataSegmentEncoder* data) {
   data_segments_.push_back(data);
 }
 
 
 int WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
-                                                       FunctionSig* b) {
+                                                       FunctionSig* b) const {
   if (a->return_count() < b->return_count()) return -1;
   if (a->return_count() > b->return_count()) return 1;
   if (a->parameter_count() < b->parameter_count()) return -1;
   if (a->parameter_count() > b->parameter_count()) return 1;
   for (size_t r = 0; r < a->return_count(); r++) {
     if (a->GetReturn(r) < b->GetReturn(r)) return -1;
     if (a->GetReturn(r) > b->GetReturn(r)) return 1;
   }
   for (size_t p = 0; p < a->parameter_count(); p++) {
     if (a->GetParam(p) < b->GetParam(p)) return -1;
@@ skipping 105 matching lines @@
   for (auto segment : data_segments_) {
     sizes.Add(segment->HeaderSize(), segment->BodySize());
   }
 
   sizes.AddSection(indirect_functions_.size());
   sizes.Add(2 * static_cast<uint32_t>(indirect_functions_.size()), 0);
 
   if (sizes.body_size > 0) sizes.Add(1, 0);
 
   ZoneVector<uint8_t> buffer_vector(sizes.total(), zone);
-  byte* buffer = buffer_vector.data();
+  byte* buffer = &buffer_vector[0];
   byte* header = buffer;
   byte* body = buffer + sizes.header_size;
 
   // -- emit memory declaration ------------------------------------------------
   EmitUint8(&header, kDeclMemory);
   EmitUint8(&header, 16);  // min memory size
   EmitUint8(&header, 16);  // max memory size
   EmitUint8(&header, 0);   // memory export
 
   // -- emit globals -----------------------------------------------------------
@@ skipping 72 matching lines @@
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8