Improve the casing of Stackmap and Stacktrace.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 383 matching lines @@
       I->object_store()->set_symbol_class(null_class);
       I->object_store()->set_compiletime_error_class(null_class);
     }
     DropClasses();
     DropLibraries();
 
     BindStaticCalls();
     SwitchICCalls();
 
     ShareMegamorphicBuckets();
-    DedupStackmaps();
+    DedupStackMaps();
     DedupLists();
 
     if (FLAG_dedup_instructions) {
       // Reduces binary size but obfuscates profiler results.
       DedupInstructions();
     }
 
     zone_ = NULL;
   }
 
@@ skipping 1776 matching lines @@
 
   for (intptr_t i = 0; i < table.Length(); i++) {
     cache ^= table.At(i);
     cache.set_buckets(buckets);
     cache.set_mask(capacity - 1);
     cache.set_filled_entry_count(0);
   }
 }
 
 
-void Precompiler::DedupStackmaps() {
-  class DedupStackmapsVisitor : public FunctionVisitor {
+void Precompiler::DedupStackMaps() {
+  class DedupStackMapsVisitor : public FunctionVisitor {
    public:
-    explicit DedupStackmapsVisitor(Zone* zone)
+    explicit DedupStackMapsVisitor(Zone* zone)
         : zone_(zone),
           canonical_stackmaps_(),
           code_(Code::Handle(zone)),
           stackmaps_(Array::Handle(zone)),
-          stackmap_(Stackmap::Handle(zone)) {}
+          stackmap_(StackMap::Handle(zone)) {}
 
     void Visit(const Function& function) {
       if (!function.HasCode()) {
         return;
       }
       code_ = function.CurrentCode();
       stackmaps_ = code_.stackmaps();
       if (stackmaps_.IsNull()) return;
       for (intptr_t i = 0; i < stackmaps_.Length(); i++) {
         stackmap_ ^= stackmaps_.At(i);
-        stackmap_ = DedupStackmap(stackmap_);
+        stackmap_ = DedupStackMap(stackmap_);
         stackmaps_.SetAt(i, stackmap_);
       }
     }
 
-    RawStackmap* DedupStackmap(const Stackmap& stackmap) {
-      const Stackmap* canonical_stackmap =
+    RawStackMap* DedupStackMap(const StackMap& stackmap) {
+      const StackMap* canonical_stackmap =
           canonical_stackmaps_.LookupValue(&stackmap);
       if (canonical_stackmap == NULL) {
         canonical_stackmaps_.Insert(
-            &Stackmap::ZoneHandle(zone_, stackmap.raw()));
+            &StackMap::ZoneHandle(zone_, stackmap.raw()));
         return stackmap.raw();
       } else {
         return canonical_stackmap->raw();
       }
     }
 
    private:
     Zone* zone_;
-    StackmapSet canonical_stackmaps_;
+    StackMapSet canonical_stackmaps_;
     Code& code_;
     Array& stackmaps_;
-    Stackmap& stackmap_;
+    StackMap& stackmap_;
   };
 
-  DedupStackmapsVisitor visitor(Z);
+  DedupStackMapsVisitor visitor(Z);
   VisitFunctions(&visitor);
 }
 
 
 void Precompiler::DedupLists() {
   class DedupListsVisitor : public FunctionVisitor {
    public:
     explicit DedupListsVisitor(Zone* zone)
         : zone_(zone),
           canonical_lists_(),
@@ skipping 417 matching lines @@
 
   const Array& caller_inlining_id_map_array =
       Array::Handle(zone, graph_compiler->CallerInliningIdMap());
   INC_STAT(thread(), total_code_size,
            caller_inlining_id_map_array.Length() * sizeof(uword));
   code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
 
   graph_compiler->FinalizePcDescriptors(code);
   code.set_deopt_info_array(deopt_info_array);
 
-  graph_compiler->FinalizeStackmaps(code);
+  graph_compiler->FinalizeStackMaps(code);
   graph_compiler->FinalizeVarDescriptors(code);
   graph_compiler->FinalizeExceptionHandlers(code);
   graph_compiler->FinalizeStaticCallTargetsTable(code);
 
   if (optimized()) {
     // Installs code while at safepoint.
     ASSERT(thread()->IsMutatorThread());
     function.InstallOptimizedCode(code, /* is_osr = */ false);
   } else {  // not optimized.
     function.set_unoptimized_code(code);
@@ skipping 604 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart