Improve the casing of Stackmap and Stacktrace.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 627 matching lines @@
 
   cls = Class::New<ObjectPool>();
   object_pool_class_ = cls.raw();
 
   cls = Class::New<PcDescriptors>();
   pc_descriptors_class_ = cls.raw();
 
   cls = Class::New<CodeSourceMap>();
   code_source_map_class_ = cls.raw();
 
-  cls = Class::New<Stackmap>();
+  cls = Class::New<StackMap>();
   stackmap_class_ = cls.raw();
 
   cls = Class::New<LocalVarDescriptors>();
   var_descriptors_class_ = cls.raw();
 
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
   cls = Class::New<Context>();
   context_class_ = cls.raw();
@@ skipping 323 matching lines @@
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
   SET_CLASS_NAME(namespace, Namespace);
   SET_CLASS_NAME(code, Code);
   SET_CLASS_NAME(instructions, Instructions);
   SET_CLASS_NAME(object_pool, ObjectPool);
   SET_CLASS_NAME(code_source_map, CodeSourceMap);
   SET_CLASS_NAME(pc_descriptors, PcDescriptors);
-  SET_CLASS_NAME(stackmap, Stackmap);
+  SET_CLASS_NAME(stackmap, StackMap);
   SET_CLASS_NAME(var_descriptors, LocalVarDescriptors);
   SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
   SET_CLASS_NAME(context, Context);
   SET_CLASS_NAME(context_scope, ContextScope);
   SET_CLASS_NAME(singletargetcache, SingleTargetCache);
   SET_CLASS_NAME(unlinkedcall, UnlinkedCall);
   SET_CLASS_NAME(icdata, ICData);
   SET_CLASS_NAME(megamorphic_cache, MegamorphicCache);
   SET_CLASS_NAME(subtypetestcache, SubtypeTestCache);
   SET_CLASS_NAME(api_error, ApiError);
@@ skipping 305 matching lines @@
     pending_classes.Add(cls);
 
     cls = Class::New<ReceivePort>();
     RegisterPrivateClass(cls, Symbols::_RawReceivePortImpl(), isolate_lib);
     pending_classes.Add(cls);
 
     cls = Class::New<SendPort>();
     RegisterPrivateClass(cls, Symbols::_SendPortImpl(), isolate_lib);
     pending_classes.Add(cls);
 
-    const Class& stacktrace_cls = Class::Handle(zone, Class::New<Stacktrace>());
+    const Class& stacktrace_cls = Class::Handle(zone, Class::New<StackTrace>());
     RegisterPrivateClass(stacktrace_cls, Symbols::_StackTrace(), core_lib);
     pending_classes.Add(stacktrace_cls);
     // Super type set below, after Object is allocated.
 
     cls = Class::New<RegExp>();
     RegisterPrivateClass(cls, Symbols::_RegExp(), core_lib);
     pending_classes.Add(cls);
 
     // Initialize the base interfaces used by the core VM classes.
 
@@ skipping 204 matching lines @@
     cls = Class::New<Float64x2>();
     RegisterClass(cls, Symbols::Float64x2(), lib);
     cls.set_num_type_arguments(0);
     cls.set_num_own_type_arguments(0);
     cls.set_is_prefinalized();
     pending_classes.Add(cls);
     object_store->set_float64x2_class(cls);
     type = Type::NewNonParameterizedType(cls);
     object_store->set_float64x2_type(type);
 
-    // Set the super type of class Stacktrace to Object type so that the
+    // Set the super type of class StackTrace to Object type so that the
     // 'toString' method is implemented.
     type = object_store->object_type();
     stacktrace_cls.set_super_type(type);
 
     // Abstract class that represents the Dart class Function.
     cls = Class::New<Instance>(kIllegalCid);
     cls.set_num_type_arguments(0);
     cls.set_num_own_type_arguments(0);
     cls.set_is_prefinalized();
     RegisterClass(cls, Symbols::Function(), core_lib);
@@ skipping 172 matching lines @@
 
     cls = Class::New<Bool>();
     object_store->set_bool_class(cls);
 
     cls = Class::New<Instance>(kNullCid);
     object_store->set_null_class(cls);
 
     cls = Class::New<Capability>();
     cls = Class::New<ReceivePort>();
     cls = Class::New<SendPort>();
-    cls = Class::New<Stacktrace>();
+    cls = Class::New<StackTrace>();
     cls = Class::New<RegExp>();
     cls = Class::New<Number>();
 
     cls = Class::New<WeakProperty>();
     object_store->set_weak_property_class(cls);
 
     cls = Class::New<MirrorReference>();
     cls = Class::New<UserTag>();
 
     const Context& context = Context::Handle(zone, Context::New(0, Heap::kOld));
@@ skipping 1617 matching lines @@
     case kCodeCid:
       return Symbols::Code().raw();
     case kInstructionsCid:
       return Symbols::Instructions().raw();
     case kObjectPoolCid:
       return Symbols::ObjectPool().raw();
     case kCodeSourceMapCid:
       return Symbols::CodeSourceMap().raw();
     case kPcDescriptorsCid:
       return Symbols::PcDescriptors().raw();
-    case kStackmapCid:
-      return Symbols::Stackmap().raw();
+    case kStackMapCid:
+      return Symbols::StackMap().raw();
     case kLocalVarDescriptorsCid:
       return Symbols::LocalVarDescriptors().raw();
     case kExceptionHandlersCid:
       return Symbols::ExceptionHandlers().raw();
     case kContextCid:
       return Symbols::Context().raw();
     case kContextScopeCid:
       return Symbols::ContextScope().raw();
     case kSingleTargetCacheCid:
       return Symbols::SingleTargetCache().raw();
@@ skipping 8582 matching lines @@
 
 
 // Decode SLEB128 encoded integer. Update byte_index to the next integer.
 intptr_t CodeSourceMap::DecodeInteger(intptr_t* byte_index) const {
   NoSafepointScope no_safepoint;
   const uint8_t* data = raw_ptr()->data();
   return DecodeSLEB128(data, Length(), byte_index);
 }
 
 
-bool Stackmap::GetBit(intptr_t bit_index) const {
+bool StackMap::GetBit(intptr_t bit_index) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
   uint8_t byte = raw_ptr()->data()[byte_index];
   return (byte & byte_mask);
 }
 
 
-void Stackmap::SetBit(intptr_t bit_index, bool value) const {
+void StackMap::SetBit(intptr_t bit_index, bool value) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
   NoSafepointScope no_safepoint;
   uint8_t* byte_addr = UnsafeMutableNonPointer(&raw_ptr()->data()[byte_index]);
   if (value) {
     *byte_addr |= byte_mask;
   } else {
     *byte_addr &= ~byte_mask;
   }
 }
 
 
-RawStackmap* Stackmap::New(intptr_t pc_offset,
+RawStackMap* StackMap::New(intptr_t pc_offset,
                            BitmapBuilder* bmap,
                            intptr_t slow_path_bit_count) {
   ASSERT(Object::stackmap_class() != Class::null());
   ASSERT(bmap != NULL);
-  Stackmap& result = Stackmap::Handle();
+  StackMap& result = StackMap::Handle();
   // Guard against integer overflow of the instance size computation.
   intptr_t length = bmap->Length();
   intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
   if ((payload_size < 0) || (payload_size > kMaxLengthInBytes)) {
     // This should be caught before we reach here.
-    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n", length);
+    FATAL1("Fatal error in StackMap::New: invalid length %" Pd "\n", length);
   }
   {
-    // Stackmap data objects are associated with a code object, allocate them
+    // StackMap data objects are associated with a code object, allocate them
     // in old generation.
     RawObject* raw = Object::Allocate(
-        Stackmap::kClassId, Stackmap::InstanceSize(length), Heap::kOld);
+        StackMap::kClassId, StackMap::InstanceSize(length), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
-  // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
+  // PC. StackMapTableBuilder::FinalizeStackMaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   for (intptr_t i = 0; i < length; ++i) {
     result.SetBit(i, bmap->Get(i));
   }
   result.SetSlowPathBitCount(slow_path_bit_count);
   return result.raw();
 }
 
 
-RawStackmap* Stackmap::New(intptr_t length,
+RawStackMap* StackMap::New(intptr_t length,
                            intptr_t slow_path_bit_count,
                            intptr_t pc_offset) {
   ASSERT(Object::stackmap_class() != Class::null());
-  Stackmap& result = Stackmap::Handle();
+  StackMap& result = StackMap::Handle();
   // Guard against integer overflow of the instance size computation.
   intptr_t payload_size = Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
   if ((payload_size < 0) || (payload_size > kMaxLengthInBytes)) {
     // This should be caught before we reach here.
-    FATAL1("Fatal error in Stackmap::New: invalid length %" Pd "\n", length);
+    FATAL1("Fatal error in StackMap::New: invalid length %" Pd "\n", length);
   }
   {
-    // Stackmap data objects are associated with a code object, allocate them
+    // StackMap data objects are associated with a code object, allocate them
     // in old generation.
     RawObject* raw = Object::Allocate(
-        Stackmap::kClassId, Stackmap::InstanceSize(length), Heap::kOld);
+        StackMap::kClassId, StackMap::InstanceSize(length), Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
     result.SetLength(length);
   }
   // When constructing a stackmap we store the pc offset in the stackmap's
-  // PC. StackmapTableBuilder::FinalizeStackmaps will replace it with the pc
+  // PC. StackMapTableBuilder::FinalizeStackMaps will replace it with the pc
   // address.
   ASSERT(pc_offset >= 0);
   result.SetPcOffset(pc_offset);
   result.SetSlowPathBitCount(slow_path_bit_count);
   return result.raw();
 }
 
 
-const char* Stackmap::ToCString() const {
+const char* StackMap::ToCString() const {
 #define FORMAT "%#05x: "
   if (IsNull()) {
     return "{null}";
   } else {
     intptr_t fixed_length = OS::SNPrint(NULL, 0, FORMAT, PcOffset()) + 1;
     Thread* thread = Thread::Current();
     // Guard against integer overflow in the computation of alloc_size.
     //
     // TODO(kmillikin): We could just truncate the string if someone
     // tries to print a 2 billion plus entry stackmap.
@@ skipping 184 matching lines @@
   return raw_ptr()->data()[try_index].handler_pc_offset;
 }
 
 
 intptr_t ExceptionHandlers::OuterTryIndex(intptr_t try_index) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].outer_try_index;
 }
 
 
-bool ExceptionHandlers::NeedsStacktrace(intptr_t try_index) const {
+bool ExceptionHandlers::NeedsStackTrace(intptr_t try_index) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].needs_stacktrace;
 }
 
 
 bool ExceptionHandlers::HasCatchAll(intptr_t try_index) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
   return raw_ptr()->data()[try_index].has_catch_all;
 }
 
@@ skipping 2101 matching lines @@
   // store buffer update is not needed here.
   StorePointer(&raw_ptr()->active_instructions_, instructions.raw());
   StoreNonPointer(&raw_ptr()->entry_point_,
                   Instructions::UncheckedEntryPoint(instructions.raw()));
   StoreNonPointer(&raw_ptr()->checked_entry_point_,
                   Instructions::CheckedEntryPoint(instructions.raw()));
 #endif
 }
 
 
-RawStackmap* Code::GetStackmap(uint32_t pc_offset,
+RawStackMap* Code::GetStackMap(uint32_t pc_offset,
                                Array* maps,
-                               Stackmap* map) const {
+                               StackMap* map) const {
   // This code is used during iterating frames during a GC and hence it
   // should not in turn start a GC.
   NoSafepointScope no_safepoint;
   if (stackmaps() == Array::null()) {
     // No stack maps are present in the code object which means this
     // frame relies on tagged pointers.
-    return Stackmap::null();
+    return StackMap::null();
   }
   // A stack map is present in the code object, use the stack map to visit
   // frame slots which are marked as having objects.
   *maps = stackmaps();
-  *map = Stackmap::null();
+  *map = StackMap::null();
   for (intptr_t i = 0; i < maps->Length(); i++) {
     *map ^= maps->At(i);
     ASSERT(!map->IsNull());
     if (map->PcOffset() == pc_offset) {
       return map->raw();  // We found a stack map for this frame.
     }
   }
   // If we are missing a stack map, this must either be unoptimized code, or
   // the entry to an osr function. (In which case all stack slots are
   // considered to have tagged pointers.)
   // Running with --verify-on-transition should hit this.
   ASSERT(!is_optimized() ||
          (pc_offset == UncheckedEntryPoint() - PayloadStart()));
-  return Stackmap::null();
+  return StackMap::null();
 }
 
 
 intptr_t Code::GetCallerId(intptr_t inlined_id) const {
   if (inlined_id < 0) {
     return -1;
   }
   const Array& map = Array::Handle(GetInlinedCallerIdMap());
   if (map.IsNull() || (map.Length() == 0)) {
     return -1;
@@ skipping 757 matching lines @@
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw =
         Object::Allocate(UnhandledException::kClassId,
                          UnhandledException::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_exception(Object::null_instance());
-  result.set_stacktrace(Stacktrace::Handle());
+  result.set_stacktrace(StackTrace::Handle());
   return result.raw();
 }
 
 
 void UnhandledException::set_exception(const Instance& exception) const {
   StorePointer(&raw_ptr()->exception_, exception.raw());
 }
 
 
 void UnhandledException::set_stacktrace(const Instance& stacktrace) const {
@@ skipping 7045 matching lines @@
 }
 
 
 RawClosure* Closure::New() {
   RawObject* raw =
       Object::Allocate(Closure::kClassId, Closure::InstanceSize(), Heap::kOld);
   return reinterpret_cast<RawClosure*>(raw);
 }
 
 
-intptr_t Stacktrace::Length() const {
+intptr_t StackTrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
 
-RawFunction* Stacktrace::FunctionAtFrame(intptr_t frame_index) const {
+RawFunction* StackTrace::FunctionAtFrame(intptr_t frame_index) const {
   const Code& code = Code::Handle(CodeAtFrame(frame_index));
   return code.IsNull() ? Function::null() : code.function();
 }
 
 
-RawCode* Stacktrace::CodeAtFrame(intptr_t frame_index) const {
+RawCode* StackTrace::CodeAtFrame(intptr_t frame_index) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return reinterpret_cast<RawCode*>(code_array.At(frame_index));
 }
 
 
-void Stacktrace::SetCodeAtFrame(intptr_t frame_index, const Code& code) const {
+void StackTrace::SetCodeAtFrame(intptr_t frame_index, const Code& code) const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   code_array.SetAt(frame_index, code);
 }
 
 
-RawSmi* Stacktrace::PcOffsetAtFrame(intptr_t frame_index) const {
+RawSmi* StackTrace::PcOffsetAtFrame(intptr_t frame_index) const {
   const Array& pc_offset_array = Array::Handle(raw_ptr()->pc_offset_array_);
   return reinterpret_cast<RawSmi*>(pc_offset_array.At(frame_index));
 }
 
 
-void Stacktrace::SetPcOffsetAtFrame(intptr_t frame_index,
+void StackTrace::SetPcOffsetAtFrame(intptr_t frame_index,
                                     const Smi& pc_offset) const {
   const Array& pc_offset_array = Array::Handle(raw_ptr()->pc_offset_array_);
   pc_offset_array.SetAt(frame_index, pc_offset);
 }
 
 
-void Stacktrace::set_code_array(const Array& code_array) const {
+void StackTrace::set_code_array(const Array& code_array) const {
   StorePointer(&raw_ptr()->code_array_, code_array.raw());
 }
 
 
-void Stacktrace::set_pc_offset_array(const Array& pc_offset_array) const {
+void StackTrace::set_pc_offset_array(const Array& pc_offset_array) const {
   StorePointer(&raw_ptr()->pc_offset_array_, pc_offset_array.raw());
 }
 
 
-void Stacktrace::set_expand_inlined(bool value) const {
+void StackTrace::set_expand_inlined(bool value) const {
   StoreNonPointer(&raw_ptr()->expand_inlined_, value);
 }
 
 
-bool Stacktrace::expand_inlined() const {
+bool StackTrace::expand_inlined() const {
   return raw_ptr()->expand_inlined_;
 }
 
 
-RawStacktrace* Stacktrace::New(const Array& code_array,
+RawStackTrace* StackTrace::New(const Array& code_array,
                                const Array& pc_offset_array,
                                Heap::Space space) {
-  Stacktrace& result = Stacktrace::Handle();
+  StackTrace& result = StackTrace::Handle();
   {
-    RawObject* raw = Object::Allocate(Stacktrace::kClassId,
-                                      Stacktrace::InstanceSize(), space);
+    RawObject* raw = Object::Allocate(StackTrace::kClassId,
+                                      StackTrace::InstanceSize(), space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   result.set_code_array(code_array);
   result.set_pc_offset_array(pc_offset_array);
   result.set_expand_inlined(true);  // default.
   return result.raw();
 }
 
 
-const char* Stacktrace::ToCString() const {
+const char* StackTrace::ToCString() const {
   intptr_t idx = 0;
   return ToCStringInternal(&idx);
 }
 
 
-static intptr_t PrintOneStacktrace(Zone* zone,
+static intptr_t PrintOneStackTrace(Zone* zone,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const TokenPosition token_pos = code.GetTokenIndexOfPC(pc);
   const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
       String::Handle(zone, function.QualifiedUserVisibleName());
   const String& url = String::Handle(
@@ skipping 17 matching lines @@
                         function_name.ToCString(), url.ToCString(), line);
   } else {
     chars = OS::SCreate(zone, "#%-6" Pd " %s (%s)\n", frame_index,
                         function_name.ToCString(), url.ToCString());
   }
   frame_strings->Add(chars);
   return strlen(chars);
 }
 
 
-const char* Stacktrace::ToCStringInternal(intptr_t* frame_index,
+const char* StackTrace::ToCStringInternal(intptr_t* frame_index,
                                           intptr_t max_frames) const {
   Zone* zone = Thread::Current()->zone();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   // Iterate through the stack frames and create C string description
   // for each frame.
   intptr_t total_len = 0;
   GrowableArray<char*> frame_strings;
   for (intptr_t i = 0; (i < Length()) && (*frame_index < max_frames); i++) {
     function = FunctionAtFrame(i);
@@ skipping 22 matching lines @@
         for (InlinedFunctionsIterator it(code, pc);
              !it.Done() && (*frame_index < max_frames); it.Advance()) {
           function = it.function();
           if (function.is_visible() || FLAG_show_invisible_frames) {
             code = it.code();
             ASSERT(function.raw() == code.function());
             uword pc = it.pc();
             ASSERT(pc != 0);
             ASSERT(code.PayloadStart() <= pc);
             ASSERT(pc < (code.PayloadStart() + code.Size()));
-            total_len += PrintOneStacktrace(zone, &frame_strings, pc, function,
+            total_len += PrintOneStackTrace(zone, &frame_strings, pc, function,
                                             code, *frame_index);
             (*frame_index)++;  // To account for inlined frames.
           }
         }
       } else {
         if (function.is_visible() || FLAG_show_invisible_frames) {
-          total_len += PrintOneStacktrace(zone, &frame_strings, pc, function,
+          total_len += PrintOneStackTrace(zone, &frame_strings, pc, function,
                                           code, *frame_index);
           (*frame_index)++;
         }
       }
     }
   }
 
   // Now concatenate the frame descriptions into a single C string.
   char* chars = zone->Alloc<char>(total_len + 1);
   intptr_t index = 0;
@@ skipping 320 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart