[wasm] Remove the use of the "external" bit on OldFunctions section.

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 86 matching lines @@
 
 struct WasmFunctionBuilder::Type {
   bool param_;
   LocalType type_;
 };
 
 WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone)
     : return_type_(kAstI32),
       locals_(zone),
       exported_(0),
-      external_(0),
       body_(zone),
       local_indices_(zone),
       name_(zone) {}
 
 void WasmFunctionBuilder::EmitVarInt(uint32_t val) {
   byte buffer[8];
   byte* ptr = buffer;
   LEBHelper::write_u32v(&ptr, val);
   for (byte* p = buffer; p < ptr; p++) {
     body_.push_back(*p);
@@ skipping 97 matching lines @@
       }
     }
   }
   DCHECK(offset + immediate_size <= body_.size());
   byte* p = &body_[offset];
   v8::internal::wasm::EmitVarInt(&p, immediate);
 }
 
 void WasmFunctionBuilder::Exported(uint8_t flag) { exported_ = flag; }
 
-void WasmFunctionBuilder::External(uint8_t flag) { external_ = flag; }
-
-void WasmFunctionBuilder::SetName(const unsigned char* name, int name_length) {
+void WasmFunctionBuilder::SetName(const char* name, int name_length) {
   name_.clear();
   if (name_length > 0) {
     for (int i = 0; i < name_length; i++) {
       name_.push_back(*(name + i));
     }
   }
 }
 
 WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
                                                 WasmModuleBuilder* mb) const {
   WasmFunctionEncoder* e =
-      new (zone) WasmFunctionEncoder(zone, return_type_, exported_, external_);
+      new (zone) WasmFunctionEncoder(zone, return_type_, exported_);
   uint16_t* var_index = zone->NewArray<uint16_t>(locals_.size());
   IndexVars(e, var_index);
   if (body_.size() > 0) {
     // TODO(titzer): iterate over local indexes, not the bytes.
     const byte* start = &body_[0];
     size_t local_index = 0;
     for (size_t i = 0; i < body_.size();) {
       if (local_index < local_indices_.size() &&
           i == local_indices_[local_index]) {
         // Read the old index.
@@ skipping 73 matching lines @@
       var_index[i] = i64++;
     } else if (locals_.at(i).type_ == kAstF32) {
       var_index[i] = f32++;
     } else if (locals_.at(i).type_ == kAstF64) {
       var_index[i] = f64++;
     }
   }
 }
 
 WasmFunctionEncoder::WasmFunctionEncoder(Zone* zone, LocalType return_type,
-                                         bool exported, bool external)
-    : params_(zone),
-      exported_(exported),
-      external_(external),
-      body_(zone),
-      name_(zone) {}
+                                         bool exported)
+    : params_(zone), exported_(exported), body_(zone), name_(zone) {}
 
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
-  if (!external_) size += 2;
+  size += 2;
   if (HasName()) {
     uint32_t name_size = NameSize();
     size +=
         static_cast<uint32_t>(LEBHelper::sizeof_u32v(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);
   local_decl.AddLocals(local_f64_count_, kAstF64);
 
-  return external_ ? 0
-                   : static_cast<uint32_t>(body_.size() + local_decl.Size());
+  return static_cast<uint32_t>(body_.size() + local_decl.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) |
                       (HasName() ? kDeclFunctionName : 0);
 
   EmitUint8(header, decl_bits);
   EmitUint16(header, signature_index_);
 
   if (HasName()) {
     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);
+  // 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);
 
-    EmitUint16(header, static_cast<uint16_t>(body_.size() + local_decl.Size()));
-    (*header) += local_decl.Emit(*header);
-    if (body_.size() > 0) {
-      std::memcpy(*header, &body_[0], body_.size());
-      (*header) += body_.size();
-    }
+  EmitUint16(header, static_cast<uint16_t>(body_.size() + local_decl.Size()));
+  (*header) += local_decl.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)
     : data_(zone), dest_(dest) {
   for (size_t i = 0; i < size; i++) {
     data_.push_back(data[i]);
   }
 }
@@ skipping 12 matching lines @@
   EmitVarInt(header, dest_);
   EmitVarInt(header, static_cast<uint32_t>(data_.size()));
 
   std::memcpy(*header, &data_[0], data_.size());
   (*header) += data_.size();
 }
 
 WasmModuleBuilder::WasmModuleBuilder(Zone* zone)
     : zone_(zone),
       signatures_(zone),
+      imports_(zone),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
       signature_map_(zone),
       start_function_index_(-1) {}
 
-uint16_t WasmModuleBuilder::AddFunction() {
+uint32_t WasmModuleBuilder::AddFunction() {
   functions_.push_back(new (zone_) WasmFunctionBuilder(zone_));
-  return static_cast<uint16_t>(functions_.size() - 1);
+  return static_cast<uint32_t>(functions_.size() - 1);
 }
 
 WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
   if (functions_.size() > index) {
     return functions_.at(index);
   } else {
     return nullptr;
   }
 }
 
@@ skipping 11 matching lines @@
     if (a->GetReturn(r) < b->GetReturn(r)) return true;
     if (a->GetReturn(r) > b->GetReturn(r)) return false;
   }
   for (size_t p = 0; p < a->parameter_count(); p++) {
     if (a->GetParam(p) < b->GetParam(p)) return true;
     if (a->GetParam(p) > b->GetParam(p)) return false;
   }
   return false;
 }
 
-uint16_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
+uint32_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
   SignatureMap::iterator pos = signature_map_.find(sig);
   if (pos != signature_map_.end()) {
     return pos->second;
   } else {
     uint16_t index = static_cast<uint16_t>(signatures_.size());
     signature_map_[sig] = index;
     signatures_.push_back(sig);
     return index;
   }
 }
 
 void WasmModuleBuilder::AddIndirectFunction(uint16_t index) {
   indirect_functions_.push_back(index);
 }
 
+uint32_t WasmModuleBuilder::AddImport(const char* name, int name_length,
+                                      FunctionSig* sig) {
+  imports_.push_back({AddSignature(sig), name, name_length});
+  return static_cast<uint32_t>(imports_.size() - 1);
+}
+
 void WasmModuleBuilder::MarkStartFunction(uint16_t index) {
   start_function_index_ = index;
 }
 
 WasmModuleWriter* WasmModuleBuilder::Build(Zone* zone) {
   WasmModuleWriter* writer = new (zone) WasmModuleWriter(zone);
+  for (auto import : imports_) {
+    writer->imports_.push_back(import);
+  }
   for (auto function : functions_) {
     writer->functions_.push_back(function->Build(zone, this));
   }
   for (auto segment : data_segments_) {
     writer->data_segments_.push_back(segment);
   }
   for (auto sig : signatures_) {
     writer->signatures_.push_back(sig);
   }
   for (auto index : indirect_functions_) {
     writer->indirect_functions_.push_back(index);
   }
   for (auto global : globals_) {
     writer->globals_.push_back(global);
   }
   writer->start_function_index_ = start_function_index_;
   return writer;
 }
 
 uint32_t WasmModuleBuilder::AddGlobal(MachineType type, bool exported) {
   globals_.push_back(std::make_pair(type, exported));
   return static_cast<uint32_t>(globals_.size() - 1);
 }
 
 WasmModuleWriter::WasmModuleWriter(Zone* zone)
-    : functions_(zone),
+    : imports_(zone),
+      functions_(zone),
       data_segments_(zone),
       signatures_(zone),
       indirect_functions_(zone),
       globals_(zone) {}
 
 struct Sizes {
   size_t header_size;
   size_t body_size;
 
   size_t total() { return header_size + body_size; }
@@ skipping 41 matching lines @@
   if (functions_.size() > 0) {
     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 (imports_.size() > 0) {
+    sizes.AddSection(WasmSection::Code::ImportTable, imports_.size());
+    for (auto import : imports_) {
+      sizes.Add(LEBHelper::sizeof_u32v(import.sig_index), 0);
+      sizes.Add(LEBHelper::sizeof_u32v(import.name_length), 0);
+      sizes.Add(import.name_length, 0);
+      sizes.Add(1, 0);
+    }
+    TRACE("Size after imports: %u, %u\n", (unsigned)sizes.header_size,
+          (unsigned)sizes.body_size);
+  }
+
   if (indirect_functions_.size() > 0) {
     sizes.AddSection(WasmSection::Code::FunctionTable,
                      indirect_functions_.size());
     for (auto function_index : indirect_functions_) {
       sizes.Add(LEBHelper::sizeof_u32v(function_index), 0);
     }
     TRACE("Size after indirect functions: %u, %u\n",
           (unsigned)sizes.header_size, (unsigned)sizes.body_size);
   }
 
@@ skipping 59 matching lines @@
         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 imports -----------------------------------------------------------
+  if (imports_.size() > 0) {
+    byte* section = EmitSection(WasmSection::Code::ImportTable, &header);
+    EmitVarInt(&header, imports_.size());
+    for (auto import : imports_) {
+      EmitVarInt(&header, import.sig_index);
+      EmitVarInt(&header, import.name_length);
+      std::memcpy(header, import.name, import.name_length);
+      header += import.name_length;
+      EmitVarInt(&header, 0);
+    }
+    FixupSection(section, header);
+  }
+
   // -- emit functions ---------------------------------------------------------
   if (functions_.size() > 0) {
     byte* section = EmitSection(WasmSection::Code::OldFunctions, &header);
     EmitVarInt(&header, functions_.size());
 
     for (auto func : functions_) {
       func->Serialize(buffer, &header, &body);
     }
     FixupSection(section, header);
   }
@@ skipping 40 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