[formatting] Remove all double blank lines in WASM code.

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 21 matching lines @@
 
 /*TODO: add error cases for adding too many locals, too many functions and bad
   indices in body */
 
 namespace {
 void EmitUint8(byte** b, uint8_t x) {
   Memory::uint8_at(*b) = x;
   *b += 1;
 }
 
-
 void EmitUint16(byte** b, uint16_t x) {
   WriteUnalignedUInt16(*b, x);
   *b += 2;
 }
 
-
 void EmitUint32(byte** b, uint32_t x) {
   WriteUnalignedUInt32(*b, x);
   *b += 4;
 }
 
 void EmitVarInt(byte** b, size_t val) {
   LEBHelper::write_u32v(b, static_cast<uint32_t>(val));
 }
 
 // Sections all start with a size, but it's unknown at the start.
@@ skipping 36 matching lines @@
 
   return start;
 }
 }  // namespace
 
 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);
   }
 }
 
 uint16_t WasmFunctionBuilder::AddParam(LocalType type) {
   return AddVar(type, true);
 }
 
-
 uint16_t WasmFunctionBuilder::AddLocal(LocalType type) {
   return AddVar(type, false);
 }
 
-
 uint16_t WasmFunctionBuilder::AddVar(LocalType type, bool param) {
   locals_.push_back({param, type});
   return static_cast<uint16_t>(locals_.size() - 1);
 }
 
-
 void WasmFunctionBuilder::ReturnType(LocalType type) { return_type_ = type; }
 
-
 void WasmFunctionBuilder::EmitCode(const byte* code, uint32_t code_size) {
   EmitCode(code, code_size, nullptr, 0);
 }
 
 void WasmFunctionBuilder::EmitGetLocal(uint32_t local_index) {
   local_indices_.push_back(static_cast<uint32_t>(body_.size() + 1));
   EmitWithVarInt(kExprGetLocal, local_index);
 }
 
 void WasmFunctionBuilder::EmitSetLocal(uint32_t local_index) {
   local_indices_.push_back(static_cast<uint32_t>(body_.size() + 1));
   EmitWithVarInt(kExprSetLocal, local_index);
 }
 
 void WasmFunctionBuilder::EmitCode(const byte* code, uint32_t code_size,
                                    const uint32_t* local_indices,
                                    uint32_t indices_size) {
   size_t size = body_.size();
   for (size_t i = 0; i < code_size; i++) {
     body_.push_back(code[i]);
   }
   for (size_t i = 0; i < indices_size; i++) {
     local_indices_.push_back(local_indices[i] + static_cast<uint32_t>(size));
   }
 }
 
-
 void WasmFunctionBuilder::Emit(WasmOpcode opcode) {
   body_.push_back(static_cast<byte>(opcode));
 }
 
-
 void WasmFunctionBuilder::EmitWithU8(WasmOpcode opcode, const byte immediate) {
   body_.push_back(static_cast<byte>(opcode));
   body_.push_back(immediate);
 }
 
 void WasmFunctionBuilder::EmitWithU8U8(WasmOpcode opcode, const byte imm1,
                                        const byte imm2) {
   body_.push_back(static_cast<byte>(opcode));
   body_.push_back(imm1);
   body_.push_back(imm2);
@@ skipping 37 matching lines @@
       if (local_indices_[i] >= offset) {
         local_indices_[i] += diff;
       }
     }
   }
   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) {
   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_);
   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;
@@ skipping 31 matching lines @@
     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());
   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 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++;
@@ skipping 25 matching lines @@
     } else if (locals_.at(i).type_ == kAstI64) {
       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) {}
 
-
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
   if (!external_) 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());
 }
 
-
 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);
 
     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]);
   }
 }
 
-
 uint32_t WasmDataSegmentEncoder::HeaderSize() const {
   static const int kDataSegmentSize = 13;
   return kDataSegmentSize;
 }
 
-
 uint32_t WasmDataSegmentEncoder::BodySize() const {
   return static_cast<uint32_t>(data_.size());
 }
 
-
 void WasmDataSegmentEncoder::Serialize(byte* buffer, byte** header,
                                        byte** body) const {
   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),
       functions_(zone),
       data_segments_(zone),
       indirect_functions_(zone),
       globals_(zone),
       signature_map_(zone),
       start_function_index_(-1) {}
 
 uint16_t WasmModuleBuilder::AddFunction() {
   functions_.push_back(new (zone_) WasmFunctionBuilder(zone_));
   return static_cast<uint16_t>(functions_.size() - 1);
 }
 
-
 WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
   if (functions_.size() > index) {
     return functions_.at(index);
   } else {
     return nullptr;
   }
 }
 
-
 void WasmModuleBuilder::AddDataSegment(WasmDataSegmentEncoder* data) {
   data_segments_.push_back(data);
 }
 
-
 bool WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
                                                         FunctionSig* b) const {
   if (a->return_count() < b->return_count()) return true;
   if (a->return_count() > b->return_count()) return false;
   if (a->parameter_count() < b->parameter_count()) return true;
   if (a->parameter_count() > b->parameter_count()) return false;
   for (size_t r = 0; r < a->return_count(); r++) {
     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) {
   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);
 }
 
 void WasmModuleBuilder::MarkStartFunction(uint16_t index) {
   start_function_index_ = index;
 }
 
 WasmModuleWriter* WasmModuleBuilder::Build(Zone* zone) {
   WasmModuleWriter* writer = new (zone) WasmModuleWriter(zone);
   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),
       data_segments_(zone),
       signatures_(zone),
       indirect_functions_(zone),
       globals_(zone) {}
 
 struct Sizes {
   size_t header_size;
   size_t body_size;
@@ skipping 182 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