1 /*
2 * Copyright (c) 2000, 2008, 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 */
24
25 # include "incls/_precompiled.incl"
26 # include "incls/_methodDataKlass.cpp.incl"
27
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 }
38
39
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 }
44
45
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 }
50
51
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);
60
61 assert(mdo->is_parsable(), "should be parsable here.");
62 assert(size == mdo->object_size(), "wrong size for methodDataOop");
63 return mdo;
64 }
65
66
67 void methodDataKlass::oop_follow_contents(oop obj) {
68 assert (obj->is_methodData(), "object must be method data");
69 methodDataOop m = methodDataOop(obj);
70
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 }
80
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);
86
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
97
98
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();
105
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 }
116
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();
123
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 }
137
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();
144
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 }
154
155
156 #ifndef SERIALGC
157 void methodDataKlass::oop_push_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 }
163
164 int methodDataKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
165 assert(obj->is_methodData(), "should be method data");
166 methodDataOop m = methodDataOop(obj);
167
168 PSParallelCompact::adjust_pointer(m->adr_method());
169
170 ResourceMark rm;
171 ProfileData* data;
172 for (data = m->first_data(); m->is_valid(data); data = m->next_data(data)) {
173 data->update_pointers();
174 }
175 return m->object_size();
176 }
177
178 int
179 methodDataKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
180 HeapWord* beg_addr, HeapWord* end_addr) {
181 assert(obj->is_methodData(), "should be method data");
182
183 oop* p;
184 methodDataOop m = methodDataOop(obj);
185
186 p = m->adr_method();
187 PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
188
189 ResourceMark rm;
190 ProfileData* data;
191 for (data = m->first_data(); m->is_valid(data); data = m->next_data(data)) {
192 data->update_pointers(beg_addr, end_addr);
193 }
194 return m->object_size();
195 }
196 #endif // SERIALGC
197
198 #ifndef PRODUCT
199
200 // Printing
201 void methodDataKlass::oop_print_on(oop obj, outputStream* st) {
202 assert(obj->is_methodData(), "should be method data");
203 methodDataOop m = methodDataOop(obj);
204 st->print("method data for ");
205 m->method()->print_value_on(st);
206 st->cr();
207 m->print_data_on(st);
208 }
209
210 #endif //PRODUCT
211
212 void methodDataKlass::oop_print_value_on(oop obj, outputStream* st) {
213 assert(obj->is_methodData(), "should be method data");
214 methodDataOop m = methodDataOop(obj);
215 st->print("method data for ");
216 m->method()->print_value_on(st);
217 }
218
219 const char* methodDataKlass::internal_name() const {
220 return "{method data}";
221 }
222
223
224 // Verification
225 void methodDataKlass::oop_verify_on(oop obj, outputStream* st) {
226 Klass::oop_verify_on(obj, st);
227 guarantee(obj->is_methodData(), "object must be method data");
228 methodDataOop m = methodDataOop(obj);
229 guarantee(m->is_perm(), "should be in permspace");
230 m->verify_data_on(st);
231 }