hotspot/src/share/vm/oops/instanceKlass.cpp
changeset 46444 677be3444372
parent 46431 87b0d1afe03e
child 46458 3c12af929e7d
equal deleted inserted replaced
46443:cdb638b5ec53 46444:677be3444372
    39 #include "gc/shared/specialized_oop_closures.hpp"
    39 #include "gc/shared/specialized_oop_closures.hpp"
    40 #include "interpreter/oopMapCache.hpp"
    40 #include "interpreter/oopMapCache.hpp"
    41 #include "interpreter/rewriter.hpp"
    41 #include "interpreter/rewriter.hpp"
    42 #include "jvmtifiles/jvmti.h"
    42 #include "jvmtifiles/jvmti.h"
    43 #include "logging/log.hpp"
    43 #include "logging/log.hpp"
       
    44 #include "logging/logMessage.hpp"
    44 #include "memory/heapInspection.hpp"
    45 #include "memory/heapInspection.hpp"
    45 #include "memory/iterator.inline.hpp"
    46 #include "memory/iterator.inline.hpp"
    46 #include "memory/metadataFactory.hpp"
    47 #include "memory/metadataFactory.hpp"
    47 #include "memory/metaspaceShared.hpp"
    48 #include "memory/metaspaceShared.hpp"
    48 #include "memory/oopFactory.hpp"
    49 #include "memory/oopFactory.hpp"
    70 #include "services/classLoadingService.hpp"
    71 #include "services/classLoadingService.hpp"
    71 #include "services/threadService.hpp"
    72 #include "services/threadService.hpp"
    72 #include "utilities/dtrace.hpp"
    73 #include "utilities/dtrace.hpp"
    73 #include "utilities/macros.hpp"
    74 #include "utilities/macros.hpp"
    74 #include "utilities/stringUtils.hpp"
    75 #include "utilities/stringUtils.hpp"
    75 #include "logging/log.hpp"
       
    76 #ifdef COMPILER1
    76 #ifdef COMPILER1
    77 #include "c1/c1_Compiler.hpp"
    77 #include "c1/c1_Compiler.hpp"
    78 #endif
    78 #endif
    79 
    79 
    80 #ifdef DTRACE_ENABLED
    80 #ifdef DTRACE_ENABLED
  3056 
  3056 
  3057 const char* InstanceKlass::internal_name() const {
  3057 const char* InstanceKlass::internal_name() const {
  3058   return external_name();
  3058   return external_name();
  3059 }
  3059 }
  3060 
  3060 
  3061 void InstanceKlass::print_loading_log(LogLevel::type type,
  3061 void InstanceKlass::print_class_load_logging(ClassLoaderData* loader_data,
  3062                                       ClassLoaderData* loader_data,
  3062                                              const char* module_name,
  3063                                       const char* module_name,
  3063                                              const ClassFileStream* cfs) const {
  3064                                       const ClassFileStream* cfs) const {
  3064   if (!log_is_enabled(Info, class, load)) {
       
  3065     return;
       
  3066   }
       
  3067 
  3065   ResourceMark rm;
  3068   ResourceMark rm;
  3066   outputStream* log;
  3069   LogMessage(class, load) msg;
  3067 
  3070   stringStream info_stream;
  3068   assert(type == LogLevel::Info || type == LogLevel::Debug, "sanity");
       
  3069 
       
  3070   if (type == LogLevel::Info) {
       
  3071     log = Log(class, load)::info_stream();
       
  3072   } else {
       
  3073     assert(type == LogLevel::Debug,
       
  3074            "print_loading_log supports only Debug and Info levels");
       
  3075     log = Log(class, load)::debug_stream();
       
  3076   }
       
  3077 
  3071 
  3078   // Name and class hierarchy info
  3072   // Name and class hierarchy info
  3079   log->print("%s", external_name());
  3073   info_stream.print("%s", external_name());
  3080 
  3074 
  3081   // Source
  3075   // Source
  3082   if (cfs != NULL) {
  3076   if (cfs != NULL) {
  3083     if (cfs->source() != NULL) {
  3077     if (cfs->source() != NULL) {
  3084       if (module_name != NULL) {
  3078       if (module_name != NULL) {
  3085         if (ClassLoader::is_jrt(cfs->source())) {
  3079         if (ClassLoader::is_jrt(cfs->source())) {
  3086           log->print(" source: jrt:/%s", module_name);
  3080           info_stream.print(" source: jrt:/%s", module_name);
  3087         } else {
  3081         } else {
  3088           log->print(" source: %s", cfs->source());
  3082           info_stream.print(" source: %s", cfs->source());
  3089         }
  3083         }
  3090       } else {
  3084       } else {
  3091         log->print(" source: %s", cfs->source());
  3085         info_stream.print(" source: %s", cfs->source());
  3092       }
  3086       }
  3093     } else if (loader_data == ClassLoaderData::the_null_class_loader_data()) {
  3087     } else if (loader_data == ClassLoaderData::the_null_class_loader_data()) {
  3094       Thread* THREAD = Thread::current();
  3088       Thread* THREAD = Thread::current();
  3095       Klass* caller =
  3089       Klass* caller =
  3096             THREAD->is_Java_thread()
  3090             THREAD->is_Java_thread()
  3097                 ? ((JavaThread*)THREAD)->security_get_caller_class(1)
  3091                 ? ((JavaThread*)THREAD)->security_get_caller_class(1)
  3098                 : NULL;
  3092                 : NULL;
  3099       // caller can be NULL, for example, during a JVMTI VM_Init hook
  3093       // caller can be NULL, for example, during a JVMTI VM_Init hook
  3100       if (caller != NULL) {
  3094       if (caller != NULL) {
  3101         log->print(" source: instance of %s", caller->external_name());
  3095         info_stream.print(" source: instance of %s", caller->external_name());
  3102       } else {
  3096       } else {
  3103         // source is unknown
  3097         // source is unknown
  3104       }
  3098       }
  3105     } else {
  3099     } else {
  3106       oop class_loader = loader_data->class_loader();
  3100       oop class_loader = loader_data->class_loader();
  3107       log->print(" source: %s", class_loader->klass()->external_name());
  3101       info_stream.print(" source: %s", class_loader->klass()->external_name());
  3108     }
  3102     }
  3109   } else {
  3103   } else {
  3110     log->print(" source: shared objects file");
  3104     info_stream.print(" source: shared objects file");
  3111   }
  3105   }
  3112 
  3106 
  3113   if (type == LogLevel::Debug) {
  3107   msg.info("%s", info_stream.as_string());
       
  3108 
       
  3109   if (log_is_enabled(Debug, class, load)) {
       
  3110     stringStream debug_stream;
       
  3111 
  3114     // Class hierarchy info
  3112     // Class hierarchy info
  3115     log->print(" klass: " INTPTR_FORMAT " super: " INTPTR_FORMAT,
  3113     debug_stream.print(" klass: " INTPTR_FORMAT " super: " INTPTR_FORMAT,
  3116                p2i(this),  p2i(superklass()));
  3114                        p2i(this),  p2i(superklass()));
  3117 
  3115 
       
  3116     // Interfaces
  3118     if (local_interfaces() != NULL && local_interfaces()->length() > 0) {
  3117     if (local_interfaces() != NULL && local_interfaces()->length() > 0) {
  3119       log->print(" interfaces:");
  3118       debug_stream.print(" interfaces:");
  3120       int length = local_interfaces()->length();
  3119       int length = local_interfaces()->length();
  3121       for (int i = 0; i < length; i++) {
  3120       for (int i = 0; i < length; i++) {
  3122         log->print(" " INTPTR_FORMAT,
  3121         debug_stream.print(" " INTPTR_FORMAT,
  3123                    p2i(InstanceKlass::cast(local_interfaces()->at(i))));
  3122                            p2i(InstanceKlass::cast(local_interfaces()->at(i))));
  3124       }
  3123       }
  3125     }
  3124     }
  3126 
  3125 
  3127     // Class loader
  3126     // Class loader
  3128     log->print(" loader: [");
  3127     debug_stream.print(" loader: [");
  3129     loader_data->print_value_on(log);
  3128     loader_data->print_value_on(&debug_stream);
  3130     log->print("]");
  3129     debug_stream.print("]");
  3131 
  3130 
  3132     // Classfile checksum
  3131     // Classfile checksum
  3133     if (cfs) {
  3132     if (cfs) {
  3134       log->print(" bytes: %d checksum: %08x",
  3133       debug_stream.print(" bytes: %d checksum: %08x",
  3135                  cfs->length(),
  3134                          cfs->length(),
  3136                  ClassLoader::crc32(0, (const char*)cfs->buffer(),
  3135                          ClassLoader::crc32(0, (const char*)cfs->buffer(),
  3137                  cfs->length()));
  3136                          cfs->length()));
  3138     }
  3137     }
  3139   }
  3138 
  3140   log->cr();
  3139     msg.debug("%s", debug_stream.as_string());
       
  3140   }
  3141 }
  3141 }
  3142 
  3142 
  3143 #if INCLUDE_SERVICES
  3143 #if INCLUDE_SERVICES
  3144 // Size Statistics
  3144 // Size Statistics
  3145 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
  3145 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {