Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_OOPS_ARRAYKLASS_HPP
26 #define SHARE_VM_OOPS_ARRAYKLASS_HPP
28 #include "memory/universe.hpp"
29 #include "oops/klass.hpp"
30 #include "oops/klassOop.hpp"
31 #include "oops/klassVtable.hpp"
33 // arrayKlass is the abstract baseclass for all array classes
35 class arrayKlass: public Klass {
36 friend class VMStructs;
37 private:
38 int _dimension; // This is n'th-dimensional array.
39 volatile klassOop _higher_dimension; // Refers the (n+1)'th-dimensional array (if present).
40 volatile klassOop _lower_dimension; // Refers the (n-1)'th-dimensional array (if present).
41 int _vtable_len; // size of vtable for this klass
42 juint _alloc_size; // allocation profiling support
43 oop _component_mirror; // component type, as a java/lang/Class
45 public:
46 // Testing operation
47 bool oop_is_array() const { return true; }
49 // Instance variables
50 int dimension() const { return _dimension; }
51 void set_dimension(int dimension) { _dimension = dimension; }
53 klassOop higher_dimension() const { return _higher_dimension; }
54 void set_higher_dimension(klassOop k) { oop_store_without_check((oop*) &_higher_dimension, (oop) k); }
55 oop* adr_higher_dimension() { return (oop*)&this->_higher_dimension;}
57 klassOop lower_dimension() const { return _lower_dimension; }
58 void set_lower_dimension(klassOop k) { oop_store_without_check((oop*) &_lower_dimension, (oop) k); }
59 oop* adr_lower_dimension() { return (oop*)&this->_lower_dimension;}
61 // Allocation profiling support
62 juint alloc_size() const { return _alloc_size; }
63 void set_alloc_size(juint n) { _alloc_size = n; }
65 // offset of first element, including any padding for the sake of alignment
66 int array_header_in_bytes() const { return layout_helper_header_size(layout_helper()); }
67 int log2_element_size() const { return layout_helper_log2_element_size(layout_helper()); }
68 // type of elements (T_OBJECT for both oop arrays and array-arrays)
69 BasicType element_type() const { return layout_helper_element_type(layout_helper()); }
71 oop component_mirror() const { return _component_mirror; }
72 void set_component_mirror(oop m) { oop_store((oop*) &_component_mirror, m); }
73 oop* adr_component_mirror() { return (oop*)&this->_component_mirror;}
75 // Compiler/Interpreter offset
76 static ByteSize component_mirror_offset() { return byte_offset_of(arrayKlass, _component_mirror); }
78 virtual klassOop java_super() const;//{ return SystemDictionary::Object_klass(); }
80 // Allocation
81 // Sizes points to the first dimension of the array, subsequent dimensions
82 // are always in higher memory. The callers of these set that up.
83 virtual oop multi_allocate(int rank, jint* sizes, TRAPS);
84 objArrayOop allocate_arrayArray(int n, int length, TRAPS);
86 // Lookup operations
87 methodOop uncached_lookup_method(Symbol* name, Symbol* signature) const;
89 // Casting from klassOop
90 static arrayKlass* cast(klassOop k) {
91 Klass* kp = k->klass_part();
92 assert(kp->null_vtbl() || kp->oop_is_array(), "cast to arrayKlass");
93 return (arrayKlass*) kp;
94 }
96 objArrayOop compute_secondary_supers(int num_extra_slots, TRAPS);
97 bool compute_is_subtype_of(klassOop k);
99 // Sizing
100 static int header_size() { return oopDesc::header_size() + sizeof(arrayKlass)/HeapWordSize; }
101 int object_size(int header_size) const;
103 bool object_is_parsable() const { return _vtable_len > 0; }
105 // Java vtable
106 klassVtable* vtable() const; // return new klassVtable
107 int vtable_length() const { return _vtable_len; }
108 static int base_vtable_length() { return Universe::base_vtable_size(); }
109 void set_vtable_length(int len) { assert(len == base_vtable_length(), "bad length"); _vtable_len = len; }
110 protected:
111 inline intptr_t* start_of_vtable() const;
113 public:
114 // Iterators
115 void array_klasses_do(void f(klassOop k));
116 void with_array_klasses_do(void f(klassOop k));
118 // Shared creation method
119 static arrayKlassHandle base_create_array_klass(
120 const Klass_vtbl& vtbl,
121 int header_size, KlassHandle klass,
122 TRAPS);
123 // Return a handle.
124 static void complete_create_array_klass(arrayKlassHandle k, KlassHandle super_klass, TRAPS);
126 // jvm support
127 jint compute_modifier_flags(TRAPS) const;
129 // JVMTI support
130 jint jvmti_class_status() const;
132 // Printing
133 void oop_print_on(oop obj, outputStream* st);
135 // Verification
136 void oop_verify_on(oop obj, outputStream* st);
137 };
139 #endif // SHARE_VM_OOPS_ARRAYKLASS_HPP