Mon, 09 Jun 2008 11:51:19 -0400
6687581: Make CMS work with compressed oops
Summary: Make FreeChunk read markword instead of LSB in _klass pointer to indicate that it's a FreeChunk for compressed oops.
Reviewed-by: ysr, jmasa
1 /*
2 * Copyright 2000-2006 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 # include "incls/_precompiled.incl"
26 # include "incls/_methodDataKlass.cpp.incl"
28 klassOop methodDataKlass::create_klass(TRAPS) {
29 methodDataKlass o;
30 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
31 KlassHandle k = base_create_klass(h_this_klass, header_size(),
32 o.vtbl_value(), CHECK_NULL);
33 // Make sure size calculation is right
34 assert(k()->size() == align_object_size(header_size()),
35 "wrong size for object");
36 return k();
37 }
40 int methodDataKlass::oop_size(oop obj) const {
41 assert(obj->is_methodData(), "must be method data oop");
42 return methodDataOop(obj)->object_size();
43 }
46 bool methodDataKlass::oop_is_parsable(oop obj) const {
47 assert(obj->is_methodData(), "must be method data oop");
48 return methodDataOop(obj)->object_is_parsable();
49 }
52 methodDataOop methodDataKlass::allocate(methodHandle method, TRAPS) {
53 int size = methodDataOopDesc::compute_allocation_size_in_words(method);
54 KlassHandle h_k(THREAD, as_klassOop());
55 methodDataOop mdo =
56 (methodDataOop)CollectedHeap::permanent_obj_allocate(h_k, size, CHECK_NULL);
57 assert(!mdo->is_parsable(), "not expecting parsability yet.");
58 No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC
59 mdo->initialize(method);
61 assert(mdo->is_parsable(), "should be parsable here.");
62 assert(size == mdo->object_size(), "wrong size for methodDataOop");
63 return mdo;
64 }
67 void methodDataKlass::oop_follow_contents(oop obj) {
68 assert (obj->is_methodData(), "object must be method data");
69 methodDataOop m = methodDataOop(obj);
71 obj->follow_header();
72 MarkSweep::mark_and_push(m->adr_method());
73 ResourceMark rm;
74 for (ProfileData* data = m->first_data();
75 m->is_valid(data);
76 data = m->next_data(data)) {
77 data->follow_contents();
78 }
79 }
81 #ifndef SERIALGC
82 void methodDataKlass::oop_follow_contents(ParCompactionManager* cm,
83 oop obj) {
84 assert (obj->is_methodData(), "object must be method data");
85 methodDataOop m = methodDataOop(obj);
87 obj->follow_header(cm);
88 PSParallelCompact::mark_and_push(cm, m->adr_method());
89 ResourceMark rm;
90 for (ProfileData* data = m->first_data();
91 m->is_valid(data);
92 data = m->next_data(data)) {
93 data->follow_contents(cm);
94 }
95 }
96 #endif // SERIALGC
99 int methodDataKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
100 assert (obj->is_methodData(), "object must be method data");
101 methodDataOop m = methodDataOop(obj);
102 // Get size before changing pointers
103 // Don't call size() or oop_size() since that is a virtual call.
104 int size = m->object_size();
106 obj->oop_iterate_header(blk);
107 blk->do_oop(m->adr_method());
108 ResourceMark rm;
109 for (ProfileData* data = m->first_data();
110 m->is_valid(data);
111 data = m->next_data(data)) {
112 data->oop_iterate(blk);
113 }
114 return size;
115 }
117 int methodDataKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
118 assert (obj->is_methodData(), "object must be method data");
119 methodDataOop m = methodDataOop(obj);
120 // Get size before changing pointers
121 // Don't call size() or oop_size() since that is a virtual call.
122 int size = m->object_size();
124 obj->oop_iterate_header(blk, mr);
125 oop* adr = m->adr_method();
126 if (mr.contains(adr)) {
127 blk->do_oop(m->adr_method());
128 }
129 ResourceMark rm;
130 for (ProfileData* data = m->first_data();
131 m->is_valid(data);
132 data = m->next_data(data)) {
133 data->oop_iterate_m(blk, mr);
134 }
135 return size;
136 }
138 int methodDataKlass::oop_adjust_pointers(oop obj) {
139 assert(obj->is_methodData(), "should be method data");
140 methodDataOop m = methodDataOop(obj);
141 // Get size before changing pointers
142 // Don't call size() or oop_size() since that is a virtual call.
143 int size = m->object_size();
145 obj->adjust_header();
146 MarkSweep::adjust_pointer(m->adr_method());
147 ResourceMark rm;
148 ProfileData* data;
149 for (data = m->first_data(); m->is_valid(data); data = m->next_data(data)) {
150 data->adjust_pointers();
151 }
152 return size;
153 }
156 #ifndef SERIALGC
157 void methodDataKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
158 assert (obj->is_methodData(), "object must be method data");
159 methodDataOop m = methodDataOop(obj);
160 // This should never point into the young gen.
161 assert(!PSScavenge::should_scavenge(m->adr_method()), "Sanity");
162 }
164 void methodDataKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
165 assert (obj->is_methodData(), "object must be method data");
166 methodDataOop m = methodDataOop(obj);
167 // This should never point into the young gen.
168 assert(!PSScavenge::should_scavenge(m->adr_method()), "Sanity");
169 }
171 int methodDataKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
172 assert(obj->is_methodData(), "should be method data");
173 methodDataOop m = methodDataOop(obj);
175 PSParallelCompact::adjust_pointer(m->adr_method());
177 ResourceMark rm;
178 ProfileData* data;
179 for (data = m->first_data(); m->is_valid(data); data = m->next_data(data)) {
180 data->update_pointers();
181 }
182 return m->object_size();
183 }
185 int
186 methodDataKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
187 HeapWord* beg_addr, HeapWord* end_addr) {
188 assert(obj->is_methodData(), "should be method data");
190 oop* p;
191 methodDataOop m = methodDataOop(obj);
193 p = m->adr_method();
194 PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
196 ResourceMark rm;
197 ProfileData* data;
198 for (data = m->first_data(); m->is_valid(data); data = m->next_data(data)) {
199 data->update_pointers(beg_addr, end_addr);
200 }
201 return m->object_size();
202 }
203 #endif // SERIALGC
205 #ifndef PRODUCT
207 // Printing
208 void methodDataKlass::oop_print_on(oop obj, outputStream* st) {
209 assert(obj->is_methodData(), "should be method data");
210 methodDataOop m = methodDataOop(obj);
211 st->print("method data for ");
212 m->method()->print_value_on(st);
213 st->cr();
214 m->print_data_on(st);
215 }
217 void methodDataKlass::oop_print_value_on(oop obj, outputStream* st) {
218 assert(obj->is_methodData(), "should be method data");
219 methodDataOop m = methodDataOop(obj);
220 st->print("method data for ");
221 m->method()->print_value_on(st);
222 }
224 #endif // !PRODUCT
226 const char* methodDataKlass::internal_name() const {
227 return "{method data}";
228 }
231 // Verification
232 void methodDataKlass::oop_verify_on(oop obj, outputStream* st) {
233 Klass::oop_verify_on(obj, st);
234 guarantee(obj->is_methodData(), "object must be method data");
235 methodDataOop m = methodDataOop(obj);
236 guarantee(m->is_perm(), "should be in permspace");
237 m->verify_data_on(st);
238 }