jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlass.cpp

equal deleted inserted replaced

-:693c6b883b54
+:8c1e3dd5fe1b
 #include "jvmtifiles/jvmti.h"
 #include "memory/genOopClosures.inline.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/permGen.hpp"
 #include "oops/instanceKlass.hpp"
+#include "oops/instanceMirrorKlass.hpp"
 #include "oops/instanceOop.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/objArrayKlassKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 JavaCalls::call(&result, mh, &args, CHECK_NULL);
 return h_i();
 }
 instanceOop instanceKlass::allocate_instance(TRAPS) {
+assert(!oop_is_instanceMirror(), "wrong allocation path");
 bool has_finalizer_flag = has_finalizer(); // Query before possible GC
 int size = size_helper();  // Query before forming handle.
 KlassHandle h_k(THREAD, as_klassOop());
 // Finalizer registration occurs in the Object.<init> constructor
 // and constructors normally aren't run when allocating perm
 // instances so simply disallow finalizable perm objects.  This can
 // be relaxed if a need for it is found.
 assert(!has_finalizer(), "perm objects not allowed to have finalizers");
+assert(!oop_is_instanceMirror(), "wrong allocation path");
 int size = size_helper();  // Query before forming handle.
 KlassHandle h_k(THREAD, as_klassOop());
 instanceOop i = (instanceOop)
 CollectedHeap::permanent_obj_allocate(h_k, size, CHECK_NULL);
 return i;
 methodOop m = methodOop(methods()->obj_at(index));
 assert(m->is_method(), "must be method");
 f(m);
 }
 }
 void instanceKlass::do_local_static_fields(FieldClosure* cl) {
 fieldDescriptor fd;
 int length = fields()->length();
 for (int i = 0; i < length; i += next_offset) {
 // The following macros call specialized macros, passing either oop or
 // narrowOop as the specialization type.  These test the UseCompressedOops
 // flag.
-#define InstanceKlass_OOP_ITERATE(start_p, count,    \
-do_oop, assert_fn) \
-{                                                    \
-if (UseCompressedOops) {                           \
-InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
-start_p, count,                                \
-do_oop, assert_fn)                             \
-} else {                                           \
-InstanceKlass_SPECIALIZED_OOP_ITERATE(oop,       \
-start_p, count,                                \
-do_oop, assert_fn)                             \
-}                                                  \
-}
-#define InstanceKlass_BOUNDED_OOP_ITERATE(start_p, count, low, high,    \
-do_oop, assert_fn) \
-{                                                            \
-if (UseCompressedOops) {                                   \
-InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
-start_p, count,                                        \
-low, high,                                             \
-do_oop, assert_fn)                                     \
-} else {                                                   \
-InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop,       \
-start_p, count,                                        \
-low, high,                                             \
-do_oop, assert_fn)                                     \
-}                                                          \
-}
 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn)            \
 {                                                                        \
 /* Compute oopmap block range. The common case                         \
 is nonstatic_oop_map_size == 1. */                                  \
 OopMapBlock* map           = start_of_nonstatic_oop_maps();            \
 ++map;                                                             \
 }                                                                    \
 }                                                                      \
 }
-void instanceKlass::follow_static_fields() {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-MarkSweep::mark_and_push(p), \
-assert_is_in_closed_subset)
-}
-#ifndef SERIALGC
-void instanceKlass::follow_static_fields(ParCompactionManager* cm) {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-PSParallelCompact::mark_and_push(cm, p), \
-assert_is_in)
-}
-#endif // SERIALGC
-void instanceKlass::adjust_static_fields() {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-MarkSweep::adjust_pointer(p), \
-assert_nothing)
-}
-#ifndef SERIALGC
-void instanceKlass::update_static_fields() {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-PSParallelCompact::adjust_pointer(p), \
-assert_nothing)
-}
-#endif // SERIALGC
 void instanceKlass::oop_follow_contents(oop obj) {
 assert(obj != NULL, "can't follow the content of NULL object");
 obj->follow_header();
 InstanceKlass_OOP_MAP_ITERATE( \
 obj, \
 #ifndef SERIALGC
 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
-void instanceKlass::iterate_static_fields(OopClosure* closure) {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-closure->do_oop(p), \
-assert_is_in_reserved)
-}
-void instanceKlass::iterate_static_fields(OopClosure* closure,
-MemRegion mr) {
-InstanceKlass_BOUNDED_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-mr.start(), mr.end(), \
-(closure)->do_oop_v(p), \
-assert_is_in_closed_subset)
-}
 int instanceKlass::oop_adjust_pointers(oop obj) {
 int size = size_helper();
 InstanceKlass_OOP_MAP_ITERATE( \
 obj, \
 MarkSweep::adjust_pointer(p), \
 PSParallelCompact::adjust_pointer(p), \
 assert_nothing)
 return size_helper();
 }
-void instanceKlass::push_static_fields(PSPromotionManager* pm) {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-if (PSScavenge::should_scavenge(p)) { \
-pm->claim_or_forward_depth(p); \
-}, \
-assert_nothing )
-}
-void instanceKlass::copy_static_fields(ParCompactionManager* cm) {
-InstanceKlass_OOP_ITERATE( \
-start_of_static_fields(), static_oop_field_size(), \
-PSParallelCompact::adjust_pointer(p), \
-assert_is_in)
-}
 #endif // SERIALGC
 // This klass is alive but the implementor link is not followed/updated.
 // Subklass and sibling links are handled by Klass::follow_weak_klass_links
 void instanceKlass::set_source_debug_extension(Symbol* n) {
 _source_debug_extension = n;
 if (_source_debug_extension != NULL) _source_debug_extension->increment_refcount();
 }
+address instanceKlass::static_field_addr(int offset) {
+return (address)(offset + instanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
+}
 const char* instanceKlass::signature_name() const {
 const char* src = (const char*) (name()->as_C_string());
 const int src_length = (int)strlen(src);
 char* dest = NEW_RESOURCE_ARRAY(char, src_length + 3);
 #define BULLET  " - "
 void FieldPrinter::do_field(fieldDescriptor* fd) {
 _st->print(BULLET);
-if (fd->is_static() || (_obj == NULL)) {
+if (_obj == NULL) {
 fd->print_on(_st);
 _st->cr();
 } else {
 fd->print_on_for(_st, _obj);
 _st->cr();
 if (!WizardMode)  return;  // that is enough
 }
 }
 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj));
-FieldPrinter print_nonstatic_field(st, obj);
+FieldPrinter print_field(st, obj);
-do_nonstatic_fields(&print_nonstatic_field);
+do_nonstatic_fields(&print_field);
 if (as_klassOop() == SystemDictionary::Class_klass()) {
 st->print(BULLET"signature: ");
 java_lang_Class::print_signature(obj, st);
 st->cr();
 klassOop array_klass = java_lang_Class::array_klass(obj);
 st->cr();
 st->print(BULLET"fake entry for array: ");
 array_klass->print_value_on(st);
 st->cr();
+st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj));
+st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj));
+klassOop real_klass = java_lang_Class::as_klassOop(obj);
+if (real_klass && real_klass->klass_part()->oop_is_instance()) {
+instanceKlass::cast(real_klass)->do_local_static_fields(&print_field);
+}
 } else if (as_klassOop() == SystemDictionary::MethodType_klass()) {
 st->print(BULLET"signature: ");
 java_lang_invoke_MethodType::print_signature(obj, st);
 st->cr();
 }
 }
 }
 void JNIid::verify(klassOop holder) {
-int first_field_offset  = instanceKlass::cast(holder)->offset_of_static_fields();
+int first_field_offset  = instanceMirrorKlass::offset_of_static_fields();
 int end_field_offset;
 end_field_offset = first_field_offset + (instanceKlass::cast(holder)->static_field_size() * wordSize);
 JNIid* current = this;
 while (current != NULL) {

changeset 8725	8c1e3dd5fe1b
parent 8676	9098d4e927e1
child 8875	bc9f101d8df6