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

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 36 matching lines @@
 namespace internal {
 namespace compiler {
 
 namespace {
 const Operator* UnsupportedOpcode(wasm::WasmOpcode opcode) {
   V8_Fatal(__FILE__, __LINE__, "Unsupported opcode #%d:%s", opcode,
            wasm::WasmOpcodes::OpcodeName(opcode));
   return nullptr;
 }
 
-
 void MergeControlToEnd(JSGraph* jsgraph, Node* node) {
   Graph* g = jsgraph->graph();
   if (g->end()) {
     NodeProperties::MergeControlToEnd(g, jsgraph->common(), node);
   } else {
     g->SetEnd(g->NewNode(jsgraph->common()->End(1), node));
   }
 }
 
 }  // namespace
@@ skipping 210 matching lines @@
       control_(nullptr),
       effect_(nullptr),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
       trap_(new (zone) WasmTrapHelper(this)),
       function_signature_(function_signature),
       source_position_table_(source_position_table) {
   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);
   MergeControlToEnd(jsgraph(), terminate);
   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);
   int new_size = merge->InputCount();
   NodeProperties::ChangeOp(
       merge, jsgraph()->common()->ResizeMergeOrPhi(merge->op(), new_size));
 }
 
 void WasmGraphBuilder::AppendToPhi(Node* phi, Node* from) {
   DCHECK(IrOpcode::IsPhiOpcode(phi->opcode()));
   int new_size = phi->InputCount();
   phi->InsertInput(jsgraph()->zone(), phi->InputCount() - 1, from);
   NodeProperties::ChangeOp(
       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()));
   Node** buf = Realloc(vals, count, count + 1);
   buf[count] = control;
   return graph()->NewNode(jsgraph()->common()->Phi(type, count), count + 1,
                           buf);
 }
 
-
 Node* WasmGraphBuilder::EffectPhi(unsigned count, Node** effects,
                                   Node* control) {
   DCHECK(IrOpcode::IsMergeOpcode(control->opcode()));
   Node** buf = Realloc(effects, count, count + 1);
   buf[count] = control;
   return graph()->NewNode(jsgraph()->common()->EffectPhi(count), count + 1,
                           buf);
 }
 
 Node* WasmGraphBuilder::NumberConstant(int32_t value) {
   return jsgraph()->Constant(value);
 }
 
 Node* WasmGraphBuilder::Int32Constant(int32_t value) {
   return jsgraph()->Int32Constant(value);
 }
 
-
 Node* WasmGraphBuilder::Int64Constant(int64_t value) {
   return jsgraph()->Int64Constant(value);
 }
 
 Node* WasmGraphBuilder::Binop(wasm::WasmOpcode opcode, Node* left, Node* right,
                               wasm::WasmCodePosition position) {
   const Operator* op;
   MachineOperatorBuilder* m = jsgraph()->machine();
   switch (opcode) {
     case wasm::kExprI32Add:
@@ skipping 499 matching lines @@
     case wasm::kExprF32AsmjsLoadMem:
       return BuildAsmjsLoadMem(MachineType::Float32(), input);
     case wasm::kExprF64AsmjsLoadMem:
       return BuildAsmjsLoadMem(MachineType::Float64(), input);
     default:
       op = UnsupportedOpcode(opcode);
   }
   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);
   DCHECK_NOT_NULL(*control_);
   Node* branch =
       graph()->NewNode(jsgraph()->common()->Branch(), cond, *control_);
   *true_node = graph()->NewNode(jsgraph()->common()->IfTrue(), branch);
   *false_node = graph()->NewNode(jsgraph()->common()->IfFalse(), branch);
   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_);
 
   if (count == 0) {
     // Handle a return of void.
     vals[0] = jsgraph()->Int32Constant(0);
     count = 1;
   }
 
   Node** buf = Realloc(vals, count, count + 2);
   buf[count] = *effect_;
   buf[count + 1] = *control_;
   Node* ret = graph()->NewNode(jsgraph()->common()->Return(), count + 2, vals);
 
   MergeControlToEnd(jsgraph(), ret);
   return ret;
 }
 
-
 Node* WasmGraphBuilder::ReturnVoid() { return Return(0, Buffer(0)); }
 
 Node* WasmGraphBuilder::Unreachable(wasm::WasmCodePosition position) {
   trap_->Unreachable(position);
   return nullptr;
 }
 
 Node* WasmGraphBuilder::MaskShiftCount32(Node* node) {
   static const int32_t kMask32 = 0x1f;
   if (!jsgraph()->machine()->Word32ShiftIsSafe()) {
@@ skipping 28 matching lines @@
 
 Node* WasmGraphBuilder::BuildF32Neg(Node* input) {
   Node* result =
       Unop(wasm::kExprF32ReinterpretI32,
            Binop(wasm::kExprI32Xor, Unop(wasm::kExprI32ReinterpretF32, input),
                  jsgraph()->Int32Constant(0x80000000)));
 
   return result;
 }
 
-
 Node* WasmGraphBuilder::BuildF64Neg(Node* input) {
 #if WASM_64
   Node* result =
       Unop(wasm::kExprF64ReinterpretI64,
            Binop(wasm::kExprI64Xor, Unop(wasm::kExprI64ReinterpretF64, input),
                  jsgraph()->Int64Constant(0x8000000000000000)));
 
   return result;
 #else
   MachineOperatorBuilder* m = jsgraph()->machine();
 
   Node* old_high_word = graph()->NewNode(m->Float64ExtractHighWord32(), input);
   Node* new_high_word = Binop(wasm::kExprI32Xor, old_high_word,
                               jsgraph()->Int32Constant(0x80000000));
 
   return graph()->NewNode(m->Float64InsertHighWord32(), input, new_high_word);
 #endif
 }
 
-
 Node* WasmGraphBuilder::BuildF32CopySign(Node* left, Node* right) {
   Node* result = Unop(
       wasm::kExprF32ReinterpretI32,
       Binop(wasm::kExprI32Ior,
             Binop(wasm::kExprI32And, Unop(wasm::kExprI32ReinterpretF32, left),
                   jsgraph()->Int32Constant(0x7fffffff)),
             Binop(wasm::kExprI32And, Unop(wasm::kExprI32ReinterpretF32, right),
                   jsgraph()->Int32Constant(0x80000000))));
 
   return result;
 }
 
-
 Node* WasmGraphBuilder::BuildF64CopySign(Node* left, Node* right) {
 #if WASM_64
   Node* result = Unop(
       wasm::kExprF64ReinterpretI64,
       Binop(wasm::kExprI64Ior,
             Binop(wasm::kExprI64And, Unop(wasm::kExprI64ReinterpretF64, left),
                   jsgraph()->Int64Constant(0x7fffffffffffffff)),
             Binop(wasm::kExprI64And, Unop(wasm::kExprI64ReinterpretF64, right),
                   jsgraph()->Int64Constant(0x8000000000000000))));
 
   return result;
 #else
   MachineOperatorBuilder* m = jsgraph()->machine();
 
   Node* high_word_left = graph()->NewNode(m->Float64ExtractHighWord32(), left);
   Node* high_word_right =
       graph()->NewNode(m->Float64ExtractHighWord32(), right);
 
   Node* new_high_word =
       Binop(wasm::kExprI32Ior, Binop(wasm::kExprI32And, high_word_left,
                                      jsgraph()->Int32Constant(0x7fffffff)),
             Binop(wasm::kExprI32And, high_word_right,
                   jsgraph()->Int32Constant(0x80000000)));
 
   return graph()->NewNode(m->Float64InsertHighWord32(), left, new_high_word);
 #endif
 }
 
-
 Node* WasmGraphBuilder::BuildF32Min(Node* left, Node* right) {
   Diamond left_le_right(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF32Le, left, right));
 
   Diamond right_lt_left(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF32Lt, right, left));
 
   Diamond left_is_not_nan(graph(), jsgraph()->common(),
                           Binop(wasm::kExprF32Eq, left, left));
 
   return left_le_right.Phi(
       wasm::kAstF32, left,
       right_lt_left.Phi(
           wasm::kAstF32, right,
           left_is_not_nan.Phi(
               wasm::kAstF32,
               Binop(wasm::kExprF32Mul, right, Float32Constant(1.0)),
               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));
 
   Diamond right_gt_left(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF32Gt, right, left));
 
   Diamond left_is_not_nan(graph(), jsgraph()->common(),
                           Binop(wasm::kExprF32Eq, left, left));
 
   return left_ge_right.Phi(
       wasm::kAstF32, left,
       right_gt_left.Phi(
           wasm::kAstF32, right,
           left_is_not_nan.Phi(
               wasm::kAstF32,
               Binop(wasm::kExprF32Mul, right, Float32Constant(1.0)),
               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));
 
   Diamond right_lt_left(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF64Lt, right, left));
 
   Diamond left_is_not_nan(graph(), jsgraph()->common(),
                           Binop(wasm::kExprF64Eq, left, left));
 
   return left_le_right.Phi(
       wasm::kAstF64, left,
       right_lt_left.Phi(
           wasm::kAstF64, right,
           left_is_not_nan.Phi(
               wasm::kAstF64,
               Binop(wasm::kExprF64Mul, right, Float64Constant(1.0)),
               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));
 
   Diamond right_gt_left(graph(), jsgraph()->common(),
                         Binop(wasm::kExprF64Lt, right, left));
 
   Diamond left_is_not_nan(graph(), jsgraph()->common(),
                           Binop(wasm::kExprF64Eq, left, left));
 
@@ skipping 130 matching lines @@
                                               jsgraph()->isolate()),
                                    MachineRepresentation::kWord64));
 }
 
 Node* WasmGraphBuilder::BuildI32Popcnt(Node* input) {
   return BuildBitCountingCall(
       input, ExternalReference::wasm_word32_popcnt(jsgraph()->isolate()),
       MachineRepresentation::kWord32);
 }
 
-
 Node* WasmGraphBuilder::BuildI64Popcnt(Node* input) {
   return Unop(wasm::kExprI64UConvertI32,
               BuildBitCountingCall(input, ExternalReference::wasm_word64_popcnt(
                                               jsgraph()->isolate()),
                                    MachineRepresentation::kWord64));
 }
 
 Node* WasmGraphBuilder::BuildF32Trunc(Node* input) {
   MachineType type = MachineType::Float32();
   ExternalReference ref =
@@ skipping 1147 matching lines @@
   }
   Node* jsval =
       ToJS(retval, context,
            sig->return_count() == 0 ? wasm::kAstStmt : sig->GetReturn());
   Node* ret =
       graph()->NewNode(jsgraph()->common()->Return(), jsval, call, start);
 
   MergeControlToEnd(jsgraph(), ret);
 }
 
-
 void WasmGraphBuilder::BuildWasmToJSWrapper(Handle<JSFunction> function,
                                             wasm::FunctionSig* sig) {
   int js_count = function->shared()->internal_formal_parameter_count();
   int wasm_count = static_cast<int>(sig->parameter_count());
   int param_count;
   if (jsgraph()->machine()->Is64()) {
     param_count = wasm_count;
   } else {
     param_count = Int64Lowering::GetParameterCountAfterLowering(sig);
   }
@@ skipping 72 matching lines @@
                            graph()->NewNode(jsgraph()->machine()->Word32Sar(),
                                             val, jsgraph()->Int32Constant(31)),
                            call, start);
   } else {
     ret = graph()->NewNode(jsgraph()->common()->Return(), val, call, start);
   }
 
   MergeControlToEnd(jsgraph(), ret);
 }
 
-
 Node* WasmGraphBuilder::MemBuffer(uint32_t offset) {
   DCHECK(module_ && module_->instance);
   if (offset == 0) {
     if (!mem_buffer_) {
       mem_buffer_ = jsgraph()->RelocatableIntPtrConstant(
           reinterpret_cast<uintptr_t>(module_->instance->mem_start),
           RelocInfo::WASM_MEMORY_REFERENCE);
     }
     return mem_buffer_;
   } else {
     return jsgraph()->RelocatableIntPtrConstant(
         reinterpret_cast<uintptr_t>(module_->instance->mem_start + offset),
         RelocInfo::WASM_MEMORY_REFERENCE);
   }
 }
 
-
 Node* WasmGraphBuilder::MemSize(uint32_t offset) {
   DCHECK(module_ && module_->instance);
   uint32_t size = static_cast<uint32_t>(module_->instance->mem_size);
   if (offset == 0) {
     if (!mem_size_) mem_size_ = jsgraph()->Int32Constant(size);
     return mem_size_;
   } else {
     return jsgraph()->Int32Constant(size + offset);
   }
 }
 
-
 Node* WasmGraphBuilder::FunctionTable() {
   DCHECK(module_ && module_->instance &&
          !module_->instance->function_table.is_null());
   if (!function_table_) {
     function_table_ = jsgraph()->Constant(module_->instance->function_table);
   }
   return function_table_;
 }
 
-
 Node* WasmGraphBuilder::LoadGlobal(uint32_t index) {
   DCHECK(module_ && module_->instance && module_->instance->globals_start);
   MachineType mem_type = module_->GetGlobalType(index);
   Node* addr = jsgraph()->IntPtrConstant(
       reinterpret_cast<uintptr_t>(module_->instance->globals_start +
                                   module_->module->globals[index].offset));
   const Operator* op = jsgraph()->machine()->Load(mem_type);
   Node* node = graph()->NewNode(op, addr, jsgraph()->Int32Constant(0), *effect_,
                                 *control_);
   *effect_ = node;
   return node;
 }
 
-
 Node* WasmGraphBuilder::StoreGlobal(uint32_t index, Node* val) {
   DCHECK(module_ && module_->instance && module_->instance->globals_start);
   MachineType mem_type = module_->GetGlobalType(index);
   Node* addr = jsgraph()->IntPtrConstant(
       reinterpret_cast<uintptr_t>(module_->instance->globals_start +
                                   module_->module->globals[index].offset));
   const Operator* op = jsgraph()->machine()->Store(
       StoreRepresentation(mem_type.representation(), kNoWriteBarrier));
   Node* node = graph()->NewNode(op, addr, jsgraph()->Int32Constant(0), val,
                                 *effect_, *control_);
@@ skipping 94 matching lines @@
   Node* store = graph()->NewNode(op, MemBuffer(0), index, MemSize(0), val,
                                  *effect_, *control_);
   *effect_ = store;
   return val;
 }
 
 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() {
   if (jsgraph()->machine()->Is32()) {
     Int64Lowering r(jsgraph()->graph(), jsgraph()->machine(),
                     jsgraph()->common(), jsgraph()->zone(),
                     function_signature_);
     r.LowerGraph();
   }
 }
@@ skipping 397 matching lines @@
                                  const wasm::WasmFunction* function) {
   WasmCompilationUnit* unit =
       CreateWasmCompilationUnit(thrower, isolate, module_env, function, 0);
   ExecuteCompilation(unit);
   return FinishCompilation(unit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8