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

runtime/vm/exceptions.cc

 // Copyright (c) 2011, 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 "vm/exceptions.h"
 
 #include "platform/address_sanitizer.h"
 
 #include "lib/stacktrace.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/datastream.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 
-
 namespace dart {
 
 DECLARE_FLAG(bool, trace_deoptimization);
 DEFINE_FLAG(bool,
             print_stacktrace_at_throw,
             false,
             "Prints a stack trace everytime a throw occurs.");
 
-
 class StackTraceBuilder : public ValueObject {
  public:
   StackTraceBuilder() {}
   virtual ~StackTraceBuilder() {}
 
   virtual void AddFrame(const Code& code, const Smi& offset) = 0;
 };
 
-
 class RegularStackTraceBuilder : public StackTraceBuilder {
  public:
   explicit RegularStackTraceBuilder(Zone* zone)
       : code_list_(
             GrowableObjectArray::Handle(zone, GrowableObjectArray::New())),
         pc_offset_list_(
             GrowableObjectArray::Handle(zone, GrowableObjectArray::New())) {}
   ~RegularStackTraceBuilder() {}
 
   const GrowableObjectArray& code_list() const { return code_list_; }
   const GrowableObjectArray& pc_offset_list() const { return pc_offset_list_; }
 
   virtual void AddFrame(const Code& code, const Smi& offset) {
     code_list_.Add(code);
     pc_offset_list_.Add(offset);
   }
 
  private:
   const GrowableObjectArray& code_list_;
   const GrowableObjectArray& pc_offset_list_;
 
   DISALLOW_COPY_AND_ASSIGN(RegularStackTraceBuilder);
 };
 
-
 class PreallocatedStackTraceBuilder : public StackTraceBuilder {
  public:
   explicit PreallocatedStackTraceBuilder(const Instance& stacktrace)
       : stacktrace_(StackTrace::Cast(stacktrace)),
         cur_index_(0),
         dropped_frames_(0) {
     ASSERT(stacktrace_.raw() ==
            Isolate::Current()->object_store()->preallocated_stack_trace());
   }
   ~PreallocatedStackTraceBuilder() {}
 
   virtual void AddFrame(const Code& code, const Smi& offset);
 
  private:
   static const int kNumTopframes = StackTrace::kPreallocatedStackdepth / 2;
 
   const StackTrace& stacktrace_;
   intptr_t cur_index_;
   intptr_t dropped_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(PreallocatedStackTraceBuilder);
 };
 
-
 void PreallocatedStackTraceBuilder::AddFrame(const Code& code,
                                              const Smi& offset) {
   if (cur_index_ >= StackTrace::kPreallocatedStackdepth) {
     // The number of frames is overflowing the preallocated stack trace object.
     Code& frame_code = Code::Handle();
     Smi& frame_offset = Smi::Handle();
     intptr_t start = StackTrace::kPreallocatedStackdepth - (kNumTopframes - 1);
     intptr_t null_slot = start - 2;
     // We are going to drop one frame.
     dropped_frames_++;
@@ skipping 15 matching lines @@
       stacktrace_.SetCodeAtFrame(prev, frame_code);
       stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
     }
     cur_index_ = (StackTrace::kPreallocatedStackdepth - 1);
   }
   stacktrace_.SetCodeAtFrame(cur_index_, code);
   stacktrace_.SetPcOffsetAtFrame(cur_index_, offset);
   cur_index_ += 1;
 }
 
-
 static void BuildStackTrace(StackTraceBuilder* builder) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   while (frame != NULL) {
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       ASSERT(code.ContainsInstructionAt(frame->pc()));
       offset = Smi::New(frame->pc() - code.PayloadStart());
       builder->AddFrame(code, offset);
     }
     frame = frames.NextFrame();
   }
 }
 
-
 static RawObject** VariableAt(uword fp, int stack_slot) {
 #if defined(TARGET_ARCH_DBC)
   return reinterpret_cast<RawObject**>(fp + stack_slot * kWordSize);
 #else
   if (stack_slot < 0) {
     return reinterpret_cast<RawObject**>(ParamAddress(fp, -stack_slot));
   } else {
     return reinterpret_cast<RawObject**>(
         LocalVarAddress(fp, kFirstLocalSlotFromFp - stack_slot));
   }
 #endif
 }
 
-
 class ExceptionHandlerFinder : public StackResource {
  public:
   explicit ExceptionHandlerFinder(Thread* thread)
       : StackResource(thread), thread_(thread), cache_(NULL), metadata_(NULL) {}
 
   // Iterate through the stack frames and try to find a frame with an
   // exception handler. Once found, set the pc, sp and fp so that execution
   // can continue in that frame. Sets 'needs_stacktrace' if there is no
   // cath-all handler or if a stack-trace is specified in the catch.
   bool Find() {
@@ skipping 166 matching lines @@
   typedef ReadStream::Raw<sizeof(intptr_t), intptr_t> Reader;
   Thread* thread_;
   CatchEntryStateCache* cache_;
   Code* code_;
   bool handler_pc_set_;
   intptr_t* metadata_;      // MetaData generated from deopt.
   CatchEntryState cached_;  // Value of per PC MetaData cache.
   intptr_t pc_;             // Current pc in the handler frame.
 };
 
-
 static void FindErrorHandler(uword* handler_pc,
                              uword* handler_sp,
                              uword* handler_fp) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
                             Thread::Current(),
                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
   while (!frame->IsEntryFrame()) {
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
 }
 
-
 static uword RemapExceptionPCForDeopt(Thread* thread,
                                       uword program_counter,
                                       uword frame_pointer) {
 #if !defined(TARGET_ARCH_DBC)
   MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
       thread->isolate()->pending_deopts();
   if (pending_deopts->length() > 0) {
     // Check if the target frame is scheduled for lazy deopt.
     for (intptr_t i = 0; i < pending_deopts->length(); i++) {
       if ((*pending_deopts)[i].fp() == frame_pointer) {
         // Deopt should now resume in the catch handler instead of after the
         // call.
         (*pending_deopts)[i].set_pc(program_counter);
 
         // Jump to the deopt stub instead of the catch handler.
         program_counter =
             StubCode::DeoptimizeLazyFromThrow_entry()->EntryPoint();
         if (FLAG_trace_deoptimization) {
           THR_Print("Throwing to frame scheduled for lazy deopt fp=%" Pp "\n",
                     frame_pointer);
         }
         break;
       }
     }
   }
 #endif  // !DBC
   return program_counter;
 }
 
-
 static void ClearLazyDeopts(Thread* thread, uword frame_pointer) {
 #if !defined(TARGET_ARCH_DBC)
   MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
       thread->isolate()->pending_deopts();
   if (pending_deopts->length() > 0) {
     // We may be jumping over frames scheduled for lazy deopt. Remove these
     // frames from the pending deopt table, but only after unmarking them so
     // any stack walk that happens before the stack is unwound will still work.
     {
       DartFrameIterator frames(thread,
@@ skipping 23 matching lines @@
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
   }
 #endif  // !DBC
 }
 
-
 static void JumpToExceptionHandler(Thread* thread,
                                    uword program_counter,
                                    uword stack_pointer,
                                    uword frame_pointer,
                                    const Object& exception_object,
                                    const Object& stacktrace_object) {
   uword remapped_pc =
       RemapExceptionPCForDeopt(thread, program_counter, frame_pointer);
   thread->set_active_exception(exception_object);
   thread->set_active_stacktrace(stacktrace_object);
   thread->set_resume_pc(remapped_pc);
   uword run_exception_pc = StubCode::RunExceptionHandler_entry()->EntryPoint();
   Exceptions::JumpToFrame(thread, run_exception_pc, stack_pointer,
                           frame_pointer, false /* do not clear deopt */);
 }
 
-
 void Exceptions::JumpToFrame(Thread* thread,
                              uword program_counter,
                              uword stack_pointer,
                              uword frame_pointer,
                              bool clear_deopt_at_target) {
   uword fp_for_clearing =
       (clear_deopt_at_target ? frame_pointer + 1 : frame_pointer);
   ClearLazyDeopts(thread, fp_for_clearing);
 #if defined(USING_SIMULATOR)
   // Unwinding of the C++ frames and destroying of their stack resources is done
@@ skipping 21 matching lines @@
   // Unpoison the stack before we tear it down in the generated stub code.
   uword current_sp = Thread::GetCurrentStackPointer() - 1024;
   ASAN_UNPOISON(reinterpret_cast<void*>(current_sp),
                 stack_pointer - current_sp);
 
   func(program_counter, stack_pointer, frame_pointer, thread);
 #endif
   UNREACHABLE();
 }
 
-
 static RawField* LookupStackTraceField(const Instance& instance) {
   if (instance.GetClassId() < kNumPredefinedCids) {
     // 'class Error' is not a predefined class.
     return Field::null();
   }
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   Class& error_class =
       Class::Handle(zone, isolate->object_store()->error_class());
@@ skipping 12 matching lines @@
           Symbols::_stackTrace());
     }
     type = test_class.super_type();
     if (type.IsNull()) return Field::null();
     test_class = type.type_class();
   }
   UNREACHABLE();
   return Field::null();
 }
 
-
 RawStackTrace* Exceptions::CurrentStackTrace() {
   return GetStackTraceForException();
 }
 
-
 static void ThrowExceptionHelper(Thread* thread,
                                  const Instance& incoming_exception,
                                  const Instance& existing_stacktrace,
                                  const bool is_rethrow) {
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   bool use_preallocated_stacktrace = false;
   Instance& exception = Instance::Handle(zone, incoming_exception.raw());
   if (exception.IsNull()) {
     exception ^=
@@ skipping 79 matching lines @@
     // the isolate etc.).
     const UnhandledException& unhandled_exception = UnhandledException::Handle(
         zone, UnhandledException::New(exception, stacktrace));
     stacktrace = StackTrace::null();
     JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
                            unhandled_exception, stacktrace);
   }
   UNREACHABLE();
 }
 
-
 // Static helpers for allocating, initializing, and throwing an error instance.
 
 // Return the script of the Dart function that called the native entry or the
 // runtime entry. The frame iterator points to the callee.
 RawScript* Exceptions::GetCallerScript(DartFrameIterator* iterator) {
   StackFrame* caller_frame = iterator->NextFrame();
   ASSERT(caller_frame != NULL && caller_frame->IsDartFrame());
   const Function& caller = Function::Handle(caller_frame->LookupDartFunction());
   ASSERT(!caller.IsNull());
   return caller.script();
 }
 
-
 // Allocate a new instance of the given class name.
 // TODO(hausner): Rename this NewCoreInstance to call out the fact that
 // the class name is resolved in the core library implicitly?
 RawInstance* Exceptions::NewInstance(const char* class_name) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const String& cls_name =
       String::Handle(zone, Symbols::New(thread, class_name));
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   // No ambiguity error expected: passing NULL.
   Class& cls = Class::Handle(core_lib.LookupClass(cls_name));
   ASSERT(!cls.IsNull());
   // There are no parameterized error types, so no need to set type arguments.
   return Instance::New(cls);
 }
 
-
 // Allocate, initialize, and throw a TypeError or CastError.
 // If error_msg is not null, throw a TypeError, even for a type cast.
 void Exceptions::CreateAndThrowTypeError(TokenPosition location,
                                          const AbstractType& src_type,
                                          const AbstractType& dst_type,
                                          const String& dst_name,
                                          const String& bound_error_msg) {
   ASSERT(!dst_name.IsNull());  // Pass Symbols::Empty() instead.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
@@ skipping 90 matching lines @@
     THR_Print("'%s': Failed type check: line %" Pd " pos %" Pd ": ",
               String::Handle(zone, script.url()).ToCString(), line, column);
     THR_Print("%s\n", error_msg.ToCString());
   }
 
   // Throw TypeError or CastError instance.
   Exceptions::ThrowByType(exception_type, args);
   UNREACHABLE();
 }
 
-
 void Exceptions::Throw(Thread* thread, const Instance& exception) {
   // Do not notify debugger on stack overflow and out of memory exceptions.
   // The VM would crash when the debugger calls back into the VM to
   // get values of variables.
   if (FLAG_support_debugger) {
     Isolate* isolate = thread->isolate();
     if (exception.raw() != isolate->object_store()->out_of_memory() &&
         exception.raw() != isolate->object_store()->stack_overflow()) {
       isolate->debugger()->PauseException(exception);
     }
   }
   // Null object is a valid exception object.
   ThrowExceptionHelper(thread, exception, StackTrace::Handle(thread->zone()),
                        false);
 }
 
-
 void Exceptions::ReThrow(Thread* thread,
                          const Instance& exception,
                          const Instance& stacktrace) {
   // Null object is a valid exception object.
   ThrowExceptionHelper(thread, exception, stacktrace, true);
 }
 
-
 void Exceptions::PropagateError(const Error& error) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(thread->top_exit_frame_info() != 0);
   if (error.IsUnhandledException()) {
     // If the error object represents an unhandled exception, then
     // rethrow the exception in the normal fashion.
     const UnhandledException& uhe = UnhandledException::Cast(error);
     const Instance& exc = Instance::Handle(zone, uhe.exception());
     const Instance& stk = Instance::Handle(zone, uhe.stacktrace());
     Exceptions::ReThrow(thread, exc, stk);
   } else {
     // Return to the invocation stub and return this error object.  The
     // C++ code which invoked this dart sequence can check and do the
     // appropriate thing.
     uword handler_pc = 0;
     uword handler_sp = 0;
     uword handler_fp = 0;
     FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
     JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp, error,
                            StackTrace::Handle(zone));  // Null stacktrace.
   }
   UNREACHABLE();
 }
 
-
 void Exceptions::ThrowByType(ExceptionType type, const Array& arguments) {
   Thread* thread = Thread::Current();
   const Object& result =
       Object::Handle(thread->zone(), Create(type, arguments));
   if (result.IsError()) {
     // We got an error while constructing the exception object.
     // Propagate the error instead of throwing the exception.
     PropagateError(Error::Cast(result));
   } else {
     ASSERT(result.IsInstance());
     Throw(thread, Instance::Cast(result));
   }
 }
 
-
 void Exceptions::ThrowOOM() {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   const Instance& oom = Instance::Handle(
       thread->zone(), isolate->object_store()->out_of_memory());
   Throw(thread, oom);
 }
 
-
 void Exceptions::ThrowStackOverflow() {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   const Instance& stack_overflow = Instance::Handle(
       thread->zone(), isolate->object_store()->stack_overflow());
   Throw(thread, stack_overflow);
 }
 
-
 void Exceptions::ThrowArgumentError(const Instance& arg) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, arg);
   Exceptions::ThrowByType(Exceptions::kArgument, args);
 }
 
-
 void Exceptions::ThrowRangeError(const char* argument_name,
                                  const Integer& argument_value,
                                  intptr_t expected_from,
                                  intptr_t expected_to) {
   const Array& args = Array::Handle(Array::New(4));
   args.SetAt(0, argument_value);
   args.SetAt(1, Integer::Handle(Integer::New(expected_from)));
   args.SetAt(2, Integer::Handle(Integer::New(expected_to)));
   args.SetAt(3, String::Handle(String::New(argument_name)));
   Exceptions::ThrowByType(Exceptions::kRange, args);
 }
 
-
 void Exceptions::ThrowRangeErrorMsg(const char* msg) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, String::Handle(String::New(msg)));
   Exceptions::ThrowByType(Exceptions::kRangeMsg, args);
 }
 
-
 void Exceptions::ThrowCompileTimeError(const LanguageError& error) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, String::Handle(error.FormatMessage()));
   Exceptions::ThrowByType(Exceptions::kCompileTimeError, args);
 }
 
-
 RawObject* Exceptions::Create(ExceptionType type, const Array& arguments) {
   Library& library = Library::Handle();
   const String* class_name = NULL;
   const String* constructor_name = &Symbols::Dot();
   switch (type) {
     case kNone:
     case kStackOverflow:
     case kOutOfMemory:
       UNREACHABLE();
       break;
@@ skipping 71 matching lines @@
       class_name = &Symbols::_CompileTimeError();
       break;
   }
 
   Thread* thread = Thread::Current();
   NoReloadScope no_reload_scope(thread->isolate(), thread);
   return DartLibraryCalls::InstanceCreate(library, *class_name,
                                           *constructor_name, arguments);
 }
 
-
 }  // namespace dart