VM: Re-format to use at most one newline between functions

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 68 matching lines @@
   RawObject** fp_;
   Simulator* simulator_;
   SimulatorSetjmpBuffer* link_;
 
   friend class Simulator;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(SimulatorSetjmpBuffer);
 };
 
-
 DART_FORCE_INLINE static RawObject** SavedCallerFP(RawObject** FP) {
   return reinterpret_cast<RawObject**>(FP[kSavedCallerFpSlotFromFp]);
 }
 
-
 DART_FORCE_INLINE static RawObject** FrameArguments(RawObject** FP,
                                                     intptr_t argc) {
   return FP - (kDartFrameFixedSize + argc);
 }
 
-
 #define RAW_CAST(Type, val) (SimulatorHelpers::CastTo##Type(val))
 
-
 class SimulatorHelpers {
  public:
 #define DEFINE_CASTS(Type)                                                     \
   DART_FORCE_INLINE static Raw##Type* CastTo##Type(RawObject* obj) {           \
     ASSERT((k##Type##Cid == kSmiCid) ? !obj->IsHeapObject()                    \
                                      : obj->Is##Type());                       \
     return reinterpret_cast<Raw##Type*>(obj);                                  \
   }
   CLASS_LIST(DEFINE_CASTS)
 #undef DEFINE_CASTS
@@ skipping 337 matching lines @@
         reinterpret_cast<RawStackTrace*>(args[0]));
     *result = Object::null();
     return true;
   }
 
   DART_FORCE_INLINE static RawCode* FrameCode(RawObject** FP) {
     ASSERT(GetClassId(FP[kPcMarkerSlotFromFp]) == kCodeCid);
     return static_cast<RawCode*>(FP[kPcMarkerSlotFromFp]);
   }
 
-
   DART_FORCE_INLINE static void SetFrameCode(RawObject** FP, RawCode* code) {
     ASSERT(GetClassId(code) == kCodeCid);
     FP[kPcMarkerSlotFromFp] = code;
   }
 
   DART_FORCE_INLINE static uint8_t* GetTypedData(RawObject* obj,
                                                  RawObject* index) {
     ASSERT(RawObject::IsTypedDataClassId(obj->GetClassId()));
     RawTypedData* array = reinterpret_cast<RawTypedData*>(obj);
     const intptr_t byte_offset = Smi::Value(RAW_CAST(Smi, index));
     ASSERT(byte_offset >= 0);
     return array->ptr()->data() + byte_offset;
   }
 };
 
-
 DART_FORCE_INLINE static uint32_t* SavedCallerPC(RawObject** FP) {
   return reinterpret_cast<uint32_t*>(FP[kSavedCallerPcSlotFromFp]);
 }
 
-
 DART_FORCE_INLINE static RawFunction* FrameFunction(RawObject** FP) {
   RawFunction* function = static_cast<RawFunction*>(FP[kFunctionSlotFromFp]);
   ASSERT(SimulatorHelpers::GetClassId(function) == kFunctionCid);
   return function;
 }
 
-
 IntrinsicHandler Simulator::intrinsics_[Simulator::kIntrinsicCount];
 
-
 // Synchronization primitives support.
 void Simulator::InitOnce() {
   for (intptr_t i = 0; i < kIntrinsicCount; i++) {
     intrinsics_[i] = 0;
   }
 
   intrinsics_[kObjectArraySetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArraySetIndexed;
   intrinsics_[kObjectArrayGetIndexedIntrinsic] =
       SimulatorHelpers::ObjectArrayGetIndexed;
@@ skipping 19 matching lines @@
   intrinsics_[kDouble_lessThanIntrinsic] = SimulatorHelpers::Double_lessThan;
   intrinsics_[kDouble_equalIntrinsic] = SimulatorHelpers::Double_equal;
   intrinsics_[kDouble_lessEqualThanIntrinsic] =
       SimulatorHelpers::Double_lessEqualThan;
   intrinsics_[kClearAsyncThreadStackTraceIntrinsic] =
       SimulatorHelpers::ClearAsyncThreadStack;
   intrinsics_[kSetAsyncThreadStackTraceIntrinsic] =
       SimulatorHelpers::SetAsyncThreadStackTrace;
 }
 
-
 Simulator::Simulator() : stack_(NULL), fp_(NULL) {
   // Setup simulator support first. Some of this information is needed to
   // setup the architecture state.
   // We allocate the stack here, the size is computed as the sum of
   // the size specified by the user and the buffer space needed for
   // handling stack overflow exceptions. To be safe in potential
   // stack underflows we also add some underflow buffer space.
   stack_ = new uintptr_t[(OSThread::GetSpecifiedStackSize() +
                           OSThread::kStackSizeBuffer +
                           kSimulatorStackUnderflowSize) /
                          sizeof(uintptr_t)];
   last_setjmp_buffer_ = NULL;
   top_exit_frame_info_ = 0;
 
   NOT_IN_PRODUCT(icount_ = 0;)
 }
 
-
 Simulator::~Simulator() {
   delete[] stack_;
   Isolate* isolate = Isolate::Current();
   if (isolate != NULL) {
     isolate->set_simulator(NULL);
   }
 }
 
-
 // Get the active Simulator for the current isolate.
 Simulator* Simulator::Current() {
   Simulator* simulator = Isolate::Current()->simulator();
   if (simulator == NULL) {
     simulator = new Simulator();
     Isolate::Current()->set_simulator(simulator);
   }
   return simulator;
 }
 
-
 // Returns the top of the stack area to enable checking for stack pointer
 // validity.
 uword Simulator::StackTop() const {
   // To be safe in potential stack underflows we leave some buffer above and
   // set the stack top.
   return StackBase() +
          (OSThread::GetSpecifiedStackSize() + OSThread::kStackSizeBuffer);
 }
 
-
 #if !defined(PRODUCT)
 // Returns true if tracing of executed instructions is enabled.
 DART_FORCE_INLINE bool Simulator::IsTracingExecution() const {
   return icount_ > FLAG_trace_sim_after;
 }
 
-
 // Prints bytecode instruction at given pc for instruction tracing.
 DART_NOINLINE void Simulator::TraceInstruction(uint32_t* pc) const {
   THR_Print("%" Pu64 " ", icount_);
   if (FLAG_support_disassembler) {
     Disassembler::Disassemble(reinterpret_cast<uword>(pc),
                               reinterpret_cast<uword>(pc + 1));
   } else {
     THR_Print("Disassembler not supported in this mode.\n");
   }
 }
 #endif  // !defined(PRODUCT)
 
-
 // Calls into the Dart runtime are based on this interface.
 typedef void (*SimulatorRuntimeCall)(NativeArguments arguments);
 
 // Calls to leaf Dart runtime functions are based on this interface.
 typedef intptr_t (*SimulatorLeafRuntimeCall)(intptr_t r0,
                                              intptr_t r1,
                                              intptr_t r2,
                                              intptr_t r3);
 
 // Calls to leaf float Dart runtime functions are based on this interface.
 typedef double (*SimulatorLeafFloatRuntimeCall)(double d0, double d1);
 
 // Calls to native Dart functions are based on this interface.
 typedef void (*SimulatorBootstrapNativeCall)(NativeArguments* arguments);
 typedef void (*SimulatorNativeCall)(NativeArguments* arguments, uword target);
 
-
 void Simulator::Exit(Thread* thread,
                      RawObject** base,
                      RawObject** frame,
                      uint32_t* pc) {
   frame[0] = Function::null();
   frame[1] = Code::null();
   frame[2] = reinterpret_cast<RawObject*>(pc);
   frame[3] = reinterpret_cast<RawObject*>(base);
   fp_ = frame + kDartFrameFixedSize;
   thread->set_top_exit_frame_info(reinterpret_cast<uword>(fp_));
@@ skipping 26 matching lines @@
       "1:"
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
-
 DART_FORCE_INLINE static bool SignedSubWithOverflow(intptr_t lhs,
                                                     intptr_t rhs,
                                                     intptr_t* out) {
   intptr_t res = 1;
 #if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)
   asm volatile(
       "sub %2, %1\n"
       "jo 1f;\n"
       "xor %0, %0\n"
       "mov %1, 0(%3)\n"
@@ skipping 10 matching lines @@
       "1:"
       : "+r"(res), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
-
 DART_FORCE_INLINE static bool SignedMulWithOverflow(intptr_t lhs,
                                                     intptr_t rhs,
                                                     intptr_t* out) {
   intptr_t res = 1;
 #if defined(HOST_ARCH_IA32) || defined(HOST_ARCH_X64)
   asm volatile(
       "imul %2, %1\n"
       "jo 1f;\n"
       "xor %0, %0\n"
       "mov %1, 0(%3)\n"
@@ skipping 24 matching lines @@
       "1:"
       : "=r"(res), "+r"(prod_lo), "+r"(lhs)
       : "r"(rhs), "r"(out)
       : "cc");
 #else
 #error "Unsupported platform"
 #endif
   return (res != 0);
 }
 
-
 DART_FORCE_INLINE static bool AreBothSmis(intptr_t a, intptr_t b) {
   return ((a | b) & kHeapObjectTag) == 0;
 }
 
-
 #define SMI_MUL(lhs, rhs, pres) SignedMulWithOverflow((lhs), (rhs) >> 1, pres)
 #define SMI_COND(cond, lhs, rhs, pres)                                         \
   ((*(pres) = ((lhs cond rhs) ? true_value : false_value)), false)
 #define SMI_EQ(lhs, rhs, pres) SMI_COND(==, lhs, rhs, pres)
 #define SMI_LT(lhs, rhs, pres) SMI_COND(<, lhs, rhs, pres)
 #define SMI_GT(lhs, rhs, pres) SMI_COND(>, lhs, rhs, pres)
 #define SMI_BITOR(lhs, rhs, pres) ((*(pres) = (lhs | rhs)), false)
 #define SMI_BITAND(lhs, rhs, pres) ((*(pres) = ((lhs) & (rhs))), false)
 #define SMI_BITXOR(lhs, rhs, pres) ((*(pres) = ((lhs) ^ (rhs))), false)
 
-
 void Simulator::CallRuntime(Thread* thread,
                             RawObject** base,
                             RawObject** exit_frame,
                             uint32_t* pc,
                             intptr_t argc_tag,
                             RawObject** args,
                             RawObject** result,
                             uword target) {
   Exit(thread, base, exit_frame, pc);
   NativeArguments native_args(thread, argc_tag, args, result);
   reinterpret_cast<RuntimeFunction>(target)(native_args);
 }
 
-
 DART_FORCE_INLINE static void EnterSyntheticFrame(RawObject*** FP,
                                                   RawObject*** SP,
                                                   uint32_t* pc) {
   RawObject** fp = *SP + kDartFrameFixedSize;
   fp[kPcMarkerSlotFromFp] = 0;
   fp[kSavedCallerPcSlotFromFp] = reinterpret_cast<RawObject*>(pc);
   fp[kSavedCallerFpSlotFromFp] = reinterpret_cast<RawObject*>(*FP);
   *FP = fp;
   *SP = fp - 1;
 }
 
-
 DART_FORCE_INLINE static void LeaveSyntheticFrame(RawObject*** FP,
                                                   RawObject*** SP) {
   RawObject** fp = *FP;
   *FP = reinterpret_cast<RawObject**>(fp[kSavedCallerFpSlotFromFp]);
   *SP = fp - kDartFrameFixedSize;
 }
 
-
 DART_FORCE_INLINE void Simulator::Invoke(Thread* thread,
                                          RawObject** call_base,
                                          RawObject** call_top,
                                          RawObjectPool** pp,
                                          uint32_t** pc,
                                          RawObject*** FP,
                                          RawObject*** SP) {
   RawObject** callee_fp = call_top + kDartFrameFixedSize;
 
   RawFunction* function = FrameFunction(callee_fp);
   RawCode* code = function->ptr()->code_;
   callee_fp[kPcMarkerSlotFromFp] = code;
   callee_fp[kSavedCallerPcSlotFromFp] = reinterpret_cast<RawObject*>(*pc);
   callee_fp[kSavedCallerFpSlotFromFp] = reinterpret_cast<RawObject*>(*FP);
   *pp = code->ptr()->object_pool_->ptr();
   *pc = reinterpret_cast<uint32_t*>(code->ptr()->entry_point_);
   pc_ = reinterpret_cast<uword>(*pc);  // For the profiler.
   *FP = callee_fp;
   *SP = *FP - 1;
 }
 
-
 void Simulator::InlineCacheMiss(int checked_args,
                                 Thread* thread,
                                 RawICData* icdata,
                                 RawObject** args,
                                 RawObject** top,
                                 uint32_t* pc,
                                 RawObject** FP,
                                 RawObject** SP) {
   RawObject** result = top;
   RawObject** miss_handler_args = top + 1;
@@ skipping 14 matching lines @@
       break;
   }
 
   // Handler arguments: arguments to check and an ICData object.
   const intptr_t miss_handler_argc = checked_args + 1;
   RawObject** exit_frame = miss_handler_args + miss_handler_argc;
   CallRuntime(thread, FP, exit_frame, pc, miss_handler_argc, miss_handler_args,
               result, reinterpret_cast<uword>(handler));
 }
 
-
 DART_FORCE_INLINE void Simulator::InstanceCall1(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
@@ skipping 22 matching lines @@
     }
   } else {
     InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
                     *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
-
 DART_FORCE_INLINE void Simulator::InstanceCall2(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
@@ skipping 24 matching lines @@
     }
   } else {
     InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
                     *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
-
 // Note: functions below are marked DART_NOINLINE to recover performance on
 // ARM where inlining these functions into the interpreter loop seemed to cause
 // some code quality issues.
 static DART_NOINLINE bool InvokeRuntime(Thread* thread,
                                         Simulator* sim,
                                         RuntimeFunction drt,
                                         const NativeArguments& args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(drt));
     drt(args);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
-
 static DART_NOINLINE bool InvokeBootstrapNative(Thread* thread,
                                                 Simulator* sim,
                                                 SimulatorBootstrapNativeCall f,
                                                 NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     f(args);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
-
 static DART_NOINLINE bool InvokeNativeNoScopeWrapper(Thread* thread,
                                                      Simulator* sim,
                                                      Dart_NativeFunction f,
                                                      NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     NativeEntry::NoScopeNativeCallWrapper(
         reinterpret_cast<Dart_NativeArguments>(args), f);
     thread->set_vm_tag(VMTag::kDartTagId);
     thread->set_top_exit_frame_info(0);
     return true;
   } else {
     return false;
   }
 }
 
-
 static DART_NOINLINE bool InvokeNativeAutoScopeWrapper(Thread* thread,
                                                        Simulator* sim,
                                                        Dart_NativeFunction f,
                                                        NativeArguments* args) {
   SimulatorSetjmpBuffer buffer(sim);
   if (!setjmp(buffer.buffer_)) {
     thread->set_vm_tag(reinterpret_cast<uword>(f));
     NativeEntry::AutoScopeNativeCallWrapper(
         reinterpret_cast<Dart_NativeArguments>(args), f);
     thread->set_vm_tag(VMTag::kDartTagId);
@@ skipping 60 matching lines @@
 #define DECODE___D rD = (op >> Bytecode::kDShift);
 
 #define DECLARE_A_D DECLARE___D
 #define DECODE_A_D DECODE___D
 
 #define DECLARE_A_X                                                            \
   int32_t rD;                                                                  \
   USE(rD)
 #define DECODE_A_X rD = (static_cast<int32_t>(op) >> Bytecode::kDShift);
 
-
 #define SMI_FASTPATH_ICDATA_INC                                                \
   do {                                                                         \
     ASSERT(Bytecode::IsCallOpcode(*pc));                                       \
     const uint16_t kidx = Bytecode::DecodeD(*pc);                              \
     const RawICData* icdata = RAW_CAST(ICData, LOAD_CONSTANT(kidx));           \
     RawObject** entries = icdata->ptr()->ic_data_->ptr()->data();              \
     SimulatorHelpers::IncrementICUsageCount(entries, 0, 2);                    \
   } while (0);
 
 // Declare bytecode handler for a smi operation (e.g. AddTOS) with the
@@ skipping 29 matching lines @@
 
 // Do not check for overflow.
 #define SMI_OP_NOCHECK(ResultT, Func)                                          \
   {                                                                            \
     const intptr_t lhs = reinterpret_cast<intptr_t>(FP[rB]);                   \
     const intptr_t rhs = reinterpret_cast<intptr_t>(FP[rC]);                   \
     ResultT* slot = reinterpret_cast<ResultT*>(&FP[rA]);                       \
     Func(lhs, rhs, slot);                                                      \
   }
 
-
 // Exception handling helper. Gets handler FP and PC from the Simulator where
 // they were stored by Simulator::Longjmp and proceeds to execute the handler.
 // Corner case: handler PC can be a fake marker that marks entry frame, which
 // means exception was not handled in the Dart code. In this case we return
 // caught exception from Simulator::Call.
 #define HANDLE_EXCEPTION                                                       \
   do {                                                                         \
     FP = reinterpret_cast<RawObject**>(fp_);                                   \
     pc = reinterpret_cast<uint32_t*>(pc_);                                     \
     if ((reinterpret_cast<uword>(pc) & 2) != 0) { /* Entry frame? */           \
@@ skipping 23 matching lines @@
     HANDLE_EXCEPTION;                                                          \
   }
 
 #define INVOKE_NATIVE_AUTO_SCOPE(Func, Args)                                   \
   if (!InvokeNativeAutoScopeWrapper(thread, this, Func, &Args)) {              \
     HANDLE_EXCEPTION;                                                          \
   }
 
 #define LOAD_CONSTANT(index) (pp->data()[(index)].raw_obj_)
 
-
 // Returns true if deoptimization succeeds.
 DART_FORCE_INLINE bool Simulator::Deoptimize(Thread* thread,
                                              RawObjectPool** pp,
                                              uint32_t** pc,
                                              RawObject*** FP,
                                              RawObject*** SP,
                                              bool is_lazy) {
   // Note: frame translation will take care of preserving result at the
   // top of the stack. See CompilerDeoptInfo::CreateDeoptInfo.
 
@@ skipping 36 matching lines @@
   // FrameArguments(...) returns a pointer to the first argument.
   *SP = FrameArguments(*FP, materialization_arg_count) - 1;
   *FP = SavedCallerFP(*FP);
 
   // Restore pp.
   *pp = SimulatorHelpers::FrameCode(*FP)->ptr()->object_pool_->ptr();
 
   return true;
 }
 
-
 RawObject* Simulator::Call(const Code& code,
                            const Array& arguments_descriptor,
                            const Array& arguments,
                            Thread* thread) {
   // Dispatch used to interpret bytecode. Contains addresses of
   // labels of bytecode handlers. Handlers themselves are defined below.
   static const void* dispatch[] = {
 #define TARGET(name, fmt, fmta, fmtb, fmtc) &&bc##name,
       BYTECODES_LIST(TARGET)
 #undef TARGET
@@ skipping 2664 matching lines @@
   // Single dispatch point used by exception handling macros.
   {
   DispatchAfterException:
     DISPATCH();
   }
 
   UNREACHABLE();
   return 0;
 }
 
-
 void Simulator::JumpToFrame(uword pc, uword sp, uword fp, Thread* thread) {
   // Walk over all setjmp buffers (simulated --> C++ transitions)
   // and try to find the setjmp associated with the simulated frame pointer.
   SimulatorSetjmpBuffer* buf = last_setjmp_buffer();
   while ((buf->link() != NULL) && (buf->link()->fp() > fp)) {
     buf = buf->link();
   }
   ASSERT(buf != NULL);
   ASSERT(last_setjmp_buffer() == buf);
 
@@ skipping 22 matching lines @@
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC