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

R=ahaas@chromium.org,mstarzinger@chromium.org
BUG=

Review-Url: https://codereview.chromium.org/1970543003
Cr-Commit-Position: refs/heads/master@{#36174}

src/compiler/wasm-compiler.cc

@@ -54,7 +54,6 @@ const Operator* UnsupportedOpcode(wasm::WasmOpcode opcode) {
   return nullptr;
 }
 
-
 void MergeControlToEnd(JSGraph* jsgraph, Node* node) {
   Graph* g = jsgraph->graph();
   if (g->end()) {
@@ -285,28 +284,23 @@ WasmGraphBuilder::WasmGraphBuilder(
   DCHECK_NOT_NULL(jsgraph_);
 }
 
-
 Node* WasmGraphBuilder::Error() { return jsgraph()->Dead(); }
 
-
 Node* WasmGraphBuilder::Start(unsigned params) {
   Node* start = graph()->NewNode(jsgraph()->common()->Start(params));
   graph()->SetStart(start);
   return start;
 }
 
-
 Node* WasmGraphBuilder::Param(unsigned index, wasm::LocalType type) {
   return graph()->NewNode(jsgraph()->common()->Parameter(index),
                           graph()->start());
 }
 
-
 Node* WasmGraphBuilder::Loop(Node* entry) {
   return graph()->NewNode(jsgraph()->common()->Loop(1), entry);
 }
 
-
 Node* WasmGraphBuilder::Terminate(Node* effect, Node* control) {
   Node* terminate =
       graph()->NewNode(jsgraph()->common()->Terminate(), effect, control);
@@ -314,18 +308,15 @@ Node* WasmGraphBuilder::Terminate(Node* effect, Node* control) {
   return terminate;
 }
 
-
 unsigned WasmGraphBuilder::InputCount(Node* node) {
   return static_cast<unsigned>(node->InputCount());
 }
 
-
 bool WasmGraphBuilder::IsPhiWithMerge(Node* phi, Node* merge) {
   return phi && IrOpcode::IsPhiOpcode(phi->opcode()) &&
          NodeProperties::GetControlInput(phi) == merge;
 }
 
-
 void WasmGraphBuilder::AppendToMerge(Node* merge, Node* from) {
   DCHECK(IrOpcode::IsMergeOpcode(merge->opcode()));
   merge->AppendInput(jsgraph()->zone(), from);
@@ -342,12 +333,10 @@ void WasmGraphBuilder::AppendToPhi(Node* phi, Node* from) {
       phi, jsgraph()->common()->ResizeMergeOrPhi(phi->op(), new_size));
 }
 
-
 Node* WasmGraphBuilder::Merge(unsigned count, Node** controls) {
   return graph()->NewNode(jsgraph()->common()->Merge(count), count, controls);
 }
 
-
 Node* WasmGraphBuilder::Phi(wasm::LocalType type, unsigned count, Node** vals,
                             Node* control) {
   DCHECK(IrOpcode::IsMergeOpcode(control->opcode()));
@@ -357,7 +346,6 @@ Node* WasmGraphBuilder::Phi(wasm::LocalType type, unsigned count, Node** vals,
                           buf);
 }
 
-
 Node* WasmGraphBuilder::EffectPhi(unsigned count, Node** effects,
                                   Node* control) {
   DCHECK(IrOpcode::IsMergeOpcode(control->opcode()));
@@ -375,7 +363,6 @@ Node* WasmGraphBuilder::Int32Constant(int32_t value) {
   return jsgraph()->Int32Constant(value);
 }
 
-
 Node* WasmGraphBuilder::Int64Constant(int64_t value) {
   return jsgraph()->Int64Constant(value);
 }
@@ -895,22 +882,18 @@ Node* WasmGraphBuilder::Unop(wasm::WasmOpcode opcode, Node* input,
   return graph()->NewNode(op, input);
 }
 
-
 Node* WasmGraphBuilder::Float32Constant(float value) {
   return jsgraph()->Float32Constant(value);
 }
 
-
 Node* WasmGraphBuilder::Float64Constant(double value) {
   return jsgraph()->Float64Constant(value);
 }
 
-
 Node* WasmGraphBuilder::Constant(Handle<Object> value) {
   return jsgraph()->Constant(value);
 }
 
-
 Node* WasmGraphBuilder::Branch(Node* cond, Node** true_node,
                                Node** false_node) {
   DCHECK_NOT_NULL(cond);
@@ -922,24 +905,20 @@ Node* WasmGraphBuilder::Branch(Node* cond, Node** true_node,
   return branch;
 }
 
-
 Node* WasmGraphBuilder::Switch(unsigned count, Node* key) {
   return graph()->NewNode(jsgraph()->common()->Switch(count), key, *control_);
 }
 
-
 Node* WasmGraphBuilder::IfValue(int32_t value, Node* sw) {
   DCHECK_EQ(IrOpcode::kSwitch, sw->opcode());
   return graph()->NewNode(jsgraph()->common()->IfValue(value), sw);
 }
 
-
 Node* WasmGraphBuilder::IfDefault(Node* sw) {
   DCHECK_EQ(IrOpcode::kSwitch, sw->opcode());
   return graph()->NewNode(jsgraph()->common()->IfDefault(), sw);
 }
 
-
 Node* WasmGraphBuilder::Return(unsigned count, Node** vals) {
   DCHECK_NOT_NULL(*control_);
   DCHECK_NOT_NULL(*effect_);
@@ -959,7 +938,6 @@ Node* WasmGraphBuilder::Return(unsigned count, Node** vals) {
   return ret;
 }
 
-
 Node* WasmGraphBuilder::ReturnVoid() { return Return(0, Buffer(0)); }
 
 Node* WasmGraphBuilder::Unreachable(wasm::WasmCodePosition position) {
@@ -1008,7 +986,6 @@ Node* WasmGraphBuilder::BuildF32Neg(Node* input) {
   return result;
 }
 
-
 Node* WasmGraphBuilder::BuildF64Neg(Node* input) {
 #if WASM_64
   Node* result =
@@ -1028,7 +1005,6 @@ Node* WasmGraphBuilder::BuildF64Neg(Node* input) {
 #endif
 }
 
-
 Node* WasmGraphBuilder::BuildF32CopySign(Node* left, Node* right) {
   Node* result = Unop(
       wasm::kExprF32ReinterpretI32,
@@ -1041,7 +1017,6 @@ Node* WasmGraphBuilder::BuildF32CopySign(Node* left, Node* right) {
   return result;
 }
 
-
 Node* WasmGraphBuilder::BuildF64CopySign(Node* left, Node* right) {
 #if WASM_64
   Node* result = Unop(
@@ -1070,7 +1045,6 @@ Node* WasmGraphBuilder::BuildF64CopySign(Node* left, Node* right) {
 #endif
 }
 
-
 Node* WasmGraphBuilder::BuildF32Min(Node* left, Node* right) {
   Diamond left_le_right(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF32Le, left, right));
@@ -1091,7 +1065,6 @@ Node* WasmGraphBuilder::BuildF32Min(Node* left, Node* right) {
               Binop(wasm::kExprF32Mul, left, Float32Constant(1.0)))));
 }
 
-
 Node* WasmGraphBuilder::BuildF32Max(Node* left, Node* right) {
   Diamond left_ge_right(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF32Ge, left, right));
@@ -1112,7 +1085,6 @@ Node* WasmGraphBuilder::BuildF32Max(Node* left, Node* right) {
               Binop(wasm::kExprF32Mul, left, Float32Constant(1.0)))));
 }
 
-
 Node* WasmGraphBuilder::BuildF64Min(Node* left, Node* right) {
   Diamond left_le_right(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF64Le, left, right));
@@ -1133,7 +1105,6 @@ Node* WasmGraphBuilder::BuildF64Min(Node* left, Node* right) {
               Binop(wasm::kExprF64Mul, left, Float64Constant(1.0)))));
 }
 
-
 Node* WasmGraphBuilder::BuildF64Max(Node* left, Node* right) {
   Diamond left_ge_right(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF64Ge, left, right));
@@ -1284,7 +1255,6 @@ Node* WasmGraphBuilder::BuildI32Popcnt(Node* input) {
       MachineRepresentation::kWord32);
 }
 
-
 Node* WasmGraphBuilder::BuildI64Popcnt(Node* input) {
   return Unop(wasm::kExprI64UConvertI32,
               BuildBitCountingCall(input, ExternalReference::wasm_word64_popcnt(
@@ -2452,7 +2422,6 @@ void WasmGraphBuilder::BuildJSToWasmWrapper(Handle<Code> wasm_code,
   MergeControlToEnd(jsgraph(), ret);
 }
 
-
 void WasmGraphBuilder::BuildWasmToJSWrapper(Handle<JSFunction> function,
                                             wasm::FunctionSig* sig) {
   int js_count = function->shared()->internal_formal_parameter_count();
@@ -2545,7 +2514,6 @@ void WasmGraphBuilder::BuildWasmToJSWrapper(Handle<JSFunction> function,
   MergeControlToEnd(jsgraph(), ret);
 }
 
-
 Node* WasmGraphBuilder::MemBuffer(uint32_t offset) {
   DCHECK(module_ && module_->instance);
   if (offset == 0) {
@@ -2562,7 +2530,6 @@ Node* WasmGraphBuilder::MemBuffer(uint32_t offset) {
   }
 }
 
-
 Node* WasmGraphBuilder::MemSize(uint32_t offset) {
   DCHECK(module_ && module_->instance);
   uint32_t size = static_cast<uint32_t>(module_->instance->mem_size);
@@ -2574,7 +2541,6 @@ Node* WasmGraphBuilder::MemSize(uint32_t offset) {
   }
 }
 
-
 Node* WasmGraphBuilder::FunctionTable() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
@@ -2584,7 +2550,6 @@ Node* WasmGraphBuilder::FunctionTable() {
   return function_table_;
 }
 
-
 Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
   DCHECK(module_ && module_->instance && module_->instance->globals_start);
   MachineType mem_type = module_->GetGlobalType(index);
@@ -2598,7 +2563,6 @@ Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
   return node;
 }
 
-
 Node* WasmGraphBuilder::StoreGlobal(uint32_t index, Node* val) {
   DCHECK(module_ && module_->instance && module_->instance->globals_start);
   MachineType mem_type = module_->GetGlobalType(index);
@@ -2713,13 +2677,11 @@ void WasmGraphBuilder::PrintDebugName(Node* node) {
   PrintF("#%d:%s", node->id(), node->op()->mnemonic());
 }
 
-
 Node* WasmGraphBuilder::String(const char* string) {
   return jsgraph()->Constant(
       jsgraph()->isolate()->factory()->NewStringFromAsciiChecked(string));
 }
 
-
 Graph* WasmGraphBuilder::graph() { return jsgraph()->graph(); }
 
 void WasmGraphBuilder::Int64LoweringForTesting() {

src/wasm/ast-decoder.cc

@@ -386,7 +386,6 @@ class WasmDecoder : public Decoder {
   }
 };
 
-
 // A shift-reduce-parser strategy for decoding Wasm code that uses an explicit
 // shift-reduce strategy with multiple internal stacks.
 class SR_WasmDecoder : public WasmDecoder {
@@ -1499,7 +1498,6 @@ TreeResult BuildTFGraph(base::AccountingAllocator* allocator,
   return decoder.toResult<Tree*>(nullptr);
 }
 
-
 std::ostream& operator<<(std::ostream& os, const Tree& tree) {
   if (tree.pc == nullptr) {
     os << "null";

src/wasm/encoder.cc

@@ -39,13 +39,11 @@ void EmitUint8(byte** b, uint8_t 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;
@@ -102,7 +100,6 @@ struct WasmFunctionBuilder::Type {
   LocalType type_;
 };
 
-
 WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone)
     : return_type_(kAstI32),
       locals_(zone),
@@ -125,21 +122,17 @@ 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);
 }
@@ -166,12 +159,10 @@ void WasmFunctionBuilder::EmitCode(const byte* code, uint32_t code_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);
@@ -229,10 +220,8 @@ void WasmFunctionBuilder::EditVarIntImmediate(uint32_t 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) {
@@ -244,7 +233,6 @@ void WasmFunctionBuilder::SetName(const unsigned char* name, int name_length) {
   }
 }
 
-
 WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
                                                 WasmModuleBuilder* mb) const {
   WasmFunctionEncoder* e =
@@ -296,7 +284,6 @@ WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
   return e;
 }
 
-
 void WasmFunctionBuilder::IndexVars(WasmFunctionEncoder* e,
                                     uint16_t* var_index) const {
   uint16_t param = 0;
@@ -342,7 +329,6 @@ void WasmFunctionBuilder::IndexVars(WasmFunctionEncoder* e,
   }
 }
 
-
 WasmFunctionEncoder::WasmFunctionEncoder(Zone* zone, LocalType return_type,
                                          bool exported, bool external)
     : params_(zone),
@@ -351,7 +337,6 @@ WasmFunctionEncoder::WasmFunctionEncoder(Zone* zone, LocalType return_type,
       body_(zone),
       name_(zone) {}
 
-
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
   if (!external_) size += 2;
@@ -363,7 +348,6 @@ uint32_t WasmFunctionEncoder::HeaderSize() const {
   return size;
 }
 
-
 uint32_t WasmFunctionEncoder::BodySize(void) const {
   // TODO(titzer): embed a LocalDeclEncoder in the WasmFunctionEncoder
   LocalDeclEncoder local_decl;
@@ -376,12 +360,10 @@ uint32_t WasmFunctionEncoder::BodySize(void) const {
                    : 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) |
@@ -398,7 +380,6 @@ void WasmFunctionEncoder::Serialize(byte* buffer, byte** header,
     }
   }
 
-
   if (!external_) {
     // TODO(titzer): embed a LocalDeclEncoder in the WasmFunctionEncoder
     LocalDeclEncoder local_decl;
@@ -416,7 +397,6 @@ void WasmFunctionEncoder::Serialize(byte* buffer, byte** header,
   }
 }
 
-
 WasmDataSegmentEncoder::WasmDataSegmentEncoder(Zone* zone, const byte* data,
                                                uint32_t size, uint32_t dest)
     : data_(zone), dest_(dest) {
@@ -425,18 +405,15 @@ WasmDataSegmentEncoder::WasmDataSegmentEncoder(Zone* zone, const byte* data,
   }
 }
 
-
 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_);
@@ -461,7 +438,6 @@ uint16_t WasmModuleBuilder::AddFunction() {
   return static_cast<uint16_t>(functions_.size() - 1);
 }
 
-
 WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
   if (functions_.size() > index) {
     return functions_.at(index);
@@ -470,12 +446,10 @@ WasmFunctionBuilder* WasmModuleBuilder::FunctionAt(size_t index) {
   }
 }
 
-
 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;
@@ -493,7 +467,6 @@ bool WasmModuleBuilder::CompareFunctionSigs::operator()(FunctionSig* a,
   return false;
 }
 
-
 uint16_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
   SignatureMap::iterator pos = signature_map_.find(sig);
   if (pos != signature_map_.end()) {
@@ -506,7 +479,6 @@ uint16_t WasmModuleBuilder::AddSignature(FunctionSig* sig) {
   }
 }
 
-
 void WasmModuleBuilder::AddIndirectFunction(uint16_t index) {
   indirect_functions_.push_back(index);
 }
@@ -536,13 +508,11 @@ WasmModuleWriter* WasmModuleBuilder::Build(Zone* zone) {
   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),

src/wasm/module-decoder.cc

@@ -773,7 +773,6 @@ class ModuleDecoder : public Decoder {
   }
 };
 
-
 // Helpers for nice error messages.
 class ModuleError : public ModuleResult {
  public:
@@ -787,7 +786,6 @@ class ModuleError : public ModuleResult {
   }
 };
 
-
 // Helpers for nice error messages.
 class FunctionError : public FunctionResult {
  public:
@@ -828,7 +826,6 @@ FunctionSig* DecodeWasmSignatureForTesting(Zone* zone, const byte* start,
   return decoder.DecodeFunctionSignature(start);
 }
 
-
 FunctionResult DecodeWasmFunction(Isolate* isolate, Zone* zone,
                                   ModuleEnv* module_env,
                                   const byte* function_start,

src/wasm/wasm-js.cc

@@ -34,7 +34,6 @@ struct RawBuffer {
   size_t size() { return static_cast<size_t>(end - start); }
 };
 
-
 RawBuffer GetRawBufferArgument(
     ErrorThrower& thrower, const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1) {
@@ -77,7 +76,6 @@ RawBuffer GetRawBufferArgument(
   return {start, end};
 }
 
-
 void VerifyModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
@@ -98,7 +96,6 @@ void VerifyModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (result.val) delete result.val;
 }
 
-
 void VerifyFunction(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
@@ -202,7 +199,6 @@ void InstantiateModuleCommon(const v8::FunctionCallbackInfo<v8::Value>& args,
   if (result.val) delete result.val;
 }
 
-
 void InstantiateModuleFromAsm(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
@@ -234,7 +230,6 @@ void InstantiateModuleFromAsm(const v8::FunctionCallbackInfo<v8::Value>& args) {
                           internal::wasm::kAsmJsOrigin);
 }
 
-
 void InstantiateModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
@@ -248,7 +243,6 @@ void InstantiateModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
 }
 }  // namespace
 
-
 // TODO(titzer): we use the API to create the function template because the
 // internal guts are too ugly to replicate here.
 static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
@@ -258,13 +252,11 @@ static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
   return v8::Utils::OpenHandle(*local);
 }
 
-
 namespace internal {
 static Handle<String> v8_str(Isolate* isolate, const char* str) {
   return isolate->factory()->NewStringFromAsciiChecked(str);
 }
 
-
 static void InstallFunc(Isolate* isolate, Handle<JSObject> object,
                         const char* str, FunctionCallback func) {
   Handle<String> name = v8_str(isolate, str);
@@ -276,7 +268,6 @@ static void InstallFunc(Isolate* isolate, Handle<JSObject> object,
   JSObject::AddProperty(object, name, function, attributes);
 }
 
-
 void WasmJs::Install(Isolate* isolate, Handle<JSGlobalObject> global) {
   // Setup wasm function map.
   Handle<Context> context(global->native_context(), isolate);
@@ -310,7 +301,6 @@ void WasmJs::Install(Isolate* isolate, Handle<JSGlobalObject> global) {
   }
 }
 
-
 void WasmJs::InstallWasmFunctionMap(Isolate* isolate, Handle<Context> context) {
   if (!context->get(Context::WASM_FUNCTION_MAP_INDEX)->IsMap()) {
     // TODO(titzer): Move this to bootstrapper.cc??

src/wasm/wasm-module.cc

@@ -84,7 +84,6 @@ std::ostream& operator<<(std::ostream& os, const WasmModule& module) {
   return os;
 }
 
-
 std::ostream& operator<<(std::ostream& os, const WasmFunction& function) {
   os << "WASM function with signature " << *function.sig;
 
@@ -221,7 +220,6 @@ size_t AllocateGlobalsOffsets(std::vector<WasmGlobal>& globals) {
   return offset;
 }
 
-
 void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
   for (const WasmDataSegment& segment : module->data_segments) {
     if (!segment.init) continue;
@@ -235,7 +233,6 @@ void LoadDataSegments(WasmModule* module, byte* mem_addr, size_t mem_size) {
   }
 }
 
-
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, WasmModule* module) {
   if (module->function_table.size() == 0) {
     return Handle<FixedArray>::null();
@@ -680,7 +677,6 @@ MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
   return instance.js_object;
 }
 
-
 Handle<Code> ModuleEnv::GetFunctionCode(uint32_t index) {
   DCHECK(IsValidFunction(index));
   if (linker) return linker->GetFunctionCode(index);
@@ -701,7 +697,6 @@ compiler::CallDescriptor* ModuleEnv::GetCallDescriptor(Zone* zone,
   return GetWasmCallDescriptor(zone, function->sig);
 }
 
-
 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
                                 const byte* module_end, bool asm_js) {
   HandleScope scope(isolate);
@@ -727,7 +722,6 @@ int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
   return retval;
 }
 
-
 int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module) {
   ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
   WasmModuleInstance instance(module);

src/wasm/wasm-opcodes.cc

@@ -51,13 +51,10 @@ std::ostream& operator<<(std::ostream& os, const FunctionSig& sig) {
   return os;
 }
 
-
 #define DECLARE_SIG_ENUM(name, ...) kSigEnum_##name,
 
-
 enum WasmOpcodeSig { FOREACH_SIGNATURE(DECLARE_SIG_ENUM) };
 
-
 // TODO(titzer): not static-initializer safe. Wrap in LazyInstance.
 #define DECLARE_SIG(name, ...)                      \
   static LocalType kTypes_##name[] = {__VA_ARGS__}; \
@@ -73,7 +70,6 @@ static const FunctionSig* kSimpleExprSigs[] = {
 
 static byte kSimpleExprSigTable[256];
 
-
 // Initialize the signature table.
 static void InitSigTable() {
 #define SET_SIG_TABLE(name, opcode, sig) \
@@ -83,7 +79,6 @@ static void InitSigTable() {
 #undef SET_SIG_TABLE
 }
 
-
 FunctionSig* WasmOpcodes::Signature(WasmOpcode opcode) {
   // TODO(titzer): use LazyInstance to make this thread safe.
   if (kSimpleExprSigTable[kExprI32Add] == 0) InitSigTable();
@@ -91,7 +86,6 @@ FunctionSig* WasmOpcodes::Signature(WasmOpcode opcode) {
       kSimpleExprSigs[kSimpleExprSigTable[static_cast<byte>(opcode)]]);
 }
 
-
 // TODO(titzer): pull WASM_64 up to a common header.
 #if !V8_TARGET_ARCH_32_BIT || V8_TARGET_ARCH_X64
 #define WASM_64 1

src/wasm/wasm-result.cc

@@ -28,7 +28,6 @@ std::ostream& operator<<(std::ostream& os, const ErrorCode& error_code) {
   return os;
 }
 
-
 void ErrorThrower::Error(const char* format, ...) {
   if (error_) return;  // only report the first error.
   error_ = true;

test/cctest/wasm/test-run-wasm-js.cc

@@ -25,14 +25,12 @@ using namespace v8::internal::wasm;
     r.Build(code, code + arraysize(code)); \
   } while (false)
 
-
 #define ADD_CODE(vec, ...)                                              \
   do {                                                                  \
     byte __buf[] = {__VA_ARGS__};                                       \
     for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
   } while (false)
 
-
 namespace {
 // A helper for generating predictable but unique argument values that
 // are easy to debug (e.g. with misaligned stacks).
@@ -48,7 +46,6 @@ class PredictableInputValues {
   }
 };
 
-
 uint32_t AddJSSelector(TestingModule* module, FunctionSig* sig, int which) {
   const int kMaxParams = 11;
   static const char* formals[kMaxParams] = {"",
@@ -73,7 +70,6 @@ uint32_t AddJSSelector(TestingModule* module, FunctionSig* sig, int which) {
   return module->AddJsFunction(sig, source.start());
 }
 
-
 void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc,
                  Handle<Object>* buffer, int count) {
   Isolate* isolate = jsfunc->GetIsolate();
@@ -91,7 +87,6 @@ void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc,
   }
 }
 
-
 void EXPECT_CALL(double expected, Handle<JSFunction> jsfunc, double a,
                  double b) {
   Isolate* isolate = jsfunc->GetIsolate();
@@ -112,7 +107,6 @@ TEST(Run_Int32Sub_jswrapped) {
   EXPECT_CALL(-8723487, jsfunc, -8000000, 723487);
 }
 
-
 TEST(Run_Float32Div_jswrapped) {
   TestSignatures sigs;
   TestingModule module;
@@ -124,7 +118,6 @@ TEST(Run_Float32Div_jswrapped) {
   EXPECT_CALL(64, jsfunc, -16, -0.25);
 }
 
-
 TEST(Run_Float64Add_jswrapped) {
   TestSignatures sigs;
   TestingModule module;
@@ -136,7 +129,6 @@ TEST(Run_Float64Add_jswrapped) {
   EXPECT_CALL(-5.5, jsfunc, -5.25, -0.25);
 }
 
-
 TEST(Run_I32Popcount_jswrapped) {
   TestSignatures sigs;
   TestingModule module;
@@ -149,7 +141,6 @@ TEST(Run_I32Popcount_jswrapped) {
   EXPECT_CALL(6, jsfunc, 0x3F, 0);
 }
 
-
 TEST(Run_CallJS_Add_jswrapped) {
   TestSignatures sigs;
   TestingModule module;
@@ -165,7 +156,6 @@ TEST(Run_CallJS_Add_jswrapped) {
   EXPECT_CALL(-666666801, jsfunc, -666666900, -1);
 }
 
-
 void RunJSSelectTest(int which) {
   const int kMaxParams = 8;
   PredictableInputValues inputs(0x100);
@@ -201,7 +191,6 @@ void RunJSSelectTest(int which) {
   }
 }
 
-
 TEST(Run_JSSelect_0) { RunJSSelectTest(0); }
 
 TEST(Run_JSSelect_1) { RunJSSelectTest(1); }
@@ -218,7 +207,6 @@ TEST(Run_JSSelect_6) { RunJSSelectTest(6); }
 
 TEST(Run_JSSelect_7) { RunJSSelectTest(7); }
 
-
 void RunWASMSelectTest(int which) {
   PredictableInputValues inputs(0x200);
   Isolate* isolate = CcTest::InitIsolateOnce();
@@ -250,7 +238,6 @@ void RunWASMSelectTest(int which) {
   }
 }
 
-
 TEST(Run_WASMSelect_0) { RunWASMSelectTest(0); }
 
 TEST(Run_WASMSelect_1) { RunWASMSelectTest(1); }
@@ -267,7 +254,6 @@ TEST(Run_WASMSelect_6) { RunWASMSelectTest(6); }
 
 TEST(Run_WASMSelect_7) { RunWASMSelectTest(7); }
 
-
 void RunWASMSelectAlignTest(int num_args, int num_params) {
   PredictableInputValues inputs(0x300);
   Isolate* isolate = CcTest::InitIsolateOnce();
@@ -301,31 +287,26 @@ void RunWASMSelectAlignTest(int num_args, int num_params) {
   }
 }
 
-
 TEST(Run_WASMSelectAlign_0) {
   RunWASMSelectAlignTest(0, 1);
   RunWASMSelectAlignTest(0, 2);
 }
 
-
 TEST(Run_WASMSelectAlign_1) {
   RunWASMSelectAlignTest(1, 2);
   RunWASMSelectAlignTest(1, 3);
 }
 
-
 TEST(Run_WASMSelectAlign_2) {
   RunWASMSelectAlignTest(2, 3);
   RunWASMSelectAlignTest(2, 4);
 }
 
-
 TEST(Run_WASMSelectAlign_3) {
   RunWASMSelectAlignTest(3, 3);
   RunWASMSelectAlignTest(3, 4);
 }
 
-
 TEST(Run_WASMSelectAlign_4) {
   RunWASMSelectAlignTest(4, 3);
   RunWASMSelectAlignTest(4, 4);
@@ -412,7 +393,6 @@ void RunJSSelectAlignTest(int num_args, int num_params) {
   }
 }
 
-
 TEST(Run_JSSelectAlign_0) {
   RunJSSelectAlignTest(0, 1);
   RunJSSelectAlignTest(0, 2);

test/cctest/wasm/test-run-wasm-module.cc

@@ -44,7 +44,6 @@ TEST(Run_WasmModule_Return114) {
   TestModule(writer->WriteTo(&zone), kReturnValue);
 }
 
-
 TEST(Run_WasmModule_CallAdd) {
   v8::base::AccountingAllocator allocator;
   Zone zone(&allocator);
@@ -66,7 +65,6 @@ TEST(Run_WasmModule_CallAdd) {
   TestModule(writer->WriteTo(&zone), 99);
 }
 
-
 TEST(Run_WasmModule_ReadLoadedDataSegment) {
   static const byte kDataSegmentDest0 = 12;
   v8::base::AccountingAllocator allocator;

test/cctest/wasm/test-run-wasm.cc

@@ -34,7 +34,6 @@ TEST(Run_WasmInt8Const) {
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
-
 TEST(Run_WasmInt8Const_fallthru1) {
   WasmRunner<int32_t> r;
   const byte kExpectedValue = 122;
@@ -43,7 +42,6 @@ TEST(Run_WasmInt8Const_fallthru1) {
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
-
 TEST(Run_WasmInt8Const_fallthru2) {
   WasmRunner<int32_t> r;
   const byte kExpectedValue = 123;
@@ -52,7 +50,6 @@ TEST(Run_WasmInt8Const_fallthru2) {
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
-
 TEST(Run_WasmInt8Const_all) {
   for (int value = -128; value <= 127; value++) {
     WasmRunner<int32_t> r;
@@ -63,7 +60,6 @@ TEST(Run_WasmInt8Const_all) {
   }
 }
 
-
 TEST(Run_WasmInt32Const) {
   WasmRunner<int32_t> r;
   const int32_t kExpectedValue = 0x11223344;
@@ -72,7 +68,6 @@ TEST(Run_WasmInt32Const) {
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
-
 TEST(Run_WasmInt32Const_many) {
   FOR_INT32_INPUTS(i) {
     WasmRunner<int32_t> r;
@@ -83,7 +78,6 @@ TEST(Run_WasmInt32Const_many) {
   }
 }
 
-
 TEST(Run_WasmMemorySize) {
   TestingModule module;
   WasmRunner<int32_t> r(&module);
@@ -92,7 +86,6 @@ TEST(Run_WasmMemorySize) {
   CHECK_EQ(1024, r.Call());
 }
 
-
 TEST(Run_WasmInt32Param0) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // return(local[0])
@@ -100,7 +93,6 @@ TEST(Run_WasmInt32Param0) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
-
 TEST(Run_WasmInt32Param0_fallthru) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // local[0]
@@ -108,7 +100,6 @@ TEST(Run_WasmInt32Param0_fallthru) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
-
 TEST(Run_WasmInt32Param1) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
   // local[1]
@@ -116,7 +107,6 @@ TEST(Run_WasmInt32Param1) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(-111, *i)); }
 }
 
-
 TEST(Run_WasmInt32Add) {
   WasmRunner<int32_t> r;
   // 11 + 44
@@ -124,7 +114,6 @@ TEST(Run_WasmInt32Add) {
   CHECK_EQ(55, r.Call());
 }
 
-
 TEST(Run_WasmInt32Add_P) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // p0 + 13
@@ -132,7 +121,6 @@ TEST(Run_WasmInt32Add_P) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
 }
 
-
 TEST(Run_WasmInt32Add_P_fallthru) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // p0 + 13
@@ -140,7 +128,6 @@ TEST(Run_WasmInt32Add_P_fallthru) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i + 13, r.Call(*i)); }
 }
 
-
 TEST(Run_WasmInt32Add_P2) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
   //  p0 + p1
@@ -154,7 +141,6 @@ TEST(Run_WasmInt32Add_P2) {
   }
 }
 
-
 TEST(Run_WasmFloat32Add) {
   WasmRunner<int32_t> r;
   // int(11.5f + 44.5f)
@@ -163,7 +149,6 @@ TEST(Run_WasmFloat32Add) {
   CHECK_EQ(56, r.Call());
 }
 
-
 TEST(Run_WasmFloat64Add) {
   WasmRunner<int32_t> r;
   // return int(13.5d + 43.5d)
@@ -171,7 +156,6 @@ TEST(Run_WasmFloat64Add) {
   CHECK_EQ(57, r.Call());
 }
 
-
 void TestInt32Binop(WasmOpcode opcode, int32_t expected, int32_t a, int32_t b) {
   {
     WasmRunner<int32_t> r;
@@ -219,7 +203,6 @@ TEST(Run_WasmInt32Binops) {
   TestInt32Binop(kExprI32GeU, 1, 0xF0000000, 98978);
 }
 
-
 void TestInt32Unop(WasmOpcode opcode, int32_t expected, int32_t a) {
   {
     WasmRunner<int32_t> r;
@@ -235,7 +218,6 @@ void TestInt32Unop(WasmOpcode opcode, int32_t expected, int32_t a) {
   }
 }
 
-
 TEST(Run_WasmInt32Clz) {
   TestInt32Unop(kExprI32Clz, 0, 0x80001000);
   TestInt32Unop(kExprI32Clz, 1, 0x40000500);
@@ -272,7 +254,6 @@ TEST(Run_WasmInt32Clz) {
   TestInt32Unop(kExprI32Clz, 32, 0x00000000);
 }
 
-
 TEST(Run_WasmInt32Ctz) {
   TestInt32Unop(kExprI32Ctz, 32, 0x00000000);
   TestInt32Unop(kExprI32Ctz, 31, 0x80000000);
@@ -309,7 +290,6 @@ TEST(Run_WasmInt32Ctz) {
   TestInt32Unop(kExprI32Ctz, 0, 0x9afdbc81);
 }
 
-
 TEST(Run_WasmInt32Popcnt) {
   TestInt32Unop(kExprI32Popcnt, 32, 0xffffffff);
   TestInt32Unop(kExprI32Popcnt, 0, 0x00000000);
@@ -373,7 +353,6 @@ TEST(Run_WASM_Int32DivS_trap) {
   CHECK_TRAP(r.Call(kMin, 0));
 }
 
-
 TEST(Run_WASM_Int32RemS_trap) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -385,7 +364,6 @@ TEST(Run_WASM_Int32RemS_trap) {
   CHECK_TRAP(r.Call(kMin, 0));
 }
 
-
 TEST(Run_WASM_Int32DivU_trap) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
   BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -397,7 +375,6 @@ TEST(Run_WASM_Int32DivU_trap) {
   CHECK_TRAP(r.Call(kMin, 0));
 }
 
-
 TEST(Run_WASM_Int32RemU_trap) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
   BUILD(r, WASM_I32_REMU(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -423,7 +400,6 @@ TEST(Run_WASM_Int32DivS_byzero_const) {
   }
 }
 
-
 TEST(Run_WASM_Int32DivU_byzero_const) {
   for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
     WasmRunner<uint32_t> r(MachineType::Uint32());
@@ -439,7 +415,6 @@ TEST(Run_WASM_Int32DivU_byzero_const) {
   }
 }
 
-
 TEST(Run_WASM_Int32DivS_trap_effect) {
   TestingModule module;
   module.AddMemoryElems<int32_t>(8);
@@ -474,7 +449,6 @@ void TestFloat32Binop(WasmOpcode opcode, int32_t expected, float a, float b) {
   }
 }
 
-
 void TestFloat32BinopWithConvert(WasmOpcode opcode, int32_t expected, float a,
                                  float b) {
   {
@@ -493,7 +467,6 @@ void TestFloat32BinopWithConvert(WasmOpcode opcode, int32_t expected, float a,
   }
 }
 
-
 void TestFloat32UnopWithConvert(WasmOpcode opcode, int32_t expected, float a) {
   {
     WasmRunner<int32_t> r;
@@ -509,7 +482,6 @@ void TestFloat32UnopWithConvert(WasmOpcode opcode, int32_t expected, float a) {
   }
 }
 
-
 void TestFloat64Binop(WasmOpcode opcode, int32_t expected, double a, double b) {
   {
     WasmRunner<int32_t> r;
@@ -525,7 +497,6 @@ void TestFloat64Binop(WasmOpcode opcode, int32_t expected, double a, double b) {
   }
 }
 
-
 void TestFloat64BinopWithConvert(WasmOpcode opcode, int32_t expected, double a,
                                  double b) {
   {
@@ -543,7 +514,6 @@ void TestFloat64BinopWithConvert(WasmOpcode opcode, int32_t expected, double a,
   }
 }
 
-
 void TestFloat64UnopWithConvert(WasmOpcode opcode, int32_t expected, double a) {
   {
     WasmRunner<int32_t> r;
@@ -611,7 +581,6 @@ TEST(Run_WasmFloat32Neg) {
   }
 }
 
-
 TEST(Run_WasmFloat64Neg) {
   WasmRunner<double> r(MachineType::Float64());
   BUILD(r, WASM_F64_NEG(WASM_GET_LOCAL(0)));
@@ -622,7 +591,6 @@ TEST(Run_WasmFloat64Neg) {
   }
 }
 
-
 TEST(Run_Wasm_IfElse_P) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // if (p0) return 11; else return 22;
@@ -690,7 +658,6 @@ TEST(Run_Wasm_IfElse_Unreachable1) {
   CHECK_EQ(27, r.Call());
 }
 
-
 TEST(Run_Wasm_Return12) {
   WasmRunner<int32_t> r;
 
@@ -698,7 +665,6 @@ TEST(Run_Wasm_Return12) {
   CHECK_EQ(12, r.Call());
 }
 
-
 TEST(Run_Wasm_Return17) {
   WasmRunner<int32_t> r;
 
@@ -706,7 +672,6 @@ TEST(Run_Wasm_Return17) {
   CHECK_EQ(17, r.Call());
 }
 
-
 TEST(Run_Wasm_Return_I32) {
   WasmRunner<int32_t> r(MachineType::Int32());
 
@@ -715,7 +680,6 @@ TEST(Run_Wasm_Return_I32) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
-
 TEST(Run_Wasm_Return_F32) {
   WasmRunner<float> r(MachineType::Float32());
 
@@ -732,7 +696,6 @@ TEST(Run_Wasm_Return_F32) {
   }
 }
 
-
 TEST(Run_Wasm_Return_F64) {
   WasmRunner<double> r(MachineType::Float64());
 
@@ -749,7 +712,6 @@ TEST(Run_Wasm_Return_F64) {
   }
 }
 
-
 TEST(Run_Wasm_Select) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // return select(11, 22, a);
@@ -760,7 +722,6 @@ TEST(Run_Wasm_Select) {
   }
 }
 
-
 TEST(Run_Wasm_Select_strict1) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // select(a=0, a=1, a=2); return a
@@ -771,7 +732,6 @@ TEST(Run_Wasm_Select_strict1) {
   FOR_INT32_INPUTS(i) { CHECK_EQ(2, r.Call(*i)); }
 }
 
-
 TEST(Run_Wasm_Select_strict2) {
   WasmRunner<int32_t> r(MachineType::Int32());
   r.AllocateLocal(kAstI32);
@@ -799,7 +759,6 @@ TEST(Run_Wasm_Select_strict3) {
   }
 }
 
-
 TEST(Run_Wasm_BrIf_strict) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(
@@ -988,7 +947,6 @@ TEST(Run_Wasm_F32ReinterpretI32) {
   }
 }
 
-
 TEST(Run_Wasm_I32ReinterpretF32) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(8);
@@ -1006,7 +964,6 @@ TEST(Run_Wasm_I32ReinterpretF32) {
   }
 }
 
-
 TEST(Run_Wasm_ReturnStore) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(8);
@@ -1022,7 +979,6 @@ TEST(Run_Wasm_ReturnStore) {
   }
 }
 
-
 TEST(Run_Wasm_VoidReturn1) {
   // We use a wrapper function because WasmRunner<void> does not exist.
 
@@ -1042,7 +998,6 @@ TEST(Run_Wasm_VoidReturn1) {
   CHECK_EQ(kExpected, result);
 }
 
-
 TEST(Run_Wasm_VoidReturn2) {
   // We use a wrapper function because WasmRunner<void> does not exist.
   // Build the test function.
@@ -1137,7 +1092,6 @@ TEST(Run_Wasm_Block_BrIf_P) {
   }
 }
 
-
 TEST(Run_Wasm_Block_IfElse_P_assign) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // { if (p0) p0 = 71; else p0 = 72; return p0; }
@@ -1152,7 +1106,6 @@ TEST(Run_Wasm_Block_IfElse_P_assign) {
   }
 }
 
-
 TEST(Run_Wasm_Block_IfElse_P_return) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // if (p0) return 81; else return 82;
@@ -1166,7 +1119,6 @@ TEST(Run_Wasm_Block_IfElse_P_return) {
   }
 }
 
-
 TEST(Run_Wasm_Block_If_P_assign) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // { if (p0) p0 = 61; p0; }
@@ -1179,7 +1131,6 @@ TEST(Run_Wasm_Block_If_P_assign) {
   }
 }
 
-
 TEST(Run_Wasm_DanglingAssign) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // { return 0; p0 = 0; }
@@ -1187,7 +1138,6 @@ TEST(Run_Wasm_DanglingAssign) {
   CHECK_EQ(99, r.Call(1));
 }
 
-
 TEST(Run_Wasm_ExprIf_P) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // p0 ? 11 : 22;
@@ -1200,7 +1150,6 @@ TEST(Run_Wasm_ExprIf_P) {
   }
 }
 
-
 TEST(Run_Wasm_ExprIf_P_fallthru) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // p0 ? 11 : 22;
@@ -1213,7 +1162,6 @@ TEST(Run_Wasm_ExprIf_P_fallthru) {
   }
 }
 
-
 TEST(Run_Wasm_CountDown) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r,
@@ -1229,7 +1177,6 @@ TEST(Run_Wasm_CountDown) {
   CHECK_EQ(0, r.Call(100));
 }
 
-
 TEST(Run_Wasm_CountDown_fallthru) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r,
@@ -1244,7 +1191,6 @@ TEST(Run_Wasm_CountDown_fallthru) {
   CHECK_EQ(0, r.Call(100));
 }
 
-
 TEST(Run_Wasm_WhileCountDown) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_BLOCK(
@@ -1257,7 +1203,6 @@ TEST(Run_Wasm_WhileCountDown) {
   CHECK_EQ(0, r.Call(100));
 }
 
-
 TEST(Run_Wasm_Loop_if_break1) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
@@ -1269,7 +1214,6 @@ TEST(Run_Wasm_Loop_if_break1) {
   CHECK_EQ(-29, r.Call(-29));
 }
 
-
 TEST(Run_Wasm_Loop_if_break2) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_LOOP(2, WASM_BR_IF(1, WASM_GET_LOCAL(0)),
@@ -1281,7 +1225,6 @@ TEST(Run_Wasm_Loop_if_break2) {
   CHECK_EQ(-29, r.Call(-29));
 }
 
-
 TEST(Run_Wasm_Loop_if_break_fallthru) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B1(WASM_LOOP(2, WASM_IF(WASM_GET_LOCAL(0), WASM_BREAK(1)),
@@ -1329,7 +1272,6 @@ TEST(Run_Wasm_LoadMemI32) {
   CHECK_EQ(77777777, r.Call(0));
 }
 
-
 TEST(Run_Wasm_LoadMemI32_oob) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(8);
@@ -1349,7 +1291,6 @@ TEST(Run_Wasm_LoadMemI32_oob) {
   }
 }
 
-
 TEST(Run_Wasm_LoadMem_offset_oob) {
   TestingModule module;
   module.AddMemoryElems<int32_t>(8);
@@ -1376,7 +1317,6 @@ TEST(Run_Wasm_LoadMem_offset_oob) {
   }
 }
 
-
 TEST(Run_Wasm_LoadMemI32_offset) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
@@ -1402,7 +1342,6 @@ TEST(Run_Wasm_LoadMemI32_offset) {
   CHECK_EQ(44444444, r.Call(8));
 }
 
-
 #if !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64
 
 TEST(Run_Wasm_LoadMemI32_const_oob_misaligned) {
@@ -1430,7 +1369,6 @@ TEST(Run_Wasm_LoadMemI32_const_oob_misaligned) {
 
 #endif
 
-
 TEST(Run_Wasm_LoadMemI32_const_oob) {
   const int kMemSize = 24;
   for (int offset = 0; offset < kMemSize + 5; offset += 4) {
@@ -1453,7 +1391,6 @@ TEST(Run_Wasm_LoadMemI32_const_oob) {
   }
 }
 
-
 TEST(Run_Wasm_StoreMemI32_offset) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
@@ -1477,7 +1414,6 @@ TEST(Run_Wasm_StoreMemI32_offset) {
   }
 }
 
-
 TEST(Run_Wasm_StoreMem_offset_oob) {
   TestingModule module;
   byte* memory = module.AddMemoryElems<byte>(32);
@@ -1514,7 +1450,6 @@ TEST(Run_Wasm_StoreMem_offset_oob) {
   }
 }
 
-
 TEST(Run_Wasm_LoadMemI32_P) {
   const int kNumElems = 8;
   TestingModule module;
@@ -1529,7 +1464,6 @@ TEST(Run_Wasm_LoadMemI32_P) {
   }
 }
 
-
 TEST(Run_Wasm_MemI32_Sum) {
   const int kNumElems = 20;
   TestingModule module;
@@ -1562,7 +1496,6 @@ TEST(Run_Wasm_MemI32_Sum) {
   }
 }
 
-
 TEST(Run_Wasm_CheckMachIntsZero) {
   const int kNumElems = 55;
   TestingModule module;
@@ -1578,7 +1511,6 @@ TEST(Run_Wasm_CheckMachIntsZero) {
   CHECK_EQ(0, r.Call((kNumElems - 1) * 4));
 }
 
-
 TEST(Run_Wasm_MemF32_Sum) {
   const int kSize = 5;
   TestingModule module;
@@ -1612,7 +1544,6 @@ TEST(Run_Wasm_MemF32_Sum) {
   CHECK_EQ(71256.0f, buffer[0]);
 }
 
-
 template <typename T>
 T GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
                      LocalType astType, MachineType memType) {
@@ -1643,7 +1574,6 @@ T GenerateAndRunFold(WasmOpcode binop, T* buffer, size_t size,
   return module.raw_mem_at<double>(0);
 }
 
-
 TEST(Run_Wasm_MemF64_Mul) {
   const size_t kSize = 6;
   double buffer[kSize] = {1, 2, 2, 2, 2, 2};
@@ -1652,14 +1582,12 @@ TEST(Run_Wasm_MemF64_Mul) {
   CHECK_EQ(32, result);
 }
 
-
 TEST(Build_Wasm_Infinite_Loop) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // Only build the graph and compile, don't run.
   BUILD(r, WASM_INFINITE_LOOP);
 }
 
-
 TEST(Build_Wasm_Infinite_Loop_effect) {
   TestingModule module;
   module.AddMemoryElems<int8_t>(16);
@@ -1669,7 +1597,6 @@ TEST(Build_Wasm_Infinite_Loop_effect) {
   BUILD(r, WASM_LOOP(1, WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)));
 }
 
-
 TEST(Run_Wasm_Unreachable0a) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_BRV(0, WASM_I8(9)), RET(WASM_GET_LOCAL(0))));
@@ -1677,7 +1604,6 @@ TEST(Run_Wasm_Unreachable0a) {
   CHECK_EQ(9, r.Call(1));
 }
 
-
 TEST(Run_Wasm_Unreachable0b) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_BRV(0, WASM_I8(7)), WASM_UNREACHABLE));
@@ -1685,38 +1611,32 @@ TEST(Run_Wasm_Unreachable0b) {
   CHECK_EQ(7, r.Call(1));
 }
 
-
 TEST(Build_Wasm_Unreachable1) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_UNREACHABLE);
 }
 
-
 TEST(Build_Wasm_Unreachable2) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE);
 }
 
-
 TEST(Build_Wasm_Unreachable3) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_UNREACHABLE, WASM_UNREACHABLE, WASM_UNREACHABLE);
 }
 
-
 TEST(Build_Wasm_UnreachableIf1) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_UNREACHABLE, WASM_IF(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0)));
 }
 
-
 TEST(Build_Wasm_UnreachableIf2) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_UNREACHABLE,
         WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_GET_LOCAL(0), WASM_UNREACHABLE));
 }
 
-
 TEST(Run_Wasm_Unreachable_Load) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_BRV(0, WASM_GET_LOCAL(0)),
@@ -1725,7 +1645,6 @@ TEST(Run_Wasm_Unreachable_Load) {
   CHECK_EQ(21, r.Call(21));
 }
 
-
 TEST(Run_Wasm_Infinite_Loop_not_taken1) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_INFINITE_LOOP), WASM_I8(45)));
@@ -1733,7 +1652,6 @@ TEST(Run_Wasm_Infinite_Loop_not_taken1) {
   CHECK_EQ(45, r.Call(0));
 }
 
-
 TEST(Run_Wasm_Infinite_Loop_not_taken2) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B1(WASM_IF_ELSE(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(45)),
@@ -1742,7 +1660,6 @@ TEST(Run_Wasm_Infinite_Loop_not_taken2) {
   CHECK_EQ(45, r.Call(1));
 }
 
-
 TEST(Run_Wasm_Infinite_Loop_not_taken2_brif) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r,
@@ -1751,7 +1668,6 @@ TEST(Run_Wasm_Infinite_Loop_not_taken2_brif) {
   CHECK_EQ(45, r.Call(1));
 }
 
-
 static void TestBuildGraphForSimpleExpression(WasmOpcode opcode) {
   Isolate* isolate = CcTest::InitIsolateOnce();
   Zone zone(isolate->allocator());
@@ -1777,7 +1693,6 @@ static void TestBuildGraphForSimpleExpression(WasmOpcode opcode) {
   }
 }
 
-
 TEST(Build_Wasm_SimpleExprs) {
 // Test that the decoder can build a graph for all supported simple expressions.
 #define GRAPH_BUILD_TEST(name, opcode, sig) \
@@ -1788,7 +1703,6 @@ TEST(Build_Wasm_SimpleExprs) {
 #undef GRAPH_BUILD_TEST
 }
 
-
 TEST(Run_Wasm_Int32LoadInt8_signext) {
   TestingModule module;
   const int kNumElems = 16;
@@ -1803,7 +1717,6 @@ TEST(Run_Wasm_Int32LoadInt8_signext) {
   }
 }
 
-
 TEST(Run_Wasm_Int32LoadInt8_zeroext) {
   TestingModule module;
   const int kNumElems = 16;
@@ -1818,7 +1731,6 @@ TEST(Run_Wasm_Int32LoadInt8_zeroext) {
   }
 }
 
-
 TEST(Run_Wasm_Int32LoadInt16_signext) {
   TestingModule module;
   const int kNumBytes = 16;
@@ -1834,7 +1746,6 @@ TEST(Run_Wasm_Int32LoadInt16_signext) {
   }
 }
 
-
 TEST(Run_Wasm_Int32LoadInt16_zeroext) {
   TestingModule module;
   const int kNumBytes = 16;
@@ -1850,7 +1761,6 @@ TEST(Run_Wasm_Int32LoadInt16_zeroext) {
   }
 }
 
-
 TEST(Run_WasmInt32Global) {
   TestingModule module;
   int32_t* global = module.AddGlobal<int32_t>(MachineType::Int32());
@@ -1867,7 +1777,6 @@ TEST(Run_WasmInt32Global) {
   }
 }
 
-
 TEST(Run_WasmInt32Globals_DontAlias) {
   const int kNumGlobals = 3;
   TestingModule module;
@@ -1896,7 +1805,6 @@ TEST(Run_WasmInt32Globals_DontAlias) {
   }
 }
 
-
 TEST(Run_WasmFloat32Global) {
   TestingModule module;
   float* global = module.AddGlobal<float>(MachineType::Float32());
@@ -1915,7 +1823,6 @@ TEST(Run_WasmFloat32Global) {
   }
 }
 
-
 TEST(Run_WasmFloat64Global) {
   TestingModule module;
   double* global = module.AddGlobal<double>(MachineType::Float64());
@@ -1934,7 +1841,6 @@ TEST(Run_WasmFloat64Global) {
   }
 }
 
-
 TEST(Run_WasmMixedGlobals) {
   TestingModule module;
   int32_t* unused = module.AddGlobal<int32_t>(MachineType::Int32());
@@ -1989,7 +1895,6 @@ TEST(Run_WasmMixedGlobals) {
   USE(unused);
 }
 
-
 TEST(Run_WasmCallEmpty) {
   const int32_t kExpected = -414444;
   // Build the target function.
@@ -2007,7 +1912,6 @@ TEST(Run_WasmCallEmpty) {
   CHECK_EQ(kExpected, result);
 }
 
-
 TEST(Run_WasmCallF32StackParameter) {
   // Build the target function.
   LocalType param_types[20];
@@ -2032,7 +1936,6 @@ TEST(Run_WasmCallF32StackParameter) {
   CHECK_EQ(256.5f, result);
 }
 
-
 TEST(Run_WasmCallF64StackParameter) {
   // Build the target function.
   LocalType param_types[20];
@@ -2081,7 +1984,6 @@ TEST(Run_WasmCallVoid) {
   CHECK_EQ(kExpected, module.raw_mem_start<int32_t>()[kElemNum]);
 }
 
-
 TEST(Run_WasmCall_Int32Add) {
   // Build the target function.
   TestSignatures sigs;
@@ -2121,7 +2023,6 @@ TEST(Run_WasmCall_Float32Sub) {
   }
 }
 
-
 TEST(Run_WasmCall_Float64Sub) {
   TestingModule module;
   double* memory = module.AddMemoryElems<double>(16);
@@ -2156,7 +2057,6 @@ TEST(Run_WasmCall_Float64Sub) {
     for (size_t i = 0; i < sizeof(__buf); i++) vec.push_back(__buf[i]); \
   } while (false)
 
-
 static void Run_WasmMixedCall_N(int start) {
   const int kExpected = 6333;
   const int kElemSize = 8;
@@ -2244,7 +2144,6 @@ static void Run_WasmMixedCall_N(int start) {
   }
 }
 
-
 TEST(Run_WasmMixedCall_0) { Run_WasmMixedCall_N(0); }
 TEST(Run_WasmMixedCall_1) { Run_WasmMixedCall_N(1); }
 TEST(Run_WasmMixedCall_2) { Run_WasmMixedCall_N(2); }
@@ -2283,7 +2182,6 @@ TEST(Run_Wasm_CountDown_expr) {
   CHECK_EQ(0, r.Call(100));
 }
 
-
 TEST(Run_Wasm_ExprBlock2a) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))), WASM_I8(1)));
@@ -2291,7 +2189,6 @@ TEST(Run_Wasm_ExprBlock2a) {
   CHECK_EQ(1, r.Call(1));
 }
 
-
 TEST(Run_Wasm_ExprBlock2b) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_IF(WASM_GET_LOCAL(0), WASM_BRV(1, WASM_I8(1))), WASM_I8(2)));
@@ -2299,7 +2196,6 @@ TEST(Run_Wasm_ExprBlock2b) {
   CHECK_EQ(1, r.Call(1));
 }
 
-
 TEST(Run_Wasm_ExprBlock2c) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(1), WASM_GET_LOCAL(0)), WASM_I8(1)));
@@ -2307,7 +2203,6 @@ TEST(Run_Wasm_ExprBlock2c) {
   CHECK_EQ(1, r.Call(1));
 }
 
-
 TEST(Run_Wasm_ExprBlock2d) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, B2(WASM_BRV_IF(0, WASM_I8(1), WASM_GET_LOCAL(0)), WASM_I8(2)));
@@ -2315,7 +2210,6 @@ TEST(Run_Wasm_ExprBlock2d) {
   CHECK_EQ(1, r.Call(1));
 }
 
-
 TEST(Run_Wasm_ExprBlock_ManualSwitch) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r, WASM_BLOCK(6, WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(0), WASM_I8(1)),
@@ -2338,7 +2232,6 @@ TEST(Run_Wasm_ExprBlock_ManualSwitch) {
   CHECK_EQ(99, r.Call(6));
 }
 
-
 TEST(Run_Wasm_ExprBlock_ManualSwitch_brif) {
   WasmRunner<int32_t> r(MachineType::Int32());
   BUILD(r,
@@ -2362,7 +2255,6 @@ TEST(Run_Wasm_ExprBlock_ManualSwitch_brif) {
   CHECK_EQ(99, r.Call(6));
 }
 
-
 TEST(Run_Wasm_nested_ifs) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
 
@@ -2371,14 +2263,12 @@ TEST(Run_Wasm_nested_ifs) {
                WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_I8(11), WASM_I8(12)),
                WASM_IF_ELSE(WASM_GET_LOCAL(1), WASM_I8(13), WASM_I8(14))));
 
-
   CHECK_EQ(11, r.Call(1, 1));
   CHECK_EQ(12, r.Call(1, 0));
   CHECK_EQ(13, r.Call(0, 1));
   CHECK_EQ(14, r.Call(0, 0));
 }
 
-
 TEST(Run_Wasm_ExprBlock_if) {
   WasmRunner<int32_t> r(MachineType::Int32());
 
@@ -2389,7 +2279,6 @@ TEST(Run_Wasm_ExprBlock_if) {
   CHECK_EQ(14, r.Call(0));
 }
 
-
 TEST(Run_Wasm_ExprBlock_nested_ifs) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
 
@@ -2407,7 +2296,6 @@ TEST(Run_Wasm_ExprBlock_nested_ifs) {
   CHECK_EQ(14, r.Call(0, 0));
 }
 
-
 TEST(Run_Wasm_ExprLoop_nested_ifs) {
   WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
 
@@ -2456,7 +2344,6 @@ TEST(Run_Wasm_SimpleCallIndirect) {
   CHECK_TRAP(r.Call(2));
 }
 
-
 TEST(Run_Wasm_MultipleCallIndirect) {
   TestSignatures sigs;
   TestingModule module;
@@ -2600,7 +2487,6 @@ TEST(Run_Wasm_F32Min) {
   }
 }
 
-
 TEST(Run_Wasm_F64Min) {
   WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
   BUILD(r, WASM_F64_MIN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2624,7 +2510,6 @@ TEST(Run_Wasm_F64Min) {
   }
 }
 
-
 TEST(Run_Wasm_F32Max) {
   WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
   BUILD(r, WASM_F32_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2648,7 +2533,6 @@ TEST(Run_Wasm_F32Max) {
   }
 }
 
-
 TEST(Run_Wasm_F64Max) {
   WasmRunner<double> r(MachineType::Float64(), MachineType::Float64());
   BUILD(r, WASM_F64_MAX(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2755,7 +2639,6 @@ TEST(Run_Wasm_I32SConvertF32) {
   }
 }
 
-
 TEST(Run_Wasm_I32SConvertF64) {
   WasmRunner<int32_t> r(MachineType::Float64());
   BUILD(r, WASM_I32_SCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -2770,7 +2653,6 @@ TEST(Run_Wasm_I32SConvertF64) {
   }
 }
 
-
 TEST(Run_Wasm_I32UConvertF32) {
   WasmRunner<uint32_t> r(MachineType::Float32());
   BUILD(r, WASM_I32_UCONVERT_F32(WASM_GET_LOCAL(0)));
@@ -2784,7 +2666,6 @@ TEST(Run_Wasm_I32UConvertF32) {
   }
 }
 
-
 TEST(Run_Wasm_I32UConvertF64) {
   WasmRunner<uint32_t> r(MachineType::Float64());
   BUILD(r, WASM_I32_UCONVERT_F64(WASM_GET_LOCAL(0)));
@@ -2807,7 +2688,6 @@ TEST(Run_Wasm_F64CopySign) {
   }
 }
 
-
 TEST(Run_Wasm_F32CopySign) {
   WasmRunner<float> r(MachineType::Float32(), MachineType::Float32());
   BUILD(r, WASM_F32_COPYSIGN(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
@@ -2846,18 +2726,14 @@ void CompileCallIndirectMany(LocalType param) {
   }
 }
 
-
 TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kAstI32); }
 
-
 #if WASM_64
 TEST(Compile_Wasm_CallIndirect_Many_i64) { CompileCallIndirectMany(kAstI64); }
 #endif
 
-
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
 
-
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }
 
 TEST(Run_WASM_Int32RemS_dead) {

test/unittests/wasm/ast-decoder-unittest.cc

@@ -52,7 +52,6 @@ static const WasmOpcode kInt32BinopOpcodes[] = {
     Verify(kSuccess, env, code, code + arraysize(code)); \
   } while (false)
 
-
 #define EXPECT_FAILURE_INLINE(env, ...)                \
   do {                                                 \
     static byte code[] = {__VA_ARGS__};                \
@@ -1150,7 +1149,6 @@ TEST_F(AstDecoderTest, AllStoreMemCombinations) {
   }
 }
 
-
 namespace {
 // A helper for tests that require a module environment for functions and
 // globals.
@@ -1862,7 +1860,6 @@ TEST_F(AstDecoderTest, Select_TypeCheck) {
       WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64V_1(0)));
 }
 
-
 class WasmOpcodeLengthTest : public TestWithZone {
  public:
   WasmOpcodeLengthTest() : TestWithZone() {}
@@ -1892,7 +1889,6 @@ TEST_F(WasmOpcodeLengthTest, Statements) {
   EXPECT_LENGTH(3, kExprBrIf);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscExpressions) {
   EXPECT_LENGTH(2, kExprI8Const);
   EXPECT_LENGTH(5, kExprF32Const);
@@ -1966,13 +1962,11 @@ TEST_F(WasmOpcodeLengthTest, LoadsAndStores) {
   EXPECT_LENGTH(3, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) {
   EXPECT_LENGTH(1, kExprMemorySize);
   EXPECT_LENGTH(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {
   EXPECT_LENGTH(1, kExprI32Add);
   EXPECT_LENGTH(1, kExprI32Sub);
@@ -2094,7 +2088,6 @@ TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {
   EXPECT_LENGTH(1, kExprI64ReinterpretF64);
 }
 
-
 class WasmOpcodeArityTest : public TestWithZone {
  public:
   WasmOpcodeArityTest() : TestWithZone() {}
@@ -2137,7 +2130,6 @@ TEST_F(WasmOpcodeArityTest, Control) {
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, Misc) {
   EXPECT_ARITY(0, kExprI8Const);
   EXPECT_ARITY(0, kExprI32Const);
@@ -2150,7 +2142,6 @@ TEST_F(WasmOpcodeArityTest, Misc) {
   EXPECT_ARITY(1, kExprStoreGlobal);
 }
 
-
 TEST_F(WasmOpcodeArityTest, Calls) {
   {
     EXPECT_ARITY(2, kExprCallFunction, 2, 0);
@@ -2181,7 +2172,6 @@ TEST_F(WasmOpcodeArityTest, Calls) {
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, LoadsAndStores) {
   EXPECT_ARITY(1, kExprI32LoadMem8S);
   EXPECT_ARITY(1, kExprI32LoadMem8U);
@@ -2210,13 +2200,11 @@ TEST_F(WasmOpcodeArityTest, LoadsAndStores) {
   EXPECT_ARITY(2, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeArityTest, MiscMemExpressions) {
   EXPECT_ARITY(0, kExprMemorySize);
   EXPECT_ARITY(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeArityTest, SimpleExpressions) {
   EXPECT_ARITY(2, kExprI32Add);
   EXPECT_ARITY(2, kExprI32Sub);

test/unittests/wasm/encoder-unittest.cc

@@ -21,7 +21,6 @@ class EncoderTest : public TestWithZone {
   }
 };
 
-
 TEST_F(EncoderTest, Function_Builder_Variable_Indexing) {
   base::AccountingAllocator allocator;
   Zone zone(&allocator);
@@ -60,7 +59,6 @@ TEST_F(EncoderTest, Function_Builder_Variable_Indexing) {
   f->Serialize(buffer, &header, &body);
 }
 
-
 TEST_F(EncoderTest, Function_Builder_Indexing_Variable_Width) {
   base::AccountingAllocator allocator;
   Zone zone(&allocator);

test/unittests/wasm/loop-assignment-analysis-unittest.cc

@@ -32,14 +32,12 @@ class WasmLoopAssignmentAnalyzerTest : public TestWithZone {
   }
 };
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Empty0) {
   byte code[] = { 0 };
   BitVector* assigned = Analyze(code, code);
   CHECK_NULL(assigned);
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Empty1) {
   byte code[] = {kExprLoop, 0};
   for (int i = 0; i < 5; i++) {
@@ -51,7 +49,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, Empty1) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, One) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -63,7 +60,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, One) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, OneBeyond) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -75,7 +71,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, OneBeyond) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Two) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -90,7 +85,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, Two) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, NestedIf) {
   num_locals = 5;
   for (int i = 0; i < 5; i++) {
@@ -104,14 +98,12 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, NestedIf) {
   }
 }
 
-
 static byte LEBByte(uint32_t val, byte which) {
   byte b = (val >> (which * 7)) & 0x7F;
   if (val >> ((which + 1) * 7)) b |= 0x80;
   return b;
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, BigLocal) {
   num_locals = 65000;
   for (int i = 13; i < 65000; i = static_cast<int>(i * 1.5)) {
@@ -133,7 +125,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, BigLocal) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Break) {
   num_locals = 3;
   byte code[] = {
@@ -147,7 +138,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, Break) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Loop1) {
   num_locals = 5;
   byte code[] = {
@@ -164,7 +154,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, Loop1) {
   }
 }
 
-
 TEST_F(WasmLoopAssignmentAnalyzerTest, Loop2) {
   num_locals = 6;
   const byte kIter = 0;
@@ -191,7 +180,6 @@ TEST_F(WasmLoopAssignmentAnalyzerTest, Loop2) {
   }
 }
 
-
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8

test/unittests/wasm/module-decoder-unittest.cc

@@ -169,7 +169,6 @@ TEST_F(WasmModuleVerifyTest, OneGlobal) {
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   static const byte data[] = {
       SECTION(GLOBALS, 1),  // --
@@ -180,7 +179,6 @@ TEST_F(WasmModuleVerifyTest, ZeroGlobals) {
   if (result.val) delete result.val;
 }
 
-
 static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
   while (true) {
     uint32_t next = val >> 7;
@@ -195,7 +193,6 @@ static void AppendUint32v(std::vector<byte>& buffer, uint32_t val) {
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, NGlobals) {
   static const byte data[] = {
       NO_NAME,  // name length
@@ -245,7 +242,6 @@ TEST_F(WasmModuleVerifyTest, GlobalWithInvalidMemoryType) {
   EXPECT_FAILURE(data);
 }
 
-
 TEST_F(WasmModuleVerifyTest, TwoGlobals) {
   static const byte data[] = {
       SECTION(GLOBALS, 7),
@@ -285,7 +281,6 @@ TEST_F(WasmModuleVerifyTest, TwoGlobals) {
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneSignature) {
   {
     static const byte data[] = {SIGNATURES_SECTION_VOID_VOID};
@@ -299,7 +294,6 @@ TEST_F(WasmModuleVerifyTest, OneSignature) {
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, MultipleSignatures) {
   static const byte data[] = {
       SECTION(SIGNATURES, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_x_x +
@@ -327,7 +321,6 @@ TEST_F(WasmModuleVerifyTest, MultipleSignatures) {
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
   static const byte data[] = {
       SECTION(OLD_FUNCTIONS, 25), 1,
@@ -349,7 +342,6 @@ TEST_F(WasmModuleVerifyTest, FunctionWithoutSig) {
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
   const int kCodeStartOffset = 49;
   const int kCodeEndOffset = kCodeStartOffset + 1;
@@ -401,7 +393,6 @@ TEST_F(WasmModuleVerifyTest, OneEmptyVoidVoidFunction) {
   EXPECT_OFF_END_FAILURE(data, 16, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneFunctionImported) {
   static const byte data[] = {
       // signatures
@@ -467,7 +458,6 @@ TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody) {
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody_WithLocals) {
   static const byte kCodeStartOffset = 46;
   static const byte kCodeEndOffset = kCodeStartOffset + 1;
@@ -505,7 +495,6 @@ TEST_F(WasmModuleVerifyTest, OneFunctionWithNopBody_WithLocals) {
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
   static const byte kNameOffset = 49;
   static const byte kCodeStartOffset = 61;
@@ -579,7 +568,6 @@ TEST_F(WasmModuleVerifyTest, OneGlobalOneFunctionWithNopBodyOneDataSegment) {
   }
 }
 
-
 TEST_F(WasmModuleVerifyTest, OneDataSegment) {
   const byte kDataSegmentSourceOffset = 30;
   const byte data[] = {
@@ -617,7 +605,6 @@ TEST_F(WasmModuleVerifyTest, OneDataSegment) {
   EXPECT_OFF_END_FAILURE(data, 13, sizeof(data));
 }
 
-
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
   const byte kDataSegment0SourceOffset = 30;
   const byte kDataSegment1SourceOffset = 30 + 8;
@@ -704,7 +691,6 @@ TEST_F(WasmModuleVerifyTest, DataSegmentWithInvalidDest) {
   }
 }
 
-
 // To make below tests for indirect calls much shorter.
 #define FUNCTION(sig_index, external) kDeclFunctionImport, SIG_INDEX(sig_index)
 
@@ -728,7 +714,6 @@ TEST_F(WasmModuleVerifyTest, OneIndirectFunction) {
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
@@ -766,7 +751,6 @@ TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   if (result.val) delete result.val;
 }
 
-
 TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
@@ -778,7 +762,6 @@ TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
   EXPECT_FAILURE(data);
 }
 
-
 TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
@@ -792,10 +775,8 @@ TEST_F(WasmModuleVerifyTest, IndirectFunctionInvalidIndex) {
   EXPECT_FAILURE(data);
 }
 
-
 class WasmSignatureDecodeTest : public TestWithZone {};
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
   static const byte data[] = {SIG_ENTRY_v_v};
   base::AccountingAllocator allocator;
@@ -808,7 +789,6 @@ TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
   EXPECT_EQ(0, sig->return_count());
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
@@ -823,7 +803,6 @@ TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair param_type = kLocalTypes[i];
@@ -838,7 +817,6 @@ TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
@@ -857,7 +835,6 @@ TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair p0_type = kLocalTypes[i];
@@ -877,7 +854,6 @@ TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
   byte data[256];
   for (int p = 0; p <= 255; p = p + 1 + p * 3) {
@@ -892,7 +868,6 @@ TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
   }
 }
 
-
 TEST_F(WasmSignatureDecodeTest, Fail_invalid_type) {
   byte kInvalidType = 76;
   for (size_t i = 0; i < SIZEOF_SIG_ENTRY_x_xx; i++) {

test/unittests/wasm/wasm-macro-gen-unittest.cc

@@ -18,7 +18,6 @@ class WasmMacroGenTest : public TestWithZone {};
     EXPECT_EQ(size, sizeof(code)); \
   } while (false)
 
-
 TEST_F(WasmMacroGenTest, Constants) {
   EXPECT_SIZE(2, WASM_ONE);
   EXPECT_SIZE(2, WASM_ZERO);
@@ -48,7 +47,6 @@ TEST_F(WasmMacroGenTest, Constants) {
   EXPECT_SIZE(9, WASM_F64(-9818934.0));
 }
 
-
 TEST_F(WasmMacroGenTest, Statements) {
   EXPECT_SIZE(1, WASM_NOP);
 
@@ -85,7 +83,6 @@ TEST_F(WasmMacroGenTest, Statements) {
   EXPECT_SIZE(1, WASM_UNREACHABLE);
 }
 
-
 TEST_F(WasmMacroGenTest, MacroStatements) {
   EXPECT_SIZE(10, WASM_WHILE(WASM_I8(0), WASM_NOP));
   EXPECT_SIZE(7, WASM_INC_LOCAL(0));
@@ -100,7 +97,6 @@ TEST_F(WasmMacroGenTest, BrTable) {
   EXPECT_SIZE(11, WASM_BR_TABLEV(WASM_ZERO, WASM_ZERO, 1, BR_TARGET(1)));
 }
 
-
 TEST_F(WasmMacroGenTest, Expressions) {
   EXPECT_SIZE(2, WASM_GET_LOCAL(0));
   EXPECT_SIZE(2, WASM_GET_LOCAL(1));
@@ -188,7 +184,6 @@ TEST_F(WasmMacroGenTest, Int32Ops) {
   EXPECT_SIZE(3, WASM_I32_EQZ(WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Int64Ops) {
   EXPECT_SIZE(5, WASM_I64_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_I64_SUB(WASM_ZERO, WASM_ZERO));
@@ -224,7 +219,6 @@ TEST_F(WasmMacroGenTest, Int64Ops) {
   EXPECT_SIZE(3, WASM_I64_EQZ(WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Float32Ops) {
   EXPECT_SIZE(5, WASM_F32_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_F32_SUB(WASM_ZERO, WASM_ZERO));
@@ -249,7 +243,6 @@ TEST_F(WasmMacroGenTest, Float32Ops) {
   EXPECT_SIZE(5, WASM_F32_GE(WASM_ZERO, WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Float64Ops) {
   EXPECT_SIZE(5, WASM_F64_ADD(WASM_ZERO, WASM_ZERO));
   EXPECT_SIZE(5, WASM_F64_SUB(WASM_ZERO, WASM_ZERO));
@@ -274,7 +267,6 @@ TEST_F(WasmMacroGenTest, Float64Ops) {
   EXPECT_SIZE(5, WASM_F64_GE(WASM_ZERO, WASM_ZERO));
 }
 
-
 TEST_F(WasmMacroGenTest, Conversions) {
   EXPECT_SIZE(3, WASM_I32_SCONVERT_F32(WASM_ZERO));
   EXPECT_SIZE(3, WASM_I32_SCONVERT_F64(WASM_ZERO));
@@ -316,7 +308,6 @@ TEST_F(WasmMacroGenTest, LoadsAndStores) {
   }
 }
 
-
 TEST_F(WasmMacroGenTest, LoadsAndStoresWithOffset) {
   for (size_t i = 0; i < arraysize(kMemTypes); i++) {
     EXPECT_SIZE(5, WASM_LOAD_MEM_OFFSET(kMemTypes[i], 11, WASM_ZERO));