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

src/wasm/wasm-module.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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
@@ skipping 66 matching lines @@
 std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
   os << "WASM module with ";
   os << (module.min_mem_pages * module.kPageSize) << " min mem";
   os << (module.max_mem_pages * module.kPageSize) << " max mem";
   os << module.functions.size() << " functions";
   os << module.functions.size() << " globals";
   os << module.functions.size() << " data segments";
   return os;
 }
 
-
 std::ostream& operator<<(std::ostream& os, const WasmFunction& function) {
   os << "WASM function with signature " << *function.sig;
 
   os << " locals: ";
   if (function.local_i32_count) os << function.local_i32_count << " i32s ";
   if (function.local_i64_count) os << function.local_i64_count << " i64s ";
   if (function.local_f32_count) os << function.local_f32_count << " f32s ";
   if (function.local_f64_count) os << function.local_f64_count << " f64s ";
 
   os << " code bytes: "
@@ skipping 116 matching lines @@
   if (globals.size() == 0) return 0;
   for (WasmGlobal& global : globals) {
     byte size = WasmOpcodes::MemSize(global.type);
     offset = (offset + size - 1) & ~(size - 1);  // align
     global.offset = offset;
     offset += size;
   }
   return offset;
 }
 
-
 void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
   for (const WasmDataSegment& segment : module->data_segments) {
     if (!segment.init) continue;
     if (!segment.source_size) continue;
     CHECK_LT(segment.dest_addr, mem_size);
     CHECK_LE(segment.source_size, mem_size);
     CHECK_LE(segment.dest_addr + segment.source_size, mem_size);
     byte* addr = mem_addr + segment.dest_addr;
     memcpy(addr, module->module_start + segment.source_offset,
            segment.source_size);
   }
 }
 
-
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, WasmModule* module) {
   if (module->function_table.size() == 0) {
     return Handle<FixedArray>::null();
   }
   int table_size = static_cast<int>(module->function_table.size());
   Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
   for (int i = 0; i < table_size; i++) {
     WasmFunction* function = &module->functions[module->function_table[i]];
     fixed->set(i, Smi::FromInt(function->sig_index));
   }
@@ skipping 424 matching lines @@
     MaybeHandle<Object> retval =
         Execution::Call(isolate, jsfunc, undefined, 0, nullptr);
 
     if (retval.is_null()) {
       thrower.Error("WASM.instantiateModule(): start function failed");
     }
   }
   return instance.js_object;
 }
 
-
 Handle<Code> ModuleEnv::GetFunctionCode(uint32_t index) {
   DCHECK(IsValidFunction(index));
   if (linker) return linker->GetFunctionCode(index);
   return instance ? instance->function_code[index] : Handle<Code>::null();
 }
 
 Handle<Code> ModuleEnv::GetImportCode(uint32_t index) {
   DCHECK(IsValidImport(index));
   return instance ? instance->import_code[index] : Handle<Code>::null();
 }
 
 compiler::CallDescriptor* ModuleEnv::GetCallDescriptor(Zone* zone,
                                                        uint32_t index) {
   DCHECK(IsValidFunction(index));
   // Always make a direct call to whatever is in the table at that location.
   // A wrapper will be generated for FFI calls.
   WasmFunction* function = &module->functions[index];
   return GetWasmCallDescriptor(zone, function->sig);
 }
 
-
 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
                                 const byte* module_end, bool asm_js) {
   HandleScope scope(isolate);
   Zone zone(isolate->allocator());
   // Decode the module, but don't verify function bodies, since we'll
   // be compiling them anyway.
   ModuleResult result = DecodeWasmModule(isolate, &zone, module_start,
                                          module_end, false, kWasmOrigin);
   if (result.failed()) {
     if (result.val) {
       delete result.val;
     }
     // Module verification failed. throw.
     std::ostringstream str;
     str << "WASM.compileRun() failed: " << result;
     isolate->Throw(
         *isolate->factory()->NewStringFromAsciiChecked(str.str().c_str()));
     return -1;
   }
 
   int32_t retval = CompileAndRunWasmModule(isolate, result.val);
   delete result.val;
   return retval;
 }
 
-
 int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module) {
   ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
   WasmModuleInstance instance(module);
 
   // Allocate and initialize the linear memory.
   if (!AllocateMemory(&thrower, isolate, &instance)) {
     return -1;
   }
   LoadDataSegments(module, instance.mem_start, instance.mem_size);
 
@@ skipping 74 matching lines @@
       wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
   if (func_names_arr_obj->IsUndefined())
     return func_names_arr_obj;  // Return undefined.
   return GetWasmFunctionNameFromTable(
       Handle<ByteArray>::cast(func_names_arr_obj), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8