--- old/src/share/vm/aot/aotCodeHeap.cpp	2016-11-03 04:05:40.202116862 -0700
+++ new/src/share/vm/aot/aotCodeHeap.cpp	2016-11-03 04:05:40.116113046 -0700
@@ -22,14 +22,14 @@
  */
 
 #include "precompiled.hpp"
+
+#include "aot/aotLoader.hpp"
+#include "aot/aotCodeHeap.hpp"
 #include "gc/g1/heapRegion.hpp"
 #include "gc/shared/gcLocker.hpp"
 #include "jvmci/compilerRuntime.hpp"
 #include "jvmci/jvmciRuntime.hpp"
 #include "oops/method.hpp"
-#include "aot/aotLoader.hpp"
-#include "aot/aotCodeHeap.hpp"
-
 #include "runtime/os.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/vm_operations.hpp"
@@ -80,14 +80,14 @@
   }
   TempNewSymbol sym = SymbolTable::probe(name, len);
   if (sym == NULL) {
-    log_debug(aotclassresolve)("Probe failed for AOT class %s", name);
+    log_debug(aot, class, resolve)("Probe failed for AOT class %s", name);
     return NULL;
   }
   Klass* k = SystemDictionary::find_instance_or_array_klass(sym, loader, protection_domain, thread);
   assert(!thread->has_pending_exception(), "should not throw");
 
   if (k != NULL) {
-    log_info(aotclassresolve)("%s %s (lookup)", caller->method_holder()->external_name(), k->external_name());
+    log_info(aot, class, resolve)("%s %s (lookup)", caller->method_holder()->external_name(), k->external_name());
   }
   return k;
 }
@@ -267,7 +267,7 @@
   }
 }
 
-void AOTCodeHeap::publish_aot(instanceKlassHandle kh, methodHandle mh, AOTMethodData* method_data, int code_id) {
+void AOTCodeHeap::publish_aot(const methodHandle& mh, AOTMethodData* method_data, int code_id) {
   // The method may be explicitly excluded by the user.
   if (CompilerOracle::should_exclude(mh)) {
     return;
@@ -631,7 +631,7 @@
   }
 }
 
-bool AOTCodeHeap::load_klass_data(instanceKlassHandle kh, Thread* thread) {
+bool AOTCodeHeap::load_klass_data(const instanceKlassHandle& kh, Thread* thread) {
   ResourceMark rm;
 
   NOT_PRODUCT( klasses_seen++; )
@@ -643,7 +643,7 @@
 
   if (!kh->has_passed_fingerprint_check()) {
     NOT_PRODUCT( aot_klasses_fp_miss++; )
-    log_trace(aotclassfingerprint)("class  %s%s  has bad fingerprint in  %s tid=" INTPTR_FORMAT,
+    log_trace(aot, class, fingerprint)("class  %s%s  has bad fingerprint in  %s tid=" INTPTR_FORMAT,
                                    kh->internal_name(), kh->is_shared() ? " (shared)" : "",
                                    _name, p2i(thread));
     sweep_dependent_methods(klass_data);
@@ -653,7 +653,7 @@
   assert(klass_data->_class_id < _class_count, "invalid class id");
   AOTClass* aot_class = &_classes[klass_data->_class_id];
   if (aot_class->_classloader != NULL && aot_class->_classloader != kh->class_loader_data()) {
-    log_trace(aotclassload)("class  %s  in  %s already loaded for classloader %p vs %p tid=" INTPTR_FORMAT,
+    log_trace(aot, class, load)("class  %s  in  %s already loaded for classloader %p vs %p tid=" INTPTR_FORMAT,
                              kh->internal_name(), _name, aot_class->_classloader, kh->class_loader_data(), p2i(thread));
     NOT_PRODUCT( aot_klasses_cl_miss++; )
     return false;
@@ -661,7 +661,7 @@
 
   NOT_PRODUCT( aot_klasses_found++; )
 
-  log_trace(aotclassload)("found  %s  in  %s for classloader %p tid=" INTPTR_FORMAT, kh->internal_name(), _name, kh->class_loader_data(), p2i(thread));
+  log_trace(aot, class, load)("found  %s  in  %s for classloader %p tid=" INTPTR_FORMAT, kh->internal_name(), _name, kh->class_loader_data(), p2i(thread));
 
   aot_class->_classloader = kh->class_loader_data();
   // Set klass's Resolve (second) got cell.
@@ -698,7 +698,7 @@
       if (mh->code() != NULL) { // Does it have already compiled code?
         continue; // Don't overwrite
       }
-      publish_aot(kh, mh, method_data, code_id);
+      publish_aot(mh, method_data, code_id);
     }
   }
   return true;
@@ -833,7 +833,7 @@
 }
 #endif
 
-void AOTCodeHeap::flush_evol_dependents_on(instanceKlassHandle dependee) {
+void AOTCodeHeap::flush_evol_dependents_on(const instanceKlassHandle& dependee) {
   for (int index = 0; index < _method_count; index++) {
     if (_code_to_aot[index]._state != in_use) {
       continue; // Skip uninitialized entries.