Mercurial > hg > truffle
comparison src/share/vm/classfile/javaClasses.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 977007096840 |
children | aed758eda82a |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
36 #include "memory/universe.inline.hpp" | 36 #include "memory/universe.inline.hpp" |
37 #include "oops/fieldStreams.hpp" | 37 #include "oops/fieldStreams.hpp" |
38 #include "oops/instanceKlass.hpp" | 38 #include "oops/instanceKlass.hpp" |
39 #include "oops/instanceMirrorKlass.hpp" | 39 #include "oops/instanceMirrorKlass.hpp" |
40 #include "oops/klass.hpp" | 40 #include "oops/klass.hpp" |
41 #include "oops/klassOop.hpp" | 41 #include "oops/method.hpp" |
42 #include "oops/methodOop.hpp" | |
43 #include "oops/symbol.hpp" | 42 #include "oops/symbol.hpp" |
44 #include "oops/typeArrayOop.hpp" | 43 #include "oops/typeArrayOop.hpp" |
45 #include "runtime/fieldDescriptor.hpp" | 44 #include "runtime/fieldDescriptor.hpp" |
46 #include "runtime/handles.inline.hpp" | 45 #include "runtime/handles.inline.hpp" |
47 #include "runtime/interfaceSupport.hpp" | 46 #include "runtime/interfaceSupport.hpp" |
104 } | 103 } |
105 return NULL; | 104 return NULL; |
106 } | 105 } |
107 | 106 |
108 | 107 |
109 static bool find_field(instanceKlass* ik, | 108 static bool find_field(InstanceKlass* ik, |
110 Symbol* name_symbol, Symbol* signature_symbol, | 109 Symbol* name_symbol, Symbol* signature_symbol, |
111 fieldDescriptor* fd, | 110 fieldDescriptor* fd, |
112 bool allow_super = false) { | 111 bool allow_super = false) { |
113 if (allow_super) | 112 if (allow_super) |
114 return ik->find_field(name_symbol, signature_symbol, fd) != NULL; | 113 return ik->find_field(name_symbol, signature_symbol, fd) != NULL; |
117 } | 116 } |
118 | 117 |
119 // Helpful routine for computing field offsets at run time rather than hardcoding them | 118 // Helpful routine for computing field offsets at run time rather than hardcoding them |
120 static void | 119 static void |
121 compute_offset(int &dest_offset, | 120 compute_offset(int &dest_offset, |
122 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, | 121 Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, |
123 bool allow_super = false) { | 122 bool allow_super = false) { |
124 fieldDescriptor fd; | 123 fieldDescriptor fd; |
125 instanceKlass* ik = instanceKlass::cast(klass_oop); | 124 InstanceKlass* ik = InstanceKlass::cast(klass_oop); |
126 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { | 125 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { |
127 ResourceMark rm; | 126 ResourceMark rm; |
128 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); | 127 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); |
129 #ifndef PRODUCT | 128 #ifndef PRODUCT |
130 klass_oop->print(); | 129 klass_oop->print(); |
131 tty->print_cr("all fields:"); | 130 tty->print_cr("all fields:"); |
132 for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { | 131 for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { |
133 tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); | 132 tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); |
134 } | 133 } |
135 #endif //PRODUCT | 134 #endif //PRODUCT |
136 fatal("Invalid layout of preloaded class"); | 135 fatal("Invalid layout of preloaded class"); |
137 } | 136 } |
139 } | 138 } |
140 | 139 |
141 // Same as above but for "optional" offsets that might not be present in certain JDK versions | 140 // Same as above but for "optional" offsets that might not be present in certain JDK versions |
142 static void | 141 static void |
143 compute_optional_offset(int& dest_offset, | 142 compute_optional_offset(int& dest_offset, |
144 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, | 143 Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, |
145 bool allow_super = false) { | 144 bool allow_super = false) { |
146 fieldDescriptor fd; | 145 fieldDescriptor fd; |
147 instanceKlass* ik = instanceKlass::cast(klass_oop); | 146 InstanceKlass* ik = InstanceKlass::cast(klass_oop); |
148 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { | 147 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { |
149 dest_offset = fd.offset(); | 148 dest_offset = fd.offset(); |
150 } | 149 } |
151 } | 150 } |
152 | 151 |
159 bool java_lang_String::initialized = false; | 158 bool java_lang_String::initialized = false; |
160 | 159 |
161 void java_lang_String::compute_offsets() { | 160 void java_lang_String::compute_offsets() { |
162 assert(!initialized, "offsets should be initialized only once"); | 161 assert(!initialized, "offsets should be initialized only once"); |
163 | 162 |
164 klassOop k = SystemDictionary::String_klass(); | 163 Klass* k = SystemDictionary::String_klass(); |
165 compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::char_array_signature()); | 164 compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::char_array_signature()); |
166 compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature()); | 165 compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature()); |
167 compute_optional_offset(count_offset, k, vmSymbols::count_name(), vmSymbols::int_signature()); | 166 compute_optional_offset(count_offset, k, vmSymbols::count_name(), vmSymbols::int_signature()); |
168 compute_optional_offset(hash_offset, k, vmSymbols::hash_name(), vmSymbols::int_signature()); | 167 compute_optional_offset(hash_offset, k, vmSymbols::hash_name(), vmSymbols::int_signature()); |
169 | 168 |
170 initialized = true; | 169 initialized = true; |
171 } | 170 } |
172 | 171 |
173 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { | 172 Handle java_lang_String::basic_create(int length, TRAPS) { |
174 assert(initialized, "Must be initialized"); | 173 assert(initialized, "Must be initialized"); |
175 // Create the String object first, so there's a chance that the String | 174 // Create the String object first, so there's a chance that the String |
176 // and the char array it points to end up in the same cache line. | 175 // and the char array it points to end up in the same cache line. |
177 oop obj; | 176 oop obj; |
178 if (tenured) { | 177 obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); |
179 obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_permanent_instance(CHECK_NH); | |
180 } else { | |
181 obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); | |
182 } | |
183 | 178 |
184 // Create the char array. The String object must be handlized here | 179 // Create the char array. The String object must be handlized here |
185 // because GC can happen as a result of the allocation attempt. | 180 // because GC can happen as a result of the allocation attempt. |
186 Handle h_obj(THREAD, obj); | 181 Handle h_obj(THREAD, obj); |
187 typeArrayOop buffer; | 182 typeArrayOop buffer; |
188 if (tenured) { | |
189 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH); | |
190 } else { | |
191 buffer = oopFactory::new_charArray(length, CHECK_NH); | 183 buffer = oopFactory::new_charArray(length, CHECK_NH); |
192 } | |
193 | 184 |
194 // Point the String at the char array | 185 // Point the String at the char array |
195 obj = h_obj(); | 186 obj = h_obj(); |
196 set_value(obj, buffer); | 187 set_value(obj, buffer); |
197 // No need to zero the offset, allocation zero'ed the entire String object | 188 // No need to zero the offset, allocation zero'ed the entire String object |
200 set_count(obj, length); | 191 set_count(obj, length); |
201 | 192 |
202 return h_obj; | 193 return h_obj; |
203 } | 194 } |
204 | 195 |
205 Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) { | 196 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { |
206 Handle h_obj = basic_create(length, tenured, CHECK_NH); | 197 Handle h_obj = basic_create(length, CHECK_NH); |
207 typeArrayOop buffer = value(h_obj()); | 198 typeArrayOop buffer = value(h_obj()); |
208 for (int index = 0; index < length; index++) { | 199 for (int index = 0; index < length; index++) { |
209 buffer->char_at_put(index, unicode[index]); | 200 buffer->char_at_put(index, unicode[index]); |
210 } | 201 } |
211 return h_obj; | 202 return h_obj; |
212 } | 203 } |
213 | 204 |
214 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { | |
215 return basic_create_from_unicode(unicode, length, false, CHECK_NH); | |
216 } | |
217 | |
218 Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) { | |
219 return basic_create_from_unicode(unicode, length, JavaObjectsInPerm, CHECK_NH); | |
220 } | |
221 | |
222 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { | 205 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { |
223 Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0); | 206 Handle h_obj = create_from_unicode(unicode, length, CHECK_0); |
224 return h_obj(); | 207 return h_obj(); |
225 } | 208 } |
226 | 209 |
227 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) { | 210 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) { |
228 if (utf8_str == NULL) { | 211 if (utf8_str == NULL) { |
229 return Handle(); | 212 return Handle(); |
230 } | 213 } |
231 int length = UTF8::unicode_length(utf8_str); | 214 int length = UTF8::unicode_length(utf8_str); |
232 Handle h_obj = basic_create(length, false, CHECK_NH); | 215 Handle h_obj = basic_create(length, CHECK_NH); |
233 if (length > 0) { | 216 if (length > 0) { |
234 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); | 217 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); |
235 } | 218 } |
236 return h_obj; | 219 return h_obj; |
237 } | 220 } |
241 return h_obj(); | 224 return h_obj(); |
242 } | 225 } |
243 | 226 |
244 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) { | 227 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) { |
245 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); | 228 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); |
246 Handle h_obj = basic_create(length, false, CHECK_NH); | 229 Handle h_obj = basic_create(length, CHECK_NH); |
247 if (length > 0) { | 230 if (length > 0) { |
248 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); | 231 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); |
249 } | 232 } |
250 return h_obj; | 233 return h_obj; |
251 } | 234 } |
325 } | 308 } |
326 | 309 |
327 // Create new UNICODE buffer. Must handlize value because GC | 310 // Create new UNICODE buffer. Must handlize value because GC |
328 // may happen during String and char array creation. | 311 // may happen during String and char array creation. |
329 typeArrayHandle h_value(THREAD, value); | 312 typeArrayHandle h_value(THREAD, value); |
330 Handle string = basic_create(length, false, CHECK_NH); | 313 Handle string = basic_create(length, CHECK_NH); |
331 | 314 |
332 typeArrayOop from_buffer = h_value(); | 315 typeArrayOop from_buffer = h_value(); |
333 typeArrayOop to_buffer = java_lang_String::value(string()); | 316 typeArrayOop to_buffer = java_lang_String::value(string()); |
334 | 317 |
335 // Copy contents | 318 // Copy contents |
517 | 500 |
518 | 501 |
519 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { | 502 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { |
520 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); | 503 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); |
521 | 504 |
505 // If the offset was read from the shared archive, it was fixed up already | |
506 if (!k->is_shared()) { | |
522 if (k->oop_is_instance()) { | 507 if (k->oop_is_instance()) { |
523 // During bootstrap, java.lang.Class wasn't loaded so static field | 508 // During bootstrap, java.lang.Class wasn't loaded so static field |
524 // offsets were computed without the size added it. Go back and | 509 // offsets were computed without the size added it. Go back and |
525 // update all the static field offsets to included the size. | 510 // update all the static field offsets to included the size. |
526 for (JavaFieldStream fs(instanceKlass::cast(k())); !fs.done(); fs.next()) { | 511 for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) { |
527 if (fs.access_flags().is_static()) { | 512 if (fs.access_flags().is_static()) { |
528 int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields(); | 513 int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields(); |
529 fs.set_offset(real_offset); | 514 fs.set_offset(real_offset); |
530 } | 515 } |
531 } | 516 } |
517 } | |
532 } | 518 } |
533 create_mirror(k, CHECK); | 519 create_mirror(k, CHECK); |
534 } | 520 } |
535 | 521 |
536 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) { | 522 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) { |
539 // to support Class.getModifiers(). Instance classes recalculate | 525 // to support Class.getModifiers(). Instance classes recalculate |
540 // the cached flags after the class file is parsed, but before the | 526 // the cached flags after the class file is parsed, but before the |
541 // class is put into the system dictionary. | 527 // class is put into the system dictionary. |
542 int computed_modifiers = k->compute_modifier_flags(CHECK_0); | 528 int computed_modifiers = k->compute_modifier_flags(CHECK_0); |
543 k->set_modifier_flags(computed_modifiers); | 529 k->set_modifier_flags(computed_modifiers); |
544 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) { | 530 // Class_klass has to be loaded because it is used to allocate |
531 // the mirror. | |
532 if (SystemDictionary::Class_klass_loaded()) { | |
545 // Allocate mirror (java.lang.Class instance) | 533 // Allocate mirror (java.lang.Class instance) |
546 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); | 534 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); |
547 | 535 |
548 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass()); | 536 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass()); |
549 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); | 537 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); |
550 | 538 |
551 // It might also have a component mirror. This mirror must already exist. | 539 // It might also have a component mirror. This mirror must already exist. |
552 if (k->oop_is_javaArray()) { | 540 if (k->oop_is_array()) { |
553 Handle comp_mirror; | 541 Handle comp_mirror; |
554 if (k->oop_is_typeArray()) { | 542 if (k->oop_is_typeArray()) { |
555 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type(); | 543 BasicType type = typeArrayKlass::cast(k())->element_type(); |
556 comp_mirror = Universe::java_mirror(type); | 544 comp_mirror = Universe::java_mirror(type); |
557 assert(comp_mirror.not_null(), "must have primitive mirror"); | 545 } else { |
558 } else if (k->oop_is_objArray()) { | 546 assert(k->oop_is_objArray(), "Must be"); |
559 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass(); | 547 Klass* element_klass = objArrayKlass::cast(k())->element_klass(); |
560 if (element_klass != NULL | 548 assert(element_klass != NULL, "Must have an element klass"); |
561 && (Klass::cast(element_klass)->oop_is_instance() || | |
562 Klass::cast(element_klass)->oop_is_javaArray())) { | |
563 comp_mirror = Klass::cast(element_klass)->java_mirror(); | 549 comp_mirror = Klass::cast(element_klass)->java_mirror(); |
564 assert(comp_mirror.not_null(), "must have element mirror"); | |
565 } | |
566 // else some object array internal to the VM, like systemObjArrayKlassObj | |
567 } | 550 } |
568 if (comp_mirror.not_null()) { | 551 assert(comp_mirror.not_null(), "must have a mirror"); |
552 | |
569 // Two-way link between the array klass and its component mirror: | 553 // Two-way link between the array klass and its component mirror: |
570 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror()); | 554 arrayKlass::cast(k())->set_component_mirror(comp_mirror()); |
571 set_array_klass(comp_mirror(), k->as_klassOop()); | 555 set_array_klass(comp_mirror(), k()); |
572 } | 556 } else { |
573 } else if (k->oop_is_instance()) { | 557 assert(k->oop_is_instance(), "Must be"); |
574 // Initialize static fields | 558 // Initialize static fields |
575 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); | 559 InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); |
576 } | 560 } |
577 return mirror(); | 561 return mirror(); |
578 } else { | 562 } else { |
563 if (fixup_mirror_list() == NULL) { | |
564 GrowableArray<Klass*>* list = | |
565 new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true); | |
566 set_fixup_mirror_list(list); | |
567 } | |
568 fixup_mirror_list()->push(k()); | |
579 return NULL; | 569 return NULL; |
580 } | 570 } |
581 } | 571 } |
582 | 572 |
583 | 573 |
600 } | 590 } |
601 | 591 |
602 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { | 592 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { |
603 // This should be improved by adding a field at the Java level or by | 593 // This should be improved by adding a field at the Java level or by |
604 // introducing a new VM klass (see comment in ClassFileParser) | 594 // introducing a new VM klass (see comment in ClassFileParser) |
605 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0); | 595 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0); |
606 if (type != T_VOID) { | 596 if (type != T_VOID) { |
607 klassOop aklass = Universe::typeArrayKlassObj(type); | 597 Klass* aklass = Universe::typeArrayKlassObj(type); |
608 assert(aklass != NULL, "correct bootstrap"); | 598 assert(aklass != NULL, "correct bootstrap"); |
609 set_array_klass(java_class, aklass); | 599 set_array_klass(java_class, aklass); |
610 } | 600 } |
611 #ifdef ASSERT | 601 #ifdef ASSERT |
612 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass()); | 602 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass()); |
614 #endif | 604 #endif |
615 return java_class; | 605 return java_class; |
616 } | 606 } |
617 | 607 |
618 | 608 |
619 klassOop java_lang_Class::as_klassOop(oop java_class) { | 609 Klass* java_lang_Class::as_Klass(oop java_class) { |
620 //%note memory_2 | 610 //%note memory_2 |
621 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); | 611 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
622 klassOop k = klassOop(java_class->obj_field(_klass_offset)); | 612 Klass* k = ((Klass*)java_class->metadata_field(_klass_offset)); |
623 assert(k == NULL || k->is_klass(), "type check"); | 613 assert(k == NULL || k->is_klass(), "type check"); |
624 return k; | 614 return k; |
625 } | 615 } |
626 | 616 |
627 | 617 |
628 void java_lang_Class::set_klass(oop java_class, klassOop klass) { | 618 void java_lang_Class::set_klass(oop java_class, Klass* klass) { |
629 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); | 619 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
630 java_class->obj_field_put(_klass_offset, klass); | 620 java_class->metadata_field_put(_klass_offset, klass); |
631 } | 621 } |
632 | 622 |
633 | 623 |
634 void java_lang_Class::print_signature(oop java_class, outputStream* st) { | 624 void java_lang_Class::print_signature(oop java_class, outputStream* st) { |
635 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); | 625 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
636 Symbol* name = NULL; | 626 Symbol* name = NULL; |
637 bool is_instance = false; | 627 bool is_instance = false; |
638 if (is_primitive(java_class)) { | 628 if (is_primitive(java_class)) { |
639 name = vmSymbols::type_signature(primitive_type(java_class)); | 629 name = vmSymbols::type_signature(primitive_type(java_class)); |
640 } else { | 630 } else { |
641 klassOop k = as_klassOop(java_class); | 631 Klass* k = as_Klass(java_class); |
642 is_instance = Klass::cast(k)->oop_is_instance(); | 632 is_instance = Klass::cast(k)->oop_is_instance(); |
643 name = Klass::cast(k)->name(); | 633 name = Klass::cast(k)->name(); |
644 } | 634 } |
645 if (name == NULL) { | 635 if (name == NULL) { |
646 st->print("<null>"); | 636 st->print("<null>"); |
659 // Because this can create a new symbol, the caller has to decrement | 649 // Because this can create a new symbol, the caller has to decrement |
660 // the refcount, so make adjustment here and below for symbols returned | 650 // the refcount, so make adjustment here and below for symbols returned |
661 // that are not created or incremented due to a successful lookup. | 651 // that are not created or incremented due to a successful lookup. |
662 name->increment_refcount(); | 652 name->increment_refcount(); |
663 } else { | 653 } else { |
664 klassOop k = as_klassOop(java_class); | 654 Klass* k = as_Klass(java_class); |
665 if (!Klass::cast(k)->oop_is_instance()) { | 655 if (!Klass::cast(k)->oop_is_instance()) { |
666 name = Klass::cast(k)->name(); | 656 name = Klass::cast(k)->name(); |
667 name->increment_refcount(); | 657 name->increment_refcount(); |
668 } else { | 658 } else { |
669 ResourceMark rm; | 659 ResourceMark rm; |
678 } | 668 } |
679 return name; | 669 return name; |
680 } | 670 } |
681 | 671 |
682 | 672 |
683 klassOop java_lang_Class::array_klass(oop java_class) { | 673 Klass* java_lang_Class::array_klass(oop java_class) { |
684 klassOop k = klassOop(java_class->obj_field(_array_klass_offset)); | 674 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); |
685 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass"); | 675 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_array(), "should be array klass"); |
686 return k; | 676 return k; |
687 } | 677 } |
688 | 678 |
689 | 679 |
690 void java_lang_Class::set_array_klass(oop java_class, klassOop klass) { | 680 void java_lang_Class::set_array_klass(oop java_class, Klass* klass) { |
691 assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass"); | 681 assert(klass->is_klass() && Klass::cast(klass)->oop_is_array(), "should be array klass"); |
692 java_class->obj_field_put(_array_klass_offset, klass); | 682 java_class->metadata_field_put(_array_klass_offset, klass); |
693 } | 683 } |
694 | 684 |
695 | 685 |
696 methodOop java_lang_Class::resolved_constructor(oop java_class) { | 686 Method* java_lang_Class::resolved_constructor(oop java_class) { |
697 oop constructor = java_class->obj_field(_resolved_constructor_offset); | 687 Metadata* constructor = java_class->metadata_field(_resolved_constructor_offset); |
698 assert(constructor == NULL || constructor->is_method(), "should be method"); | 688 assert(constructor == NULL || constructor->is_method(), "should be method"); |
699 return methodOop(constructor); | 689 return ((Method*)constructor); |
700 } | 690 } |
701 | 691 |
702 | 692 |
703 void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) { | 693 void java_lang_Class::set_resolved_constructor(oop java_class, Method* constructor) { |
704 assert(constructor->is_method(), "should be method"); | 694 assert(constructor->is_method(), "should be method"); |
705 java_class->obj_field_put(_resolved_constructor_offset, constructor); | 695 java_class->metadata_field_put(_resolved_constructor_offset, constructor); |
706 } | 696 } |
707 | 697 |
708 | 698 |
709 bool java_lang_Class::is_primitive(oop java_class) { | 699 bool java_lang_Class::is_primitive(oop java_class) { |
710 // should assert: | 700 // should assert: |
711 //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); | 701 //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
712 klassOop k = klassOop(java_class->obj_field(_klass_offset)); | 702 bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL); |
713 return k == NULL; | 703 |
704 #ifdef ASSERT | |
705 if (is_primitive) { | |
706 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); | |
707 assert(k == NULL || is_java_primitive(arrayKlass::cast(k)->element_type()), | |
708 "Should be either the T_VOID primitive or a java primitive"); | |
709 } | |
710 #endif | |
711 | |
712 return is_primitive; | |
714 } | 713 } |
715 | 714 |
716 | 715 |
717 BasicType java_lang_Class::primitive_type(oop java_class) { | 716 BasicType java_lang_Class::primitive_type(oop java_class) { |
718 assert(java_lang_Class::is_primitive(java_class), "just checking"); | 717 assert(java_lang_Class::is_primitive(java_class), "just checking"); |
719 klassOop ak = klassOop(java_class->obj_field(_array_klass_offset)); | 718 Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset)); |
720 BasicType type = T_VOID; | 719 BasicType type = T_VOID; |
721 if (ak != NULL) { | 720 if (ak != NULL) { |
722 // Note: create_basic_type_mirror above initializes ak to a non-null value. | 721 // Note: create_basic_type_mirror above initializes ak to a non-null value. |
723 type = arrayKlass::cast(ak)->element_type(); | 722 type = arrayKlass::cast(ak)->element_type(); |
724 } else { | 723 } else { |
726 } | 725 } |
727 assert(Universe::java_mirror(type) == java_class, "must be consistent"); | 726 assert(Universe::java_mirror(type) == java_class, "must be consistent"); |
728 return type; | 727 return type; |
729 } | 728 } |
730 | 729 |
731 BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) { | 730 BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) { |
732 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); | 731 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); |
733 if (is_primitive(java_class)) { | 732 if (is_primitive(java_class)) { |
734 if (reference_klass != NULL) | 733 if (reference_klass != NULL) |
735 (*reference_klass) = NULL; | 734 (*reference_klass) = NULL; |
736 return primitive_type(java_class); | 735 return primitive_type(java_class); |
737 } else { | 736 } else { |
738 if (reference_klass != NULL) | 737 if (reference_klass != NULL) |
739 (*reference_klass) = as_klassOop(java_class); | 738 (*reference_klass) = as_Klass(java_class); |
740 return T_OBJECT; | 739 return T_OBJECT; |
741 } | 740 } |
742 } | 741 } |
743 | 742 |
744 | 743 |
754 | 753 |
755 void java_lang_Class::compute_offsets() { | 754 void java_lang_Class::compute_offsets() { |
756 assert(!offsets_computed, "offsets should be initialized only once"); | 755 assert(!offsets_computed, "offsets should be initialized only once"); |
757 offsets_computed = true; | 756 offsets_computed = true; |
758 | 757 |
759 klassOop klass_oop = SystemDictionary::Class_klass(); | 758 Klass* klass_oop = SystemDictionary::Class_klass(); |
760 // The classRedefinedCount field is only present starting in 1.5, | 759 // The classRedefinedCount field is only present starting in 1.5, |
761 // so don't go fatal. | 760 // so don't go fatal. |
762 compute_optional_offset(classRedefinedCount_offset, | 761 compute_optional_offset(classRedefinedCount_offset, |
763 klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); | 762 klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); |
764 | 763 |
812 | 811 |
813 | 812 |
814 void java_lang_Thread::compute_offsets() { | 813 void java_lang_Thread::compute_offsets() { |
815 assert(_group_offset == 0, "offsets should be initialized only once"); | 814 assert(_group_offset == 0, "offsets should be initialized only once"); |
816 | 815 |
817 klassOop k = SystemDictionary::Thread_klass(); | 816 Klass* k = SystemDictionary::Thread_klass(); |
818 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); | 817 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); |
819 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); | 818 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); |
820 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); | 819 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); |
821 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); | 820 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); |
822 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); | 821 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); |
1071 } | 1070 } |
1072 | 1071 |
1073 void java_lang_ThreadGroup::compute_offsets() { | 1072 void java_lang_ThreadGroup::compute_offsets() { |
1074 assert(_parent_offset == 0, "offsets should be initialized only once"); | 1073 assert(_parent_offset == 0, "offsets should be initialized only once"); |
1075 | 1074 |
1076 klassOop k = SystemDictionary::ThreadGroup_klass(); | 1075 Klass* k = SystemDictionary::ThreadGroup_klass(); |
1077 | 1076 |
1078 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); | 1077 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); |
1079 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 1078 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
1080 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); | 1079 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); |
1081 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); | 1080 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); |
1086 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); | 1085 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); |
1087 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); | 1086 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); |
1088 } | 1087 } |
1089 | 1088 |
1090 oop java_lang_Throwable::unassigned_stacktrace() { | 1089 oop java_lang_Throwable::unassigned_stacktrace() { |
1091 instanceKlass* ik = instanceKlass::cast(SystemDictionary::Throwable_klass()); | 1090 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass()); |
1092 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset); | 1091 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset); |
1093 if (UseCompressedOops) { | 1092 if (UseCompressedOops) { |
1094 return oopDesc::load_decode_heap_oop((narrowOop *)addr); | 1093 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
1095 } else { | 1094 } else { |
1096 return oopDesc::load_decode_heap_oop((oop*)addr); | 1095 return oopDesc::load_decode_heap_oop((oop*)addr); |
1132 } | 1131 } |
1133 | 1132 |
1134 | 1133 |
1135 void java_lang_Throwable::print(oop throwable, outputStream* st) { | 1134 void java_lang_Throwable::print(oop throwable, outputStream* st) { |
1136 ResourceMark rm; | 1135 ResourceMark rm; |
1137 klassOop k = throwable->klass(); | 1136 Klass* k = throwable->klass(); |
1138 assert(k != NULL, "just checking"); | 1137 assert(k != NULL, "just checking"); |
1139 st->print("%s", instanceKlass::cast(k)->external_name()); | 1138 st->print("%s", InstanceKlass::cast(k)->external_name()); |
1140 oop msg = message(throwable); | 1139 oop msg = message(throwable); |
1141 if (msg != NULL) { | 1140 if (msg != NULL) { |
1142 st->print(": %s", java_lang_String::as_utf8_string(msg)); | 1141 st->print(": %s", java_lang_String::as_utf8_string(msg)); |
1143 } | 1142 } |
1144 } | 1143 } |
1145 | 1144 |
1146 | 1145 |
1147 void java_lang_Throwable::print(Handle throwable, outputStream* st) { | 1146 void java_lang_Throwable::print(Handle throwable, outputStream* st) { |
1148 ResourceMark rm; | 1147 ResourceMark rm; |
1149 klassOop k = throwable->klass(); | 1148 Klass* k = throwable->klass(); |
1150 assert(k != NULL, "just checking"); | 1149 assert(k != NULL, "just checking"); |
1151 st->print("%s", instanceKlass::cast(k)->external_name()); | 1150 st->print("%s", InstanceKlass::cast(k)->external_name()); |
1152 oop msg = message(throwable); | 1151 oop msg = message(throwable); |
1153 if (msg != NULL) { | 1152 if (msg != NULL) { |
1154 st->print(": %s", java_lang_String::as_utf8_string(msg)); | 1153 st->print(": %s", java_lang_String::as_utf8_string(msg)); |
1155 } | 1154 } |
1156 } | 1155 } |
1157 | 1156 |
1158 // Print stack trace element to resource allocated buffer | 1157 // Print stack trace element to resource allocated buffer |
1159 char* java_lang_Throwable::print_stack_element_to_buffer(methodOop method, int bci) { | 1158 char* java_lang_Throwable::print_stack_element_to_buffer(Method* method, int bci) { |
1160 // Get strings and string lengths | 1159 // Get strings and string lengths |
1161 instanceKlass* klass = instanceKlass::cast(method->method_holder()); | 1160 InstanceKlass* klass = InstanceKlass::cast(method->method_holder()); |
1162 const char* klass_name = klass->external_name(); | 1161 const char* klass_name = klass->external_name(); |
1163 int buf_len = (int)strlen(klass_name); | 1162 int buf_len = (int)strlen(klass_name); |
1164 char* source_file_name; | 1163 char* source_file_name; |
1165 if (klass->source_file_name() == NULL) { | 1164 if (klass->source_file_name() == NULL) { |
1166 source_file_name = NULL; | 1165 source_file_name = NULL; |
1198 | 1197 |
1199 return buf; | 1198 return buf; |
1200 } | 1199 } |
1201 | 1200 |
1202 | 1201 |
1203 void java_lang_Throwable::print_stack_element(Handle stream, methodOop method, int bci) { | 1202 void java_lang_Throwable::print_stack_element(Handle stream, Method* method, int bci) { |
1204 ResourceMark rm; | 1203 ResourceMark rm; |
1205 char* buf = print_stack_element_to_buffer(method, bci); | 1204 char* buf = print_stack_element_to_buffer(method, bci); |
1206 print_to_stream(stream, buf); | 1205 print_to_stream(stream, buf); |
1207 } | 1206 } |
1208 | 1207 |
1209 void java_lang_Throwable::print_stack_element(outputStream *st, methodOop method, int bci) { | 1208 void java_lang_Throwable::print_stack_element(outputStream *st, Method* method, int bci) { |
1210 ResourceMark rm; | 1209 ResourceMark rm; |
1211 char* buf = print_stack_element_to_buffer(method, bci); | 1210 char* buf = print_stack_element_to_buffer(method, bci); |
1212 st->print_cr("%s", buf); | 1211 st->print_cr("%s", buf); |
1213 } | 1212 } |
1214 | 1213 |
1250 st->print_cr(no_stack_trace_message()); | 1249 st->print_cr(no_stack_trace_message()); |
1251 return; | 1250 return; |
1252 } | 1251 } |
1253 | 1252 |
1254 while (result.not_null()) { | 1253 while (result.not_null()) { |
1255 objArrayHandle methods (THREAD, | 1254 typeArrayHandle methods (THREAD, |
1256 objArrayOop(result->obj_at(trace_methods_offset))); | 1255 typeArrayOop(result->obj_at(trace_methods_offset))); |
1257 typeArrayHandle bcis (THREAD, | 1256 typeArrayHandle bcis (THREAD, |
1258 typeArrayOop(result->obj_at(trace_bcis_offset))); | 1257 typeArrayOop(result->obj_at(trace_bcis_offset))); |
1259 | 1258 |
1260 if (methods.is_null() || bcis.is_null()) { | 1259 if (methods.is_null() || bcis.is_null()) { |
1261 st->print_cr(no_stack_trace_message()); | 1260 st->print_cr(no_stack_trace_message()); |
1262 return; | 1261 return; |
1263 } | 1262 } |
1264 | 1263 |
1265 int length = methods()->length(); | 1264 int length = methods()->length(); |
1266 for (int index = 0; index < length; index++) { | 1265 for (int index = 0; index < length; index++) { |
1267 methodOop method = methodOop(methods()->obj_at(index)); | 1266 Method* method = ((Method*)methods()->metadata_at(index)); |
1268 if (method == NULL) goto handle_cause; | 1267 if (method == NULL) goto handle_cause; |
1269 int bci = bcis->ushort_at(index); | 1268 int bci = bcis->ushort_at(index); |
1270 print_stack_element(st, method, bci); | 1269 print_stack_element(st, method, bci); |
1271 } | 1270 } |
1272 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset))); | 1271 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset))); |
1307 print_to_stream(stream, no_stack_trace_message()); | 1306 print_to_stream(stream, no_stack_trace_message()); |
1308 return; | 1307 return; |
1309 } | 1308 } |
1310 | 1309 |
1311 while (result.not_null()) { | 1310 while (result.not_null()) { |
1312 objArrayHandle methods (thread, | 1311 typeArrayHandle methods(thread, |
1313 objArrayOop(result->obj_at(trace_methods_offset))); | 1312 typeArrayOop(result->obj_at(trace_methods_offset))); |
1314 typeArrayHandle bcis (thread, | 1313 typeArrayHandle bcis (thread, |
1315 typeArrayOop(result->obj_at(trace_bcis_offset))); | 1314 typeArrayOop(result->obj_at(trace_bcis_offset))); |
1316 | 1315 |
1317 if (methods.is_null() || bcis.is_null()) { | 1316 if (methods.is_null() || bcis.is_null()) { |
1318 print_to_stream(stream, no_stack_trace_message()); | 1317 print_to_stream(stream, no_stack_trace_message()); |
1319 return; | 1318 return; |
1320 } | 1319 } |
1321 | 1320 |
1322 int length = methods()->length(); | 1321 int length = methods()->length(); |
1323 for (int index = 0; index < length; index++) { | 1322 for (int index = 0; index < length; index++) { |
1324 methodOop method = methodOop(methods()->obj_at(index)); | 1323 Method* method = ((Method*)methods()->metadata_at(index)); |
1325 if (method == NULL) return; | 1324 if (method == NULL) return; |
1326 int bci = bcis->ushort_at(index); | 1325 int bci = bcis->ushort_at(index); |
1327 print_stack_element(stream, method, bci); | 1326 print_stack_element(stream, method, bci); |
1328 } | 1327 } |
1329 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset))); | 1328 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset))); |
1335 // to know what it looks like. | 1334 // to know what it looks like. |
1336 class BacktraceBuilder: public StackObj { | 1335 class BacktraceBuilder: public StackObj { |
1337 private: | 1336 private: |
1338 Handle _backtrace; | 1337 Handle _backtrace; |
1339 objArrayOop _head; | 1338 objArrayOop _head; |
1340 objArrayOop _methods; | 1339 typeArrayOop _methods; |
1341 typeArrayOop _bcis; | 1340 typeArrayOop _bcis; |
1341 objArrayOop _mirrors; | |
1342 int _index; | 1342 int _index; |
1343 No_Safepoint_Verifier _nsv; | 1343 No_Safepoint_Verifier _nsv; |
1344 | 1344 |
1345 public: | 1345 public: |
1346 | 1346 |
1347 enum { | 1347 enum { |
1348 trace_methods_offset = java_lang_Throwable::trace_methods_offset, | 1348 trace_methods_offset = java_lang_Throwable::trace_methods_offset, |
1349 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, | 1349 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, |
1350 trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset, | |
1350 trace_next_offset = java_lang_Throwable::trace_next_offset, | 1351 trace_next_offset = java_lang_Throwable::trace_next_offset, |
1351 trace_size = java_lang_Throwable::trace_size, | 1352 trace_size = java_lang_Throwable::trace_size, |
1352 trace_chunk_size = java_lang_Throwable::trace_chunk_size | 1353 trace_chunk_size = java_lang_Throwable::trace_chunk_size |
1353 }; | 1354 }; |
1354 | 1355 |
1355 // constructor for new backtrace | 1356 // constructor for new backtrace |
1356 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL) { | 1357 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL) { |
1357 expand(CHECK); | 1358 expand(CHECK); |
1358 _backtrace = _head; | 1359 _backtrace = _head; |
1359 _index = 0; | 1360 _index = 0; |
1360 } | 1361 } |
1361 | 1362 |
1364 Pause_No_Safepoint_Verifier pnsv(&_nsv); | 1365 Pause_No_Safepoint_Verifier pnsv(&_nsv); |
1365 | 1366 |
1366 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); | 1367 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); |
1367 objArrayHandle new_head(THREAD, head); | 1368 objArrayHandle new_head(THREAD, head); |
1368 | 1369 |
1369 objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK); | 1370 typeArrayOop methods = oopFactory::new_metaDataArray(trace_chunk_size, CHECK); |
1370 objArrayHandle new_methods(THREAD, methods); | 1371 typeArrayHandle new_methods(THREAD, methods); |
1371 | 1372 |
1372 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK); | 1373 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK); |
1373 typeArrayHandle new_bcis(THREAD, bcis); | 1374 typeArrayHandle new_bcis(THREAD, bcis); |
1374 | 1375 |
1376 objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK); | |
1377 objArrayHandle new_mirrors(THREAD, mirrors); | |
1378 | |
1375 if (!old_head.is_null()) { | 1379 if (!old_head.is_null()) { |
1376 old_head->obj_at_put(trace_next_offset, new_head()); | 1380 old_head->obj_at_put(trace_next_offset, new_head()); |
1377 } | 1381 } |
1378 new_head->obj_at_put(trace_methods_offset, new_methods()); | 1382 new_head->obj_at_put(trace_methods_offset, new_methods()); |
1379 new_head->obj_at_put(trace_bcis_offset, new_bcis()); | 1383 new_head->obj_at_put(trace_bcis_offset, new_bcis()); |
1384 new_head->obj_at_put(trace_mirrors_offset, new_mirrors()); | |
1380 | 1385 |
1381 _head = new_head(); | 1386 _head = new_head(); |
1382 _methods = new_methods(); | 1387 _methods = new_methods(); |
1383 _bcis = new_bcis(); | 1388 _bcis = new_bcis(); |
1389 _mirrors = new_mirrors(); | |
1384 _index = 0; | 1390 _index = 0; |
1385 } | 1391 } |
1386 | 1392 |
1387 oop backtrace() { | 1393 oop backtrace() { |
1388 return _backtrace(); | 1394 return _backtrace(); |
1389 } | 1395 } |
1390 | 1396 |
1391 inline void push(methodOop method, int bci, TRAPS) { | 1397 inline void push(Method* method, int bci, TRAPS) { |
1392 // Smear the -1 bci to 0 since the array only holds unsigned | 1398 // Smear the -1 bci to 0 since the array only holds unsigned |
1393 // shorts. The later line number lookup would just smear the -1 | 1399 // shorts. The later line number lookup would just smear the -1 |
1394 // to a 0 even if it could be recorded. | 1400 // to a 0 even if it could be recorded. |
1395 if (bci == SynchronizationEntryBCI) bci = 0; | 1401 if (bci == SynchronizationEntryBCI) bci = 0; |
1396 assert(bci == (jushort)bci, "doesn't fit"); | 1402 assert(bci == (jushort)bci, "doesn't fit"); |
1399 methodHandle mhandle(THREAD, method); | 1405 methodHandle mhandle(THREAD, method); |
1400 expand(CHECK); | 1406 expand(CHECK); |
1401 method = mhandle(); | 1407 method = mhandle(); |
1402 } | 1408 } |
1403 | 1409 |
1404 _methods->obj_at_put(_index, method); | 1410 _methods->metadata_at_put(_index, method); |
1405 _bcis->ushort_at_put(_index, bci); | 1411 _bcis->ushort_at_put(_index, bci); |
1412 // we need to save the mirrors in the backtrace to keep the methods from | |
1413 // being unloaded if their class loader is unloaded while we still have | |
1414 // this stack trace. | |
1415 _mirrors->obj_at_put(_index, method->method_holder()->java_mirror()); | |
1406 _index++; | 1416 _index++; |
1407 } | 1417 } |
1408 | 1418 |
1409 methodOop current_method() { | 1419 Method* current_method() { |
1410 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); | 1420 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); |
1411 return methodOop(_methods->obj_at(_index)); | 1421 return ((Method*)_methods->metadata_at(_index)); |
1412 } | 1422 } |
1413 | 1423 |
1414 jushort current_bci() { | 1424 jushort current_bci() { |
1415 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); | 1425 assert(_index >= 0 && _index < trace_chunk_size, "out of range"); |
1416 return _bcis->ushort_at(_index); | 1426 return _bcis->ushort_at(_index); |
1463 bool skip_fillInStackTrace_check = false; | 1473 bool skip_fillInStackTrace_check = false; |
1464 bool skip_throwableInit_check = false; | 1474 bool skip_throwableInit_check = false; |
1465 bool skip_hidden = !ShowHiddenFrames; | 1475 bool skip_hidden = !ShowHiddenFrames; |
1466 | 1476 |
1467 for (frame fr = thread->last_frame(); max_depth != total_count;) { | 1477 for (frame fr = thread->last_frame(); max_depth != total_count;) { |
1468 methodOop method = NULL; | 1478 Method* method = NULL; |
1469 int bci = 0; | 1479 int bci = 0; |
1470 | 1480 |
1471 // Compiled java method case. | 1481 // Compiled java method case. |
1472 if (decode_offset != 0) { | 1482 if (decode_offset != 0) { |
1473 DebugInfoReadStream stream(nm, decode_offset); | 1483 DebugInfoReadStream stream(nm, decode_offset); |
1474 decode_offset = stream.read_int(); | 1484 decode_offset = stream.read_int(); |
1475 method = (methodOop)nm->oop_at(stream.read_int()); | 1485 method = (Method*)nm->metadata_at(stream.read_int()); |
1476 bci = stream.read_bci(); | 1486 bci = stream.read_bci(); |
1477 } else { | 1487 } else { |
1478 if (fr.is_first_frame()) break; | 1488 if (fr.is_first_frame()) break; |
1479 address pc = fr.pc(); | 1489 address pc = fr.pc(); |
1480 if (fr.is_interpreted_frame()) { | 1490 if (fr.is_interpreted_frame()) { |
1506 #ifdef ASSERT | 1516 #ifdef ASSERT |
1507 assert(st_method() == method && st.bci() == bci, | 1517 assert(st_method() == method && st.bci() == bci, |
1508 "Wrong stack trace"); | 1518 "Wrong stack trace"); |
1509 st.next(); | 1519 st.next(); |
1510 // vframeStream::method isn't GC-safe so store off a copy | 1520 // vframeStream::method isn't GC-safe so store off a copy |
1511 // of the methodOop in case we GC. | 1521 // of the Method* in case we GC. |
1512 if (!st.at_end()) { | 1522 if (!st.at_end()) { |
1513 st_method = st.method(); | 1523 st_method = st.method(); |
1514 } | 1524 } |
1515 #endif | 1525 #endif |
1516 | 1526 |
1578 // No-op if stack trace is disabled | 1588 // No-op if stack trace is disabled |
1579 if (!StackTraceInThrowable) return; | 1589 if (!StackTraceInThrowable) return; |
1580 | 1590 |
1581 objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK); | 1591 objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK); |
1582 objArrayHandle backtrace (THREAD, h_oop); | 1592 objArrayHandle backtrace (THREAD, h_oop); |
1583 objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); | 1593 typeArrayOop m_oop = oopFactory::new_metaDataArray(trace_chunk_size, CHECK); |
1584 objArrayHandle methods (THREAD, m_oop); | 1594 typeArrayHandle methods (THREAD, m_oop); |
1585 typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK); | 1595 typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK); |
1586 typeArrayHandle bcis(THREAD, b); | 1596 typeArrayHandle bcis(THREAD, b); |
1597 objArrayOop mirror_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); | |
1598 objArrayHandle mirrors (THREAD, mirror_oop); | |
1587 | 1599 |
1588 // backtrace has space for one chunk (next is NULL) | 1600 // backtrace has space for one chunk (next is NULL) |
1589 backtrace->obj_at_put(trace_methods_offset, methods()); | 1601 backtrace->obj_at_put(trace_methods_offset, methods()); |
1590 backtrace->obj_at_put(trace_bcis_offset, bcis()); | 1602 backtrace->obj_at_put(trace_bcis_offset, bcis()); |
1603 backtrace->obj_at_put(trace_mirrors_offset, mirrors()); | |
1591 set_backtrace(throwable(), backtrace()); | 1604 set_backtrace(throwable(), backtrace()); |
1592 } | 1605 } |
1593 | 1606 |
1594 | 1607 |
1595 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) { | 1608 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) { |
1598 // No-op if stack trace is disabled | 1611 // No-op if stack trace is disabled |
1599 if (!StackTraceInThrowable) return; | 1612 if (!StackTraceInThrowable) return; |
1600 | 1613 |
1601 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check"); | 1614 assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check"); |
1602 | 1615 |
1603 oop backtrace = java_lang_Throwable::backtrace(throwable()); | 1616 objArrayOop backtrace = (objArrayOop)java_lang_Throwable::backtrace(throwable()); |
1604 assert(backtrace != NULL, "backtrace not preallocated"); | 1617 assert(backtrace != NULL, "backtrace not preallocated"); |
1605 | 1618 |
1606 oop m = objArrayOop(backtrace)->obj_at(trace_methods_offset); | 1619 oop m = backtrace->obj_at(trace_methods_offset); |
1607 objArrayOop methods = objArrayOop(m); | 1620 typeArrayOop methods = typeArrayOop(m); |
1608 assert(methods != NULL && methods->length() > 0, "method array not preallocated"); | 1621 assert(methods != NULL && methods->length() > 0, "method array not preallocated"); |
1609 | 1622 |
1610 oop b = objArrayOop(backtrace)->obj_at(trace_bcis_offset); | 1623 oop b = backtrace->obj_at(trace_bcis_offset); |
1611 typeArrayOop bcis = typeArrayOop(b); | 1624 typeArrayOop bcis = typeArrayOop(b); |
1612 assert(bcis != NULL, "bci array not preallocated"); | 1625 assert(bcis != NULL, "bci array not preallocated"); |
1613 | 1626 |
1614 assert(methods->length() == bcis->length(), "method and bci arrays should match"); | 1627 oop mr = backtrace->obj_at(trace_mirrors_offset); |
1628 objArrayOop mirrors = objArrayOop(mr); | |
1629 assert(mirrors != NULL, "bci array not preallocated"); | |
1630 | |
1631 assert(methods->length() == bcis->length() && | |
1632 methods->length() == mirrors->length(), | |
1633 "method and bci arrays should match"); | |
1615 | 1634 |
1616 JavaThread* thread = JavaThread::current(); | 1635 JavaThread* thread = JavaThread::current(); |
1617 ResourceMark rm(thread); | 1636 ResourceMark rm(thread); |
1618 vframeStream st(thread); | 1637 vframeStream st(thread); |
1619 | 1638 |
1630 // the -1 to a 0 even if it could be recorded. | 1649 // the -1 to a 0 even if it could be recorded. |
1631 int bci = st.bci(); | 1650 int bci = st.bci(); |
1632 if (bci == SynchronizationEntryBCI) bci = 0; | 1651 if (bci == SynchronizationEntryBCI) bci = 0; |
1633 assert(bci == (jushort)bci, "doesn't fit"); | 1652 assert(bci == (jushort)bci, "doesn't fit"); |
1634 bcis->ushort_at_put(chunk_count, bci); | 1653 bcis->ushort_at_put(chunk_count, bci); |
1635 methods->obj_at_put(chunk_count, st.method()); | 1654 methods->metadata_at_put(chunk_count, st.method()); |
1655 mirrors->obj_at_put(chunk_count, | |
1656 st.method()->method_holder()->java_mirror()); | |
1636 | 1657 |
1637 chunk_count++; | 1658 chunk_count++; |
1638 | 1659 |
1639 // Bail-out for deep stacks | 1660 // Bail-out for deep stacks |
1640 if (chunk_count >= max_chunks) break; | 1661 if (chunk_count >= max_chunks) break; |
1665 depth += trace_chunk_size; | 1686 depth += trace_chunk_size; |
1666 chunk = next; | 1687 chunk = next; |
1667 } | 1688 } |
1668 assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); | 1689 assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); |
1669 // Count element in remaining partial chunk | 1690 // Count element in remaining partial chunk |
1670 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); | 1691 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset)); |
1671 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); | 1692 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); |
1672 assert(methods != NULL && bcis != NULL, "sanity check"); | 1693 assert(methods != NULL && bcis != NULL, "sanity check"); |
1673 for (int i = 0; i < methods->length(); i++) { | 1694 for (int i = 0; i < methods->length(); i++) { |
1674 if (methods->obj_at(i) == NULL) break; | 1695 if (methods->metadata_at(i) == NULL) break; |
1675 depth++; | 1696 depth++; |
1676 } | 1697 } |
1677 } | 1698 } |
1678 return depth; | 1699 return depth; |
1679 } | 1700 } |
1696 } | 1717 } |
1697 if (chunk == NULL) { | 1718 if (chunk == NULL) { |
1698 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); | 1719 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); |
1699 } | 1720 } |
1700 // Get method,bci from chunk | 1721 // Get method,bci from chunk |
1701 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); | 1722 typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset)); |
1702 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); | 1723 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); |
1703 assert(methods != NULL && bcis != NULL, "sanity check"); | 1724 assert(methods != NULL && bcis != NULL, "sanity check"); |
1704 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index))); | 1725 methodHandle method(THREAD, ((Method*)methods->metadata_at(chunk_index))); |
1705 int bci = bcis->ushort_at(chunk_index); | 1726 int bci = bcis->ushort_at(chunk_index); |
1706 // Chunk can be partial full | 1727 // Chunk can be partial full |
1707 if (method.is_null()) { | 1728 if (method.is_null()) { |
1708 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); | 1729 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); |
1709 } | 1730 } |
1715 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) { | 1736 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) { |
1716 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs | 1737 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs |
1717 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); | 1738 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); |
1718 | 1739 |
1719 // Allocate java.lang.StackTraceElement instance | 1740 // Allocate java.lang.StackTraceElement instance |
1720 klassOop k = SystemDictionary::StackTraceElement_klass(); | 1741 Klass* k = SystemDictionary::StackTraceElement_klass(); |
1721 assert(k != NULL, "must be loaded in 1.4+"); | 1742 assert(k != NULL, "must be loaded in 1.4+"); |
1722 instanceKlassHandle ik (THREAD, k); | 1743 instanceKlassHandle ik (THREAD, k); |
1723 if (ik->should_be_initialized()) { | 1744 if (ik->should_be_initialized()) { |
1724 ik->initialize(CHECK_0); | 1745 ik->initialize(CHECK_0); |
1725 } | 1746 } |
1726 | 1747 |
1727 Handle element = ik->allocate_instance_handle(CHECK_0); | 1748 Handle element = ik->allocate_instance_handle(CHECK_0); |
1728 // Fill in class name | 1749 // Fill in class name |
1729 ResourceMark rm(THREAD); | 1750 ResourceMark rm(THREAD); |
1730 const char* str = instanceKlass::cast(method->method_holder())->external_name(); | 1751 const char* str = InstanceKlass::cast(method->method_holder())->external_name(); |
1731 oop classname = StringTable::intern((char*) str, CHECK_0); | 1752 oop classname = StringTable::intern((char*) str, CHECK_0); |
1732 java_lang_StackTraceElement::set_declaringClass(element(), classname); | 1753 java_lang_StackTraceElement::set_declaringClass(element(), classname); |
1733 // Fill in method name | 1754 // Fill in method name |
1734 oop methodname = StringTable::intern(method->name(), CHECK_0); | 1755 oop methodname = StringTable::intern(method->name(), CHECK_0); |
1735 java_lang_StackTraceElement::set_methodName(element(), methodname); | 1756 java_lang_StackTraceElement::set_methodName(element(), methodname); |
1736 // Fill in source file name | 1757 // Fill in source file name |
1737 Symbol* source = instanceKlass::cast(method->method_holder())->source_file_name(); | 1758 Symbol* source = InstanceKlass::cast(method->method_holder())->source_file_name(); |
1738 if (ShowHiddenFrames && source == NULL) | 1759 if (ShowHiddenFrames && source == NULL) |
1739 source = vmSymbols::unknown_class_name(); | 1760 source = vmSymbols::unknown_class_name(); |
1740 oop filename = StringTable::intern(source, CHECK_0); | 1761 oop filename = StringTable::intern(source, CHECK_0); |
1741 java_lang_StackTraceElement::set_fileName(element(), filename); | 1762 java_lang_StackTraceElement::set_fileName(element(), filename); |
1742 // File in source line number | 1763 // File in source line number |
1758 return element(); | 1779 return element(); |
1759 } | 1780 } |
1760 | 1781 |
1761 | 1782 |
1762 void java_lang_reflect_AccessibleObject::compute_offsets() { | 1783 void java_lang_reflect_AccessibleObject::compute_offsets() { |
1763 klassOop k = SystemDictionary::reflect_AccessibleObject_klass(); | 1784 Klass* k = SystemDictionary::reflect_AccessibleObject_klass(); |
1764 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); | 1785 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); |
1765 } | 1786 } |
1766 | 1787 |
1767 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { | 1788 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { |
1768 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1789 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1773 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1794 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1774 reflect->bool_field_put(override_offset, (int) value); | 1795 reflect->bool_field_put(override_offset, (int) value); |
1775 } | 1796 } |
1776 | 1797 |
1777 void java_lang_reflect_Method::compute_offsets() { | 1798 void java_lang_reflect_Method::compute_offsets() { |
1778 klassOop k = SystemDictionary::reflect_Method_klass(); | 1799 Klass* k = SystemDictionary::reflect_Method_klass(); |
1779 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 1800 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
1780 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 1801 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
1781 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); | 1802 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); |
1782 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); | 1803 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
1783 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); | 1804 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
1794 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); | 1815 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); |
1795 } | 1816 } |
1796 | 1817 |
1797 Handle java_lang_reflect_Method::create(TRAPS) { | 1818 Handle java_lang_reflect_Method::create(TRAPS) { |
1798 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1819 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1799 klassOop klass = SystemDictionary::reflect_Method_klass(); | 1820 Klass* klass = SystemDictionary::reflect_Method_klass(); |
1800 // This class is eagerly initialized during VM initialization, since we keep a refence | 1821 // This class is eagerly initialized during VM initialization, since we keep a refence |
1801 // to one of the methods | 1822 // to one of the methods |
1802 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized"); | 1823 assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized"); |
1803 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); | 1824 return InstanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); |
1804 } | 1825 } |
1805 | 1826 |
1806 oop java_lang_reflect_Method::clazz(oop reflect) { | 1827 oop java_lang_reflect_Method::clazz(oop reflect) { |
1807 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1828 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1808 return reflect->obj_field(clazz_offset); | 1829 return reflect->obj_field(clazz_offset); |
1936 assert(has_annotation_default_field(), "annotation default field must be present"); | 1957 assert(has_annotation_default_field(), "annotation default field must be present"); |
1937 method->obj_field_put(annotation_default_offset, value); | 1958 method->obj_field_put(annotation_default_offset, value); |
1938 } | 1959 } |
1939 | 1960 |
1940 void java_lang_reflect_Constructor::compute_offsets() { | 1961 void java_lang_reflect_Constructor::compute_offsets() { |
1941 klassOop k = SystemDictionary::reflect_Constructor_klass(); | 1962 Klass* k = SystemDictionary::reflect_Constructor_klass(); |
1942 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 1963 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
1943 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); | 1964 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
1944 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); | 1965 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
1945 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); | 1966 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
1946 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); | 1967 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
1954 } | 1975 } |
1955 | 1976 |
1956 Handle java_lang_reflect_Constructor::create(TRAPS) { | 1977 Handle java_lang_reflect_Constructor::create(TRAPS) { |
1957 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1978 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1958 Symbol* name = vmSymbols::java_lang_reflect_Constructor(); | 1979 Symbol* name = vmSymbols::java_lang_reflect_Constructor(); |
1959 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); | 1980 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); |
1960 instanceKlassHandle klass (THREAD, k); | 1981 instanceKlassHandle klass (THREAD, k); |
1961 // Ensure it is initialized | 1982 // Ensure it is initialized |
1962 klass->initialize(CHECK_NH); | 1983 klass->initialize(CHECK_NH); |
1963 return klass->allocate_instance_handle(CHECK_NH); | 1984 return klass->allocate_instance_handle(CHECK_NH); |
1964 } | 1985 } |
2060 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); | 2081 assert(has_parameter_annotations_field(), "parameter annotations field must be present"); |
2061 method->obj_field_put(parameter_annotations_offset, value); | 2082 method->obj_field_put(parameter_annotations_offset, value); |
2062 } | 2083 } |
2063 | 2084 |
2064 void java_lang_reflect_Field::compute_offsets() { | 2085 void java_lang_reflect_Field::compute_offsets() { |
2065 klassOop k = SystemDictionary::reflect_Field_klass(); | 2086 Klass* k = SystemDictionary::reflect_Field_klass(); |
2066 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 2087 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
2067 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 2088 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
2068 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); | 2089 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); |
2069 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); | 2090 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
2070 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); | 2091 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
2076 } | 2097 } |
2077 | 2098 |
2078 Handle java_lang_reflect_Field::create(TRAPS) { | 2099 Handle java_lang_reflect_Field::create(TRAPS) { |
2079 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 2100 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
2080 Symbol* name = vmSymbols::java_lang_reflect_Field(); | 2101 Symbol* name = vmSymbols::java_lang_reflect_Field(); |
2081 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); | 2102 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); |
2082 instanceKlassHandle klass (THREAD, k); | 2103 instanceKlassHandle klass (THREAD, k); |
2083 // Ensure it is initialized | 2104 // Ensure it is initialized |
2084 klass->initialize(CHECK_NH); | 2105 klass->initialize(CHECK_NH); |
2085 return klass->allocate_instance_handle(CHECK_NH); | 2106 return klass->allocate_instance_handle(CHECK_NH); |
2086 } | 2107 } |
2167 field->obj_field_put(annotations_offset, value); | 2188 field->obj_field_put(annotations_offset, value); |
2168 } | 2189 } |
2169 | 2190 |
2170 | 2191 |
2171 void sun_reflect_ConstantPool::compute_offsets() { | 2192 void sun_reflect_ConstantPool::compute_offsets() { |
2172 klassOop k = SystemDictionary::reflect_ConstantPool_klass(); | 2193 Klass* k = SystemDictionary::reflect_ConstantPool_klass(); |
2173 // This null test can be removed post beta | 2194 // This null test can be removed post beta |
2174 if (k != NULL) { | 2195 if (k != NULL) { |
2175 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); | 2196 // The field is called ConstantPool* in the sun.reflect.ConstantPool class. |
2197 compute_offset(_oop_offset, k, vmSymbols::ConstantPool_name(), vmSymbols::object_signature()); | |
2176 } | 2198 } |
2177 } | 2199 } |
2178 | 2200 |
2179 | 2201 |
2180 Handle sun_reflect_ConstantPool::create(TRAPS) { | 2202 Handle sun_reflect_ConstantPool::create(TRAPS) { |
2181 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 2203 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
2182 klassOop k = SystemDictionary::reflect_ConstantPool_klass(); | 2204 Klass* k = SystemDictionary::reflect_ConstantPool_klass(); |
2183 instanceKlassHandle klass (THREAD, k); | 2205 instanceKlassHandle klass (THREAD, k); |
2184 // Ensure it is initialized | 2206 // Ensure it is initialized |
2185 klass->initialize(CHECK_NH); | 2207 klass->initialize(CHECK_NH); |
2186 return klass->allocate_instance_handle(CHECK_NH); | 2208 return klass->allocate_instance_handle(CHECK_NH); |
2187 } | 2209 } |
2188 | 2210 |
2189 | 2211 |
2190 oop sun_reflect_ConstantPool::cp_oop(oop reflect) { | 2212 void sun_reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) { |
2191 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 2213 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
2192 return reflect->obj_field(_cp_oop_offset); | 2214 oop mirror = value->pool_holder()->java_mirror(); |
2193 } | 2215 // Save the mirror to get back the constant pool. |
2194 | 2216 reflect->obj_field_put(_oop_offset, mirror); |
2195 | 2217 } |
2196 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) { | 2218 |
2197 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 2219 ConstantPool* sun_reflect_ConstantPool::get_cp(oop reflect) { |
2198 reflect->obj_field_put(_cp_oop_offset, value); | 2220 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
2221 | |
2222 oop mirror = reflect->obj_field(_oop_offset); | |
2223 Klass* k = java_lang_Class::as_Klass(mirror); | |
2224 assert(k->oop_is_instance(), "Must be"); | |
2225 | |
2226 // Get the constant pool back from the klass. Since class redefinition | |
2227 // merges the new constant pool into the old, this is essentially the | |
2228 // same constant pool as the original. If constant pool merging is | |
2229 // no longer done in the future, this will have to change to save | |
2230 // the original. | |
2231 return InstanceKlass::cast(k)->constants(); | |
2199 } | 2232 } |
2200 | 2233 |
2201 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { | 2234 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { |
2202 klassOop k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); | 2235 Klass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); |
2203 // This null test can be removed post beta | 2236 // This null test can be removed post beta |
2204 if (k != NULL) { | 2237 if (k != NULL) { |
2205 compute_offset(_base_offset, k, | 2238 compute_offset(_base_offset, k, |
2206 vmSymbols::base_name(), vmSymbols::object_signature()); | 2239 vmSymbols::base_name(), vmSymbols::object_signature()); |
2207 } | 2240 } |
2208 } | 2241 } |
2209 | 2242 |
2210 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { | 2243 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { |
2211 klassOop k = SystemDictionary::box_klass(type); | 2244 Klass* k = SystemDictionary::box_klass(type); |
2212 if (k == NULL) return NULL; | 2245 if (k == NULL) return NULL; |
2213 instanceKlassHandle h (THREAD, k); | 2246 instanceKlassHandle h (THREAD, k); |
2214 if (!h->is_initialized()) h->initialize(CHECK_0); | 2247 if (!h->is_initialized()) h->initialize(CHECK_0); |
2215 return h->allocate_instance(THREAD); | 2248 return h->allocate_instance(THREAD); |
2216 } | 2249 } |
2342 } | 2375 } |
2343 } | 2376 } |
2344 | 2377 |
2345 | 2378 |
2346 // Support for java_lang_ref_Reference | 2379 // Support for java_lang_ref_Reference |
2380 HeapWord *java_lang_ref_Reference::pending_list_lock_addr() { | |
2381 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); | |
2382 address addr = ik->static_field_addr(static_lock_offset); | |
2383 return (HeapWord*) addr; | |
2384 } | |
2385 | |
2347 oop java_lang_ref_Reference::pending_list_lock() { | 2386 oop java_lang_ref_Reference::pending_list_lock() { |
2348 instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); | 2387 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); |
2349 address addr = ik->static_field_addr(static_lock_offset); | 2388 address addr = ik->static_field_addr(static_lock_offset); |
2350 if (UseCompressedOops) { | 2389 if (UseCompressedOops) { |
2351 return oopDesc::load_decode_heap_oop((narrowOop *)addr); | 2390 return oopDesc::load_decode_heap_oop((narrowOop *)addr); |
2352 } else { | 2391 } else { |
2353 return oopDesc::load_decode_heap_oop((oop*)addr); | 2392 return oopDesc::load_decode_heap_oop((oop*)addr); |
2354 } | 2393 } |
2355 } | 2394 } |
2356 | 2395 |
2357 HeapWord *java_lang_ref_Reference::pending_list_addr() { | 2396 HeapWord *java_lang_ref_Reference::pending_list_addr() { |
2358 instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); | 2397 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); |
2359 address addr = ik->static_field_addr(static_pending_offset); | 2398 address addr = ik->static_field_addr(static_pending_offset); |
2360 // XXX This might not be HeapWord aligned, almost rather be char *. | 2399 // XXX This might not be HeapWord aligned, almost rather be char *. |
2361 return (HeapWord*)addr; | 2400 return (HeapWord*)addr; |
2362 } | 2401 } |
2363 | 2402 |
2376 jlong java_lang_ref_SoftReference::timestamp(oop ref) { | 2415 jlong java_lang_ref_SoftReference::timestamp(oop ref) { |
2377 return ref->long_field(timestamp_offset); | 2416 return ref->long_field(timestamp_offset); |
2378 } | 2417 } |
2379 | 2418 |
2380 jlong java_lang_ref_SoftReference::clock() { | 2419 jlong java_lang_ref_SoftReference::clock() { |
2381 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); | 2420 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); |
2382 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); | 2421 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); |
2383 return *offset; | 2422 return *offset; |
2384 } | 2423 } |
2385 | 2424 |
2386 void java_lang_ref_SoftReference::set_clock(jlong value) { | 2425 void java_lang_ref_SoftReference::set_clock(jlong value) { |
2387 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); | 2426 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); |
2388 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); | 2427 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); |
2389 *offset = value; | 2428 *offset = value; |
2390 } | 2429 } |
2391 | 2430 |
2392 | 2431 |
2398 int java_lang_invoke_MemberName::_clazz_offset; | 2437 int java_lang_invoke_MemberName::_clazz_offset; |
2399 int java_lang_invoke_MemberName::_name_offset; | 2438 int java_lang_invoke_MemberName::_name_offset; |
2400 int java_lang_invoke_MemberName::_type_offset; | 2439 int java_lang_invoke_MemberName::_type_offset; |
2401 int java_lang_invoke_MemberName::_flags_offset; | 2440 int java_lang_invoke_MemberName::_flags_offset; |
2402 int java_lang_invoke_MemberName::_vmtarget_offset; | 2441 int java_lang_invoke_MemberName::_vmtarget_offset; |
2442 int java_lang_invoke_MemberName::_vmloader_offset; | |
2403 int java_lang_invoke_MemberName::_vmindex_offset; | 2443 int java_lang_invoke_MemberName::_vmindex_offset; |
2404 | 2444 |
2405 int java_lang_invoke_LambdaForm::_vmentry_offset; | 2445 int java_lang_invoke_LambdaForm::_vmentry_offset; |
2406 | 2446 |
2407 void java_lang_invoke_MethodHandle::compute_offsets() { | 2447 void java_lang_invoke_MethodHandle::compute_offsets() { |
2408 klassOop klass_oop = SystemDictionary::MethodHandle_klass(); | 2448 Klass* klass_oop = SystemDictionary::MethodHandle_klass(); |
2409 if (klass_oop != NULL && EnableInvokeDynamic) { | 2449 if (klass_oop != NULL && EnableInvokeDynamic) { |
2410 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature()); | 2450 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature()); |
2411 compute_optional_offset(_form_offset, klass_oop, vmSymbols::form_name(), vmSymbols::java_lang_invoke_LambdaForm_signature()); | 2451 compute_optional_offset(_form_offset, klass_oop, vmSymbols::form_name(), vmSymbols::java_lang_invoke_LambdaForm_signature()); |
2412 if (_form_offset == 0) { | 2452 if (_form_offset == 0) { |
2413 EnableInvokeDynamic = false; | 2453 EnableInvokeDynamic = false; |
2414 } | 2454 } |
2415 } | 2455 } |
2416 } | 2456 } |
2417 | 2457 |
2418 void java_lang_invoke_MemberName::compute_offsets() { | 2458 void java_lang_invoke_MemberName::compute_offsets() { |
2419 klassOop klass_oop = SystemDictionary::MemberName_klass(); | 2459 Klass* klass_oop = SystemDictionary::MemberName_klass(); |
2420 if (klass_oop != NULL && EnableInvokeDynamic) { | 2460 if (klass_oop != NULL && EnableInvokeDynamic) { |
2421 compute_offset(_clazz_offset, klass_oop, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 2461 compute_offset(_clazz_offset, klass_oop, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
2422 compute_offset(_name_offset, klass_oop, vmSymbols::name_name(), vmSymbols::string_signature()); | 2462 compute_offset(_name_offset, klass_oop, vmSymbols::name_name(), vmSymbols::string_signature()); |
2423 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::object_signature()); | 2463 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::object_signature()); |
2424 compute_offset(_flags_offset, klass_oop, vmSymbols::flags_name(), vmSymbols::int_signature()); | 2464 compute_offset(_flags_offset, klass_oop, vmSymbols::flags_name(), vmSymbols::int_signature()); |
2425 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); | 2465 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
2426 } | 2466 } |
2427 } | 2467 } |
2428 | 2468 |
2429 void java_lang_invoke_LambdaForm::compute_offsets() { | 2469 void java_lang_invoke_LambdaForm::compute_offsets() { |
2430 klassOop klass_oop = SystemDictionary::LambdaForm_klass(); | 2470 Klass* klass_oop = SystemDictionary::LambdaForm_klass(); |
2431 if (klass_oop != NULL && EnableInvokeDynamic) { | 2471 if (klass_oop != NULL && EnableInvokeDynamic) { |
2432 compute_offset(_vmentry_offset, klass_oop, vmSymbols::vmentry_name(), vmSymbols::java_lang_invoke_MemberName_signature()); | 2472 compute_offset(_vmentry_offset, klass_oop, vmSymbols::vmentry_name(), vmSymbols::java_lang_invoke_MemberName_signature()); |
2433 } | 2473 } |
2434 } | 2474 } |
2435 | 2475 |
2491 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) { | 2531 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) { |
2492 assert(is_instance(mname), "wrong type"); | 2532 assert(is_instance(mname), "wrong type"); |
2493 mname->int_field_put(_flags_offset, flags); | 2533 mname->int_field_put(_flags_offset, flags); |
2494 } | 2534 } |
2495 | 2535 |
2496 oop java_lang_invoke_MemberName::vmtarget(oop mname) { | 2536 Metadata* java_lang_invoke_MemberName::vmtarget(oop mname) { |
2497 assert(is_instance(mname), "wrong type"); | 2537 assert(is_instance(mname), "wrong type"); |
2498 return mname->obj_field(_vmtarget_offset); | 2538 return (Metadata*)mname->address_field(_vmtarget_offset); |
2499 } | 2539 } |
2500 | 2540 |
2501 void java_lang_invoke_MemberName::set_vmtarget(oop mname, oop ref) { | 2541 void java_lang_invoke_MemberName::set_vmtarget(oop mname, Metadata* ref) { |
2502 assert(is_instance(mname), "wrong type"); | 2542 assert(is_instance(mname), "wrong type"); |
2503 #ifdef ASSERT | 2543 #ifdef ASSERT |
2504 // check the type of the vmtarget | 2544 // check the type of the vmtarget |
2505 if (ref != NULL) { | 2545 if (ref != NULL) { |
2506 switch (flags(mname) & (MN_IS_METHOD | | 2546 switch (flags(mname) & (MN_IS_METHOD | |
2516 default: | 2556 default: |
2517 ShouldNotReachHere(); | 2557 ShouldNotReachHere(); |
2518 } | 2558 } |
2519 } | 2559 } |
2520 #endif //ASSERT | 2560 #endif //ASSERT |
2521 mname->obj_field_put(_vmtarget_offset, ref); | 2561 mname->address_field_put(_vmtarget_offset, (address)ref); |
2562 oop loader = NULL; | |
2563 if (ref != NULL) { | |
2564 if (ref->is_klass()) { | |
2565 loader = ((Klass*)ref)->class_loader(); | |
2566 } else if (ref->is_method()) { | |
2567 loader = ((Method*)ref)->method_holder()->class_loader(); | |
2568 } else { | |
2569 ShouldNotReachHere(); | |
2570 } | |
2571 } | |
2572 // Add a reference to the loader to ensure the metadata is kept alive | |
2573 mname->obj_field_put(_vmloader_offset, loader); | |
2522 } | 2574 } |
2523 | 2575 |
2524 intptr_t java_lang_invoke_MemberName::vmindex(oop mname) { | 2576 intptr_t java_lang_invoke_MemberName::vmindex(oop mname) { |
2525 assert(is_instance(mname), "wrong type"); | 2577 assert(is_instance(mname), "wrong type"); |
2526 return (intptr_t) mname->address_field(_vmindex_offset); | 2578 return (intptr_t) mname->address_field(_vmindex_offset); |
2541 | 2593 |
2542 int java_lang_invoke_MethodType::_rtype_offset; | 2594 int java_lang_invoke_MethodType::_rtype_offset; |
2543 int java_lang_invoke_MethodType::_ptypes_offset; | 2595 int java_lang_invoke_MethodType::_ptypes_offset; |
2544 | 2596 |
2545 void java_lang_invoke_MethodType::compute_offsets() { | 2597 void java_lang_invoke_MethodType::compute_offsets() { |
2546 klassOop k = SystemDictionary::MethodType_klass(); | 2598 Klass* k = SystemDictionary::MethodType_klass(); |
2547 if (k != NULL) { | 2599 if (k != NULL) { |
2548 compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); | 2600 compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); |
2549 compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); | 2601 compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); |
2550 } | 2602 } |
2551 } | 2603 } |
2628 | 2680 |
2629 int java_lang_invoke_CallSite::_target_offset; | 2681 int java_lang_invoke_CallSite::_target_offset; |
2630 | 2682 |
2631 void java_lang_invoke_CallSite::compute_offsets() { | 2683 void java_lang_invoke_CallSite::compute_offsets() { |
2632 if (!EnableInvokeDynamic) return; | 2684 if (!EnableInvokeDynamic) return; |
2633 klassOop k = SystemDictionary::CallSite_klass(); | 2685 Klass* k = SystemDictionary::CallSite_klass(); |
2634 if (k != NULL) { | 2686 if (k != NULL) { |
2635 compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); | 2687 compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); |
2636 } | 2688 } |
2637 } | 2689 } |
2638 | 2690 |
2644 int java_security_AccessControlContext::_isPrivileged_offset = 0; | 2696 int java_security_AccessControlContext::_isPrivileged_offset = 0; |
2645 | 2697 |
2646 void java_security_AccessControlContext::compute_offsets() { | 2698 void java_security_AccessControlContext::compute_offsets() { |
2647 assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); | 2699 assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); |
2648 fieldDescriptor fd; | 2700 fieldDescriptor fd; |
2649 instanceKlass* ik = instanceKlass::cast(SystemDictionary::AccessControlContext_klass()); | 2701 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass()); |
2650 | 2702 |
2651 if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { | 2703 if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { |
2652 fatal("Invalid layout of java.security.AccessControlContext"); | 2704 fatal("Invalid layout of java.security.AccessControlContext"); |
2653 } | 2705 } |
2654 _context_offset = fd.offset(); | 2706 _context_offset = fd.offset(); |
2666 | 2718 |
2667 | 2719 |
2668 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { | 2720 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { |
2669 assert(_isPrivileged_offset != 0, "offsets should have been initialized"); | 2721 assert(_isPrivileged_offset != 0, "offsets should have been initialized"); |
2670 // Ensure klass is initialized | 2722 // Ensure klass is initialized |
2671 instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); | 2723 InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); |
2672 // Allocate result | 2724 // Allocate result |
2673 oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); | 2725 oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); |
2674 // Fill in values | 2726 // Fill in values |
2675 result->obj_field_put(_context_offset, context()); | 2727 result->obj_field_put(_context_offset, context()); |
2676 result->obj_field_put(_privilegedContext_offset, privileged_context()); | 2728 result->obj_field_put(_privilegedContext_offset, privileged_context()); |
2677 result->bool_field_put(_isPrivileged_offset, isPrivileged); | 2729 result->bool_field_put(_isPrivileged_offset, isPrivileged); |
2678 return result; | 2730 return result; |
2679 } | 2731 } |
2680 | 2732 |
2681 | 2733 |
2682 // Support for java_lang_ClassLoader | 2734 // Support for java_lang_ClassLoader |
2735 | |
2683 bool java_lang_ClassLoader::offsets_computed = false; | 2736 bool java_lang_ClassLoader::offsets_computed = false; |
2737 int java_lang_ClassLoader::_loader_data_offset = -1; | |
2738 int java_lang_ClassLoader::_dependencies_offset = -1; | |
2684 int java_lang_ClassLoader::parallelCapable_offset = -1; | 2739 int java_lang_ClassLoader::parallelCapable_offset = -1; |
2740 | |
2741 ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) { | |
2742 assert(loader != NULL && loader->is_oop(), "loader must be oop"); | |
2743 return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset); | |
2744 } | |
2745 | |
2746 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) { | |
2747 return *java_lang_ClassLoader::loader_data_addr(loader); | |
2748 } | |
2749 | |
2750 oop java_lang_ClassLoader::dependencies(oop loader) { | |
2751 return loader->obj_field(_dependencies_offset); | |
2752 } | |
2753 | |
2754 HeapWord* java_lang_ClassLoader::dependencies_addr(oop loader) { | |
2755 if (UseCompressedOops) { | |
2756 return (HeapWord*)loader->obj_field_addr<narrowOop>(_dependencies_offset); | |
2757 } else { | |
2758 return (HeapWord*)loader->obj_field_addr<oop>(_dependencies_offset); | |
2759 } | |
2760 } | |
2685 | 2761 |
2686 void java_lang_ClassLoader::compute_offsets() { | 2762 void java_lang_ClassLoader::compute_offsets() { |
2687 assert(!offsets_computed, "offsets should be initialized only once"); | 2763 assert(!offsets_computed, "offsets should be initialized only once"); |
2688 offsets_computed = true; | 2764 offsets_computed = true; |
2689 | 2765 |
2690 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, | 2766 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, |
2691 klassOop k1 = SystemDictionary::ClassLoader_klass(); | 2767 Klass* k1 = SystemDictionary::ClassLoader_klass(); |
2692 compute_optional_offset(parallelCapable_offset, | 2768 compute_optional_offset(parallelCapable_offset, |
2693 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); | 2769 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); |
2770 | |
2771 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); | |
2694 } | 2772 } |
2695 | 2773 |
2696 oop java_lang_ClassLoader::parent(oop loader) { | 2774 oop java_lang_ClassLoader::parent(oop loader) { |
2697 assert(is_instance(loader), "loader must be oop"); | 2775 assert(is_instance(loader), "loader must be oop"); |
2698 return loader->obj_field(parent_offset); | 2776 return loader->obj_field(parent_offset); |
2743 if (loader != NULL) { | 2821 if (loader != NULL) { |
2744 // See whether this is one of the class loaders associated with | 2822 // See whether this is one of the class loaders associated with |
2745 // the generated bytecodes for reflection, and if so, "magically" | 2823 // the generated bytecodes for reflection, and if so, "magically" |
2746 // delegate to its parent to prevent class loading from occurring | 2824 // delegate to its parent to prevent class loading from occurring |
2747 // in places where applications using reflection didn't expect it. | 2825 // in places where applications using reflection didn't expect it. |
2748 klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); | 2826 Klass* delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); |
2749 // This might be null in non-1.4 JDKs | 2827 // This might be null in non-1.4 JDKs |
2750 if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { | 2828 if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { |
2751 return parent(loader); | 2829 return parent(loader); |
2752 } | 2830 } |
2753 } | 2831 } |
2775 int java_lang_Class::_klass_offset; | 2853 int java_lang_Class::_klass_offset; |
2776 int java_lang_Class::_array_klass_offset; | 2854 int java_lang_Class::_array_klass_offset; |
2777 int java_lang_Class::_resolved_constructor_offset; | 2855 int java_lang_Class::_resolved_constructor_offset; |
2778 int java_lang_Class::_oop_size_offset; | 2856 int java_lang_Class::_oop_size_offset; |
2779 int java_lang_Class::_static_oop_field_count_offset; | 2857 int java_lang_Class::_static_oop_field_count_offset; |
2858 GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL; | |
2780 int java_lang_Throwable::backtrace_offset; | 2859 int java_lang_Throwable::backtrace_offset; |
2781 int java_lang_Throwable::detailMessage_offset; | 2860 int java_lang_Throwable::detailMessage_offset; |
2782 int java_lang_Throwable::cause_offset; | 2861 int java_lang_Throwable::cause_offset; |
2783 int java_lang_Throwable::stackTrace_offset; | 2862 int java_lang_Throwable::stackTrace_offset; |
2784 int java_lang_Throwable::static_unassigned_stacktrace_offset; | 2863 int java_lang_Throwable::static_unassigned_stacktrace_offset; |
2833 int java_lang_AssertionStatusDirectives::packages_offset; | 2912 int java_lang_AssertionStatusDirectives::packages_offset; |
2834 int java_lang_AssertionStatusDirectives::packageEnabled_offset; | 2913 int java_lang_AssertionStatusDirectives::packageEnabled_offset; |
2835 int java_lang_AssertionStatusDirectives::deflt_offset; | 2914 int java_lang_AssertionStatusDirectives::deflt_offset; |
2836 int java_nio_Buffer::_limit_offset; | 2915 int java_nio_Buffer::_limit_offset; |
2837 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; | 2916 int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; |
2838 int sun_reflect_ConstantPool::_cp_oop_offset; | 2917 int sun_reflect_ConstantPool::_oop_offset; |
2839 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; | 2918 int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; |
2840 | 2919 |
2841 | 2920 |
2842 // Support for java_lang_StackTraceElement | 2921 // Support for java_lang_StackTraceElement |
2843 | 2922 |
2886 return _limit_offset; | 2965 return _limit_offset; |
2887 } | 2966 } |
2888 | 2967 |
2889 | 2968 |
2890 void java_nio_Buffer::compute_offsets() { | 2969 void java_nio_Buffer::compute_offsets() { |
2891 klassOop k = SystemDictionary::nio_Buffer_klass(); | 2970 Klass* k = SystemDictionary::nio_Buffer_klass(); |
2892 assert(k != NULL, "must be loaded in 1.4+"); | 2971 assert(k != NULL, "must be loaded in 1.4+"); |
2893 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); | 2972 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); |
2894 } | 2973 } |
2895 | 2974 |
2896 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { | 2975 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { |
2897 if (_owner_offset != 0) return; | 2976 if (_owner_offset != 0) return; |
2898 | 2977 |
2899 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); | 2978 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); |
2900 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); | 2979 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); |
2901 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); | 2980 Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass(); |
2902 compute_offset(_owner_offset, k, | 2981 compute_offset(_owner_offset, k, |
2903 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); | 2982 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); |
2904 } | 2983 } |
2905 | 2984 |
2906 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { | 2985 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { |
3005 | 3084 |
3006 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { | 3085 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { |
3007 EXCEPTION_MARK; | 3086 EXCEPTION_MARK; |
3008 fieldDescriptor fd; | 3087 fieldDescriptor fd; |
3009 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); | 3088 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); |
3010 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | 3089 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); |
3011 instanceKlassHandle h_klass (THREAD, k); | 3090 instanceKlassHandle h_klass (THREAD, k); |
3012 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); | 3091 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); |
3013 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); | 3092 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); |
3014 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { | 3093 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { |
3015 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); | 3094 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name); |
3031 | 3110 |
3032 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { | 3111 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) { |
3033 EXCEPTION_MARK; | 3112 EXCEPTION_MARK; |
3034 fieldDescriptor fd; | 3113 fieldDescriptor fd; |
3035 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); | 3114 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); |
3036 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | 3115 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); |
3037 instanceKlassHandle h_klass (THREAD, k); | 3116 instanceKlassHandle h_klass (THREAD, k); |
3038 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); | 3117 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); |
3039 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); | 3118 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); |
3040 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { | 3119 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { |
3041 tty->print_cr("Static field %s.%s not found", klass_name, field_name); | 3120 tty->print_cr("Static field %s.%s not found", klass_name, field_name); |
3056 | 3135 |
3057 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { | 3136 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { |
3058 EXCEPTION_MARK; | 3137 EXCEPTION_MARK; |
3059 fieldDescriptor fd; | 3138 fieldDescriptor fd; |
3060 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); | 3139 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); |
3061 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | 3140 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); |
3062 instanceKlassHandle h_klass (THREAD, k); | 3141 instanceKlassHandle h_klass (THREAD, k); |
3063 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); | 3142 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); |
3064 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); | 3143 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); |
3065 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { | 3144 if (!h_klass->find_local_field(f_name, f_sig, &fd)) { |
3066 tty->print_cr("Static field %s.%s not found", klass_name, field_name); | 3145 tty->print_cr("Static field %s.%s not found", klass_name, field_name); |
3086 | 3165 |
3087 // Check the hard-coded field offsets of all the classes in this file | 3166 // Check the hard-coded field offsets of all the classes in this file |
3088 | 3167 |
3089 void JavaClasses::check_offsets() { | 3168 void JavaClasses::check_offsets() { |
3090 bool valid = true; | 3169 bool valid = true; |
3170 HandleMark hm; | |
3091 | 3171 |
3092 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ | 3172 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
3093 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) | 3173 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) |
3094 | 3174 |
3095 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ | 3175 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
3190 } | 3270 } |
3191 | 3271 |
3192 #endif // PRODUCT | 3272 #endif // PRODUCT |
3193 | 3273 |
3194 int InjectedField::compute_offset() { | 3274 int InjectedField::compute_offset() { |
3195 klassOop klass_oop = klass(); | 3275 Klass* klass_oop = klass(); |
3196 for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { | 3276 for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { |
3197 if (!may_be_java && !fs.access_flags().is_internal()) { | 3277 if (!may_be_java && !fs.access_flags().is_internal()) { |
3198 // Only look at injected fields | 3278 // Only look at injected fields |
3199 continue; | 3279 continue; |
3200 } | 3280 } |
3201 if (fs.name() == name() && fs.signature() == signature()) { | 3281 if (fs.name() == name() && fs.signature() == signature()) { |
3202 return fs.offset(); | 3282 return fs.offset(); |
3203 } | 3283 } |
3204 } | 3284 } |
3205 ResourceMark rm; | 3285 ResourceMark rm; |
3206 tty->print_cr("Invalid layout of %s at %s/%s%s", instanceKlass::cast(klass_oop)->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : ""); | 3286 tty->print_cr("Invalid layout of %s at %s/%s%s", InstanceKlass::cast(klass_oop)->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : ""); |
3207 #ifndef PRODUCT | 3287 #ifndef PRODUCT |
3208 klass_oop->print(); | 3288 klass_oop->print(); |
3209 tty->print_cr("all fields:"); | 3289 tty->print_cr("all fields:"); |
3210 for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { | 3290 for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { |
3211 tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); | 3291 tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); |
3212 } | 3292 } |
3213 #endif //PRODUCT | 3293 #endif //PRODUCT |
3214 fatal("Invalid layout of preloaded class"); | 3294 fatal("Invalid layout of preloaded class"); |
3215 return -1; | 3295 return -1; |