Improve the casing of Stackmap and Stacktrace.

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"
@@ skipping 10 matching lines @@
 
 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 {
+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 {
+class RegularStackTraceBuilder : public StackTraceBuilder {
  public:
-  explicit RegularStacktraceBuilder(Zone* zone)
+  explicit RegularStackTraceBuilder(Zone* zone)
       : code_list_(
             GrowableObjectArray::Handle(zone, GrowableObjectArray::New())),
         pc_offset_list_(
             GrowableObjectArray::Handle(zone, GrowableObjectArray::New())) {}
-  ~RegularStacktraceBuilder() {}
+  ~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);
+  DISALLOW_COPY_AND_ASSIGN(RegularStackTraceBuilder);
 };
 
 
-class PreallocatedStacktraceBuilder : public StacktraceBuilder {
+class PreallocatedStackTraceBuilder : public StackTraceBuilder {
  public:
-  explicit PreallocatedStacktraceBuilder(const Instance& stacktrace)
-      : stacktrace_(Stacktrace::Cast(stacktrace)),
+  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() {}
+  ~PreallocatedStackTraceBuilder() {}
 
   virtual void AddFrame(const Code& code, const Smi& offset);
 
  private:
-  static const int kNumTopframes = Stacktrace::kPreallocatedStackdepth / 2;
+  static const int kNumTopframes = StackTrace::kPreallocatedStackdepth / 2;
 
-  const Stacktrace& stacktrace_;
+  const StackTrace& stacktrace_;
   intptr_t cur_index_;
   intptr_t dropped_frames_;
 
-  DISALLOW_COPY_AND_ASSIGN(PreallocatedStacktraceBuilder);
+  DISALLOW_COPY_AND_ASSIGN(PreallocatedStackTraceBuilder);
 };
 
 
-void PreallocatedStacktraceBuilder::AddFrame(const Code& code,
+void PreallocatedStackTraceBuilder::AddFrame(const Code& code,
                                              const Smi& offset) {
-  if (cur_index_ >= Stacktrace::kPreallocatedStackdepth) {
+  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 start = StackTrace::kPreallocatedStackdepth - (kNumTopframes - 1);
     intptr_t null_slot = start - 2;
     // We are going to drop one frame.
     dropped_frames_++;
     // Add an empty slot to indicate the overflow so that the toString
     // method can account for the overflow.
     if (stacktrace_.FunctionAtFrame(null_slot) != Function::null()) {
       stacktrace_.SetCodeAtFrame(null_slot, frame_code);
       // We drop an extra frame here too.
       dropped_frames_++;
     }
     // Encode the number of dropped frames into the pc offset.
     frame_offset ^= Smi::New(dropped_frames_);
     stacktrace_.SetPcOffsetAtFrame(null_slot, frame_offset);
     // Move frames one slot down so that we can accomodate the new frame.
-    for (intptr_t i = start; i < Stacktrace::kPreallocatedStackdepth; i++) {
+    for (intptr_t i = start; i < StackTrace::kPreallocatedStackdepth; i++) {
       intptr_t prev = (i - 1);
       frame_code = stacktrace_.CodeAtFrame(i);
       frame_offset = stacktrace_.PcOffsetAtFrame(i);
       stacktrace_.SetCodeAtFrame(prev, frame_code);
       stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
     }
-    cur_index_ = (Stacktrace::kPreallocatedStackdepth - 1);
+    cur_index_ = (StackTrace::kPreallocatedStackdepth - 1);
   }
   stacktrace_.SetCodeAtFrame(cur_index_, code);
   stacktrace_.SetPcOffsetAtFrame(cur_index_, offset);
   cur_index_ += 1;
 }
 
 
-static void BuildStackTrace(StacktraceBuilder* builder) {
+static void BuildStackTrace(StackTraceBuilder* builder) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   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());
@@ skipping 192 matching lines @@
   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) {
+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());
   if (error_class.IsNull()) {
@@ skipping 12 matching lines @@
     }
     type = test_class.super_type();
     if (type.IsNull()) return Field::null();
     test_class = type.type_class();
   }
   UNREACHABLE();
   return Field::null();
 }
 
 
-RawStacktrace* Exceptions::CurrentStacktrace() {
+RawStackTrace* Exceptions::CurrentStackTrace() {
   Zone* zone = Thread::Current()->zone();
-  RegularStacktraceBuilder frame_builder(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 Stacktrace& full_stacktrace = Stacktrace::Handle(
-      Stacktrace::New(full_code_array, full_pc_offset_array));
+  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();
@@ skipping 20 matching lines @@
     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();
     }
     stacktrace ^= isolate->object_store()->preallocated_stack_trace();
-    PreallocatedStacktraceBuilder frame_builder(stacktrace);
+    PreallocatedStackTraceBuilder frame_builder(stacktrace);
     if (handler_needs_stacktrace) {
       BuildStackTrace(&frame_builder);
     }
   } else {
     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);
       stacktrace = existing_stacktrace.raw();
     } else {
       // Get stacktrace field of class Error to determine whether we have a
       // subclass of Error which carries around its stack trace.
       const Field& stacktrace_field =
-          Field::Handle(zone, LookupStacktraceField(exception));
+          Field::Handle(zone, LookupStackTraceField(exception));
       if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
         // Collect the stacktrace if needed.
         ASSERT(existing_stacktrace.IsNull());
-        stacktrace = Exceptions::CurrentStacktrace();
+        stacktrace = Exceptions::CurrentStackTrace();
         // If we have an Error object, then set its stackTrace field only if it
         // not yet initialized.
         if (!stacktrace_field.IsNull() &&
             (exception.GetField(stacktrace_field) == Object::null())) {
           exception.SetField(stacktrace_field, stacktrace);
         }
       }
     }
   }
   // We expect to find a handler_pc, if the exception is unhandled
@@ skipping 13 matching lines @@
   } 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();
+    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
@@ skipping 138 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()),
+  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 12 matching lines @@
     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.
+                           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()) {
@@ skipping 131 matching lines @@
       class_name = &Symbols::_CompileTimeError();
       break;
   }
 
   return DartLibraryCalls::InstanceCreate(library, *class_name,
                                           *constructor_name, arguments);
 }
 
 
 }  // namespace dart