clang-format runtime/vm

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 "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.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,
+DEFINE_FLAG(bool,
+            print_stacktrace_at_throw,
+            false,
             "Prints a stack trace everytime a throw occurs.");
 
 
 class StacktraceBuilder : public ValueObject {
  public:
-  StacktraceBuilder() { }
-  virtual ~StacktraceBuilder() { }
+  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())),
+            GrowableObjectArray::Handle(zone, GrowableObjectArray::New())),
         pc_offset_list_(
-          GrowableObjectArray::Handle(zone, GrowableObjectArray::New())) { }
-  ~RegularStacktraceBuilder() { }
+            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)),
+      : stacktrace_(Stacktrace::Cast(stacktrace)),
         cur_index_(0),
         dropped_frames_(0) {
     ASSERT(stacktrace_.raw() ==
            Isolate::Current()->object_store()->preallocated_stack_trace());
   }
-  ~PreallocatedStacktraceBuilder() { }
+  ~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_;
 
@@ skipping 66 matching lines @@
                                  bool* needs_stacktrace) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   if (frame == NULL) return false;  // No Dart frame.
   bool handler_pc_set = false;
   *needs_stacktrace = false;
   bool is_catch_all = false;
   uword temp_handler_pc = kUwordMax;
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
-      if (frame->FindExceptionHandler(thread,
-                                      &temp_handler_pc,
-                                      needs_stacktrace,
-                                      &is_catch_all)) {
+      if (frame->FindExceptionHandler(thread, &temp_handler_pc,
+                                      needs_stacktrace, &is_catch_all)) {
         if (!handler_pc_set) {
           handler_pc_set = true;
           *handler_pc = temp_handler_pc;
           *handler_sp = frame->sp();
           *handler_fp = frame->fp();
         }
         if (*needs_stacktrace || is_catch_all) {
           return true;
         }
       }
@@ skipping 79 matching lines @@
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
 
     for (intptr_t i = 0; i < pending_deopts->length(); i++) {
       if ((*pending_deopts)[i].fp() < frame_pointer) {
         if (FLAG_trace_deoptimization) {
-          THR_Print("Lazy deopt skipped due to throw for "
-                    "fp=%" Pp ", pc=%" Pp "\n",
-                    (*pending_deopts)[i].fp(), (*pending_deopts)[i].pc());
+          THR_Print(
+              "Lazy deopt skipped due to throw for "
+              "fp=%" Pp ", pc=%" Pp "\n",
+              (*pending_deopts)[i].fp(), (*pending_deopts)[i].pc());
         }
         pending_deopts->RemoveAt(i);
       }
     }
 
 #if defined(DEBUG)
     ValidateFrames();
 #endif
   }
 #endif  // !DBC
@@ skipping 21 matching lines @@
   typedef void (*ExcpHandler)(uword, uword, uword, RawObject*, RawObject*,
                               Thread*);
   ExcpHandler func = reinterpret_cast<ExcpHandler>(
       StubCode::JumpToExceptionHandler_entry()->EntryPoint());
 
   // 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,
-       raw_exception, raw_stacktrace, thread);
+  func(program_counter, stack_pointer, frame_pointer, raw_exception,
+       raw_stacktrace, 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());
+  Class& error_class =
+      Class::Handle(zone, isolate->object_store()->error_class());
   if (error_class.IsNull()) {
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     error_class = core_lib.LookupClass(Symbols::Error());
     ASSERT(!error_class.IsNull());
     isolate->object_store()->set_error_class(error_class);
   }
   // If instance class extends 'class Error' return '_stackTrace' field.
   Class& test_class = Class::Handle(zone, instance.clazz());
   AbstractType& type = AbstractType::Handle(zone, AbstractType::null());
   while (true) {
     if (test_class.raw() == error_class.raw()) {
       return error_class.LookupInstanceFieldAllowPrivate(
           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() {
   Zone* zone = Thread::Current()->zone();
   RegularStacktraceBuilder frame_builder(zone);
   BuildStackTrace(&frame_builder);
 
   // Create arrays for code and pc_offset tuples of each frame.
-  const Array& full_code_array = Array::Handle(zone,
-      Array::MakeArray(frame_builder.code_list()));
-  const Array& full_pc_offset_array = Array::Handle(zone,
-      Array::MakeArray(frame_builder.pc_offset_list()));
+  const Array& full_code_array =
+      Array::Handle(zone, Array::MakeArray(frame_builder.code_list()));
+  const Array& full_pc_offset_array =
+      Array::Handle(zone, Array::MakeArray(frame_builder.pc_offset_list()));
   const Stacktrace& full_stacktrace = Stacktrace::Handle(
       Stacktrace::New(full_code_array, full_pc_offset_array));
   return full_stacktrace.raw();
 }
 
 
 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 ^= Exceptions::Create(Exceptions::kNullThrown,
-                                    Object::empty_array());
+    exception ^=
+        Exceptions::Create(Exceptions::kNullThrown, Object::empty_array());
   } else if (exception.raw() == isolate->object_store()->out_of_memory() ||
              exception.raw() == isolate->object_store()->stack_overflow()) {
     use_preallocated_stacktrace = true;
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
   Instance& stacktrace = Instance::Handle(zone);
   bool handler_exists = false;
   bool handler_needs_stacktrace = false;
   if (use_preallocated_stacktrace) {
     stacktrace ^= isolate->object_store()->preallocated_stack_trace();
     PreallocatedStacktraceBuilder frame_builder(stacktrace);
-    handler_exists = FindExceptionHandler(thread,
-                                          &handler_pc,
-                                          &handler_sp,
-                                          &handler_fp,
-                                          &handler_needs_stacktrace);
+    handler_exists =
+        FindExceptionHandler(thread, &handler_pc, &handler_sp, &handler_fp,
+                             &handler_needs_stacktrace);
     if (handler_pc == 0) {
       // No Dart frame.
       ASSERT(incoming_exception.raw() ==
              isolate->object_store()->out_of_memory());
       const UnhandledException& error = UnhandledException::Handle(
           zone, isolate->object_store()->preallocated_unhandled_exception());
       thread->long_jump_base()->Jump(1, error);
       UNREACHABLE();
     }
     if (handler_needs_stacktrace) {
       BuildStackTrace(&frame_builder);
     }
   } else {
     // Get stacktrace field of class Error. This is needed to determine whether
     // we have a subclass of Error which carries around its stack trace.
     const Field& stacktrace_field =
         Field::Handle(zone, LookupStacktraceField(exception));
 
     // Find the exception handler and determine if the handler needs a
     // stacktrace.
-    handler_exists = FindExceptionHandler(thread,
-                                          &handler_pc,
-                                          &handler_sp,
-                                          &handler_fp,
-                                          &handler_needs_stacktrace);
+    handler_exists =
+        FindExceptionHandler(thread, &handler_pc, &handler_sp, &handler_fp,
+                             &handler_needs_stacktrace);
     if (!existing_stacktrace.IsNull()) {
       // If we have an existing stack trace then this better be a rethrow. The
       // reverse is not necessarily true (e.g. Dart_PropagateError can cause
       // a rethrow being called without an existing stacktrace.)
       ASSERT(is_rethrow);
       ASSERT(stacktrace_field.IsNull() ||
              (exception.GetField(stacktrace_field) != Object::null()));
       stacktrace = existing_stacktrace.raw();
     } else if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
       // Collect the stacktrace if needed.
@@ skipping 12 matching lines @@
   // stack as Exceptions::Throw should happen only after a dart
   // invocation has been done.
   ASSERT(handler_pc != 0);
 
   if (FLAG_print_stacktrace_at_throw) {
     THR_Print("Exception '%s' thrown:\n", exception.ToCString());
     THR_Print("%s\n", stacktrace.ToCString());
   }
   if (handler_exists) {
     // Found a dart handler for the exception, jump to it.
-    JumpToExceptionHandler(thread,
-                           handler_pc,
-                           handler_sp,
-                           handler_fp,
-                           exception,
-                           stacktrace);
+    JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
+                           exception, stacktrace);
   } else {
     // No dart exception handler found in this invocation sequence,
     // so we create an unhandled exception object and return to the
     // invocation stub so that it returns this unhandled exception
     // object. The C++ code which invoked this dart sequence can check
     // and do the appropriate thing (rethrow the exception to the
     // dart invocation sequence above it, print diagnostics and terminate
     // 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);
+    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 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.
   Zone* zone = Thread::Current()->zone();
   const Array& args = Array::Handle(zone, Array::New(4));
 
   ExceptionType exception_type =
       (bound_error_msg.IsNull() &&
-       (dst_name.raw() == Symbols::InTypeCast().raw())) ? kCast : kType;
+       (dst_name.raw() == Symbols::InTypeCast().raw()))
+          ? kCast
+          : kType;
 
   DartFrameIterator iterator;
   const Script& script = Script::Handle(zone, GetCallerScript(&iterator));
   intptr_t line;
   intptr_t column = -1;
   if (script.HasSource()) {
     script.GetTokenLocation(location, &line, &column);
   } else {
     script.GetTokenLocation(location, &line, NULL);
   }
   // Initialize '_url', '_line', and '_column' arguments.
   args.SetAt(0, String::Handle(zone, script.url()));
   args.SetAt(1, Smi::Handle(zone, Smi::New(line)));
   args.SetAt(2, Smi::Handle(zone, Smi::New(column)));
 
   // Construct '_errorMsg'.
-  const GrowableObjectArray& pieces = GrowableObjectArray::Handle(zone,
-      GrowableObjectArray::New(20));
+  const GrowableObjectArray& pieces =
+      GrowableObjectArray::Handle(zone, GrowableObjectArray::New(20));
 
   // Print bound error first, if any.
   if (!bound_error_msg.IsNull() && (bound_error_msg.Length() > 0)) {
     pieces.Add(bound_error_msg);
     pieces.Add(Symbols::NewLine());
   }
 
   // If dst_type is malformed or malbounded, only print the embedded error.
   if (!dst_type.IsNull()) {
     const LanguageError& error = LanguageError::Handle(zone, dst_type.error());
@@ skipping 64 matching lines @@
   // 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);
+  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);
 }
 
 
@@ skipping 156 matching lines @@
     case kCyclicInitializationError:
       library = Library::CoreLibrary();
       class_name = &Symbols::CyclicInitializationError();
       break;
     case kCompileTimeError:
       library = Library::CoreLibrary();
       class_name = &Symbols::_CompileTimeError();
       break;
   }
 
-  return DartLibraryCalls::InstanceCreate(library,
-                                          *class_name,
-                                          *constructor_name,
-                                          arguments);
+  return DartLibraryCalls::InstanceCreate(library, *class_name,
+                                          *constructor_name, arguments);
 }
 
 
 }  // namespace dart