graal-compiler: src/share/vm/oops/instanceKlass.cpp comparison

comparison src/share/vm/oops/instanceKlass.cpp @ 8124:5fc51c1ecdeb

Merge.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Tue, 05 Mar 2013 23:44:54 +0100
parents	3ac7d10a6572 927a311d00f9
children	b9a918201d47

comparison

equal deleted inserted replaced

-:a413bcd552a4
+:5fc51c1ecdeb
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "gc_interface/collectedHeap.inline.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "interpreter/rewriter.hpp"
 #include "jvmtifiles/jvmti.h"
 #include "memory/genOopClosures.inline.hpp"
+#include "memory/heapInspection.hpp"
 #include "memory/metadataFactory.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/fieldStreams.hpp"
 #include "oops/instanceClassLoaderKlass.hpp"
 #include "oops/instanceKlass.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/thread.inline.hpp"
 #include "services/threadService.hpp"
 #include "utilities/dtrace.hpp"
-#ifndef SERIALGC
+#include "utilities/macros.hpp"
+#if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
 #include "gc_implementation/g1/g1RemSet.inline.hpp"
 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
 #include "oops/oop.pcgc.inline.hpp"
-#endif
+#endif // INCLUDE_ALL_GCS
 #ifdef COMPILER1
 #include "c1/c1_Compiler.hpp"
 #endif
 #ifdef DTRACE_ENABLED
 #endif //  ndef DTRACE_ENABLED
 volatile int InstanceKlass::_total_instanceKlass_count = 0;
 Klass* InstanceKlass::allocate_instance_klass(ClassLoaderData* loader_data,
 int vtable_len,
 int itable_len,
 int static_field_size,
 int nonstatic_oop_map_size,
 ReferenceType rt,
 AccessFlags access_flags,
 Symbol* name,
 Klass* super_klass,
-KlassHandle host_klass,
+bool is_anonymous,
 TRAPS) {
 int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,
-access_flags.is_interface(),
+access_flags.is_interface(), is_anonymous);
-!host_klass.is_null());
 // Allocation
 InstanceKlass* ik;
 if (rt == REF_NONE) {
 if (name == vmSymbols::java_lang_Class()) {
 ik = new (loader_data, size, THREAD) InstanceMirrorKlass(
 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
-access_flags, !host_klass.is_null());
+access_flags, is_anonymous);
 } else if (name == vmSymbols::java_lang_ClassLoader() ||
 (SystemDictionary::ClassLoader_klass_loaded() &&
 super_klass != NULL &&
 super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) {
 ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(
 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
-access_flags, !host_klass.is_null());
+access_flags, is_anonymous);
 } else {
 // normal class
 ik = new (loader_data, size, THREAD) InstanceKlass(
 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
-access_flags, !host_klass.is_null());
+access_flags, is_anonymous);
 }
 } else {
 // reference klass
 ik = new (loader_data, size, THREAD) InstanceRefKlass(
 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
-access_flags, !host_klass.is_null());
+access_flags, is_anonymous);
 }
 Atomic::inc(&_total_instanceKlass_count);
 return ik;
 }
 obj, \
 MarkSweep::mark_and_push(p), \
 assert_is_in_closed_subset)
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 void InstanceKlass::oop_follow_contents(ParCompactionManager* cm,
 oop obj) {
 assert(obj != NULL, "can't follow the content of NULL object");
 PSParallelCompact::follow_klass(cm, obj->klass());
 // Only mark the header and let the scan of the meta-data mark
 InstanceKlass_OOP_MAP_ITERATE( \
 obj, \
 PSParallelCompact::mark_and_push(cm, p), \
 assert_is_in)
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 // closure's do_metadata() method dictates whether the given closure should be
 // applied to the klass ptr in the object header.
 #define if_do_metadata_checked(closure, nv_suffix)                    \
 (closure)->do_oop##nv_suffix(p),                                    \
 assert_is_in_closed_subset)                                         \
 return size_helper();                                                 \
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
 \
 int InstanceKlass::oop_oop_iterate_backwards##nv_suffix(oop obj,                \
 OopClosureType* closure) {        \
 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik); \
 SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::ik);\
 (closure)->do_oop##nv_suffix(p),                                            \
 assert_is_in_closed_subset)                                                 \
 return size_helper();                                                        \
 }
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 #define InstanceKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
 \
 int InstanceKlass::oop_oop_iterate##nv_suffix##_m(oop obj,              \
 OopClosureType* closure, \
 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN)
 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN)
 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 int InstanceKlass::oop_adjust_pointers(oop obj) {
 int size = size_helper();
 InstanceKlass_OOP_MAP_ITERATE( \
 obj, \
 assert_is_in)
 MarkSweep::adjust_klass(obj->klass());
 return size;
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 void InstanceKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
 obj, \
 if (PSScavenge::should_scavenge(p)) { \
 pm->claim_or_forward_depth(p); \
 assert_is_in)
 obj->update_header(cm);
 return size;
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
 assert(is_loader_alive(is_alive), "this klass should be live");
 if (is_interface()) {
 if (ClassUnloading) {
 if (source_debug_extension() != NULL) {
 st->print(BULLET"source debug extension:       ");
 st->print("%s", source_debug_extension());
 st->cr();
 }
-st->print(BULLET"annotations:       "); annotations()->print_value_on(st); st->cr();
+st->print(BULLET"class annotations:       "); class_annotations()->print_value_on(st); st->cr();
+st->print(BULLET"class type annotations:  "); class_type_annotations()->print_value_on(st); st->cr();
+st->print(BULLET"field annotations:       "); fields_annotations()->print_value_on(st); st->cr();
+st->print(BULLET"field type annotations:  "); fields_type_annotations()->print_value_on(st); st->cr();
 {
 ResourceMark rm;
 // PreviousVersionInfo objects returned via PreviousVersionWalker
 // contain a GrowableArray of handles. We have to clean up the
 // GrowableArray _after_ the PreviousVersionWalker destructor
 }
 const char* InstanceKlass::internal_name() const {
 return external_name();
 }
+#if INCLUDE_SERVICES
+// Size Statistics
+void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
+Klass::collect_statistics(sz);
+sz->_inst_size  = HeapWordSize * size_helper();
+sz->_vtab_bytes = HeapWordSize * align_object_offset(vtable_length());
+sz->_itab_bytes = HeapWordSize * align_object_offset(itable_length());
+sz->_nonstatic_oopmap_bytes = HeapWordSize *
+((is_interface() || is_anonymous()) ?
+align_object_offset(nonstatic_oop_map_size()) :
+nonstatic_oop_map_size());
+int n = 0;
+n += (sz->_methods_array_bytes         = sz->count_array(methods()));
+n += (sz->_method_ordering_bytes       = sz->count_array(method_ordering()));
+n += (sz->_local_interfaces_bytes      = sz->count_array(local_interfaces()));
+n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
+n += (sz->_signers_bytes               = sz->count_array(signers()));
+n += (sz->_fields_bytes                = sz->count_array(fields()));
+n += (sz->_inner_classes_bytes         = sz->count_array(inner_classes()));
+sz->_ro_bytes += n;
+const ConstantPool* cp = constants();
+if (cp) {
+cp->collect_statistics(sz);
+}
+const Annotations* anno = annotations();
+if (anno) {
+anno->collect_statistics(sz);
+}
+const Array<Method*>* methods_array = methods();
+if (methods()) {
+for (int i = 0; i < methods_array->length(); i++) {
+Method* method = methods_array->at(i);
+if (method) {
+sz->_method_count ++;
+method->collect_statistics(sz);
+}
+}
+}
+}
+#endif // INCLUDE_SERVICES
 // Verification
 class VerifyFieldClosure: public OopClosure {
 protected:

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/instanceKlass.cpp @ 8124:5fc51c1ecdeb