Wed, 06 Jan 2010 22:21:39 -0800
Merge
1 /*
2 * Copyright 1998-2009 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/_cpCacheKlass.cpp.incl"
29 int constantPoolCacheKlass::oop_size(oop obj) const {
30 assert(obj->is_constantPoolCache(), "must be constantPool");
31 return constantPoolCacheOop(obj)->object_size();
32 }
35 constantPoolCacheOop constantPoolCacheKlass::allocate(int length,
36 bool is_conc_safe,
37 TRAPS) {
38 // allocate memory
39 int size = constantPoolCacheOopDesc::object_size(length);
41 KlassHandle klass (THREAD, as_klassOop());
43 // This is the original code. The code from permanent_obj_allocate()
44 // was in-lined to allow the setting of is_conc_safe before the klass
45 // is installed.
46 // constantPoolCacheOop cache = (constantPoolCacheOop)
47 // CollectedHeap::permanent_obj_allocate(klass, size, CHECK_NULL);
49 oop obj = CollectedHeap::permanent_obj_allocate_no_klass_install(klass, size, CHECK_NULL);
50 constantPoolCacheOop cache = (constantPoolCacheOop) obj;
51 cache->set_is_conc_safe(is_conc_safe);
52 // The store to is_conc_safe must be visible before the klass
53 // is set. This should be done safely because _is_conc_safe has
54 // been declared volatile. If there are any problems, consider adding
55 // OrderAccess::storestore();
56 CollectedHeap::post_allocation_install_obj_klass(klass, obj, size);
57 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value((HeapWord*) obj,
58 size));
60 // The length field affects the size of the object. The allocation
61 // above allocates the correct size (see calculation of "size") but
62 // the size() method of the constant pool cache oop will not reflect
63 // that size until the correct length is set.
64 cache->set_length(length);
66 // The store of the length must be visible before is_conc_safe is
67 // set to a safe state.
68 // This should be done safely because _is_conc_safe has
69 // been declared volatile. If there are any problems, consider adding
70 // OrderAccess::storestore();
71 cache->set_is_conc_safe(methodOopDesc::IsSafeConc);
72 cache->set_constant_pool(NULL);
73 return cache;
74 }
76 klassOop constantPoolCacheKlass::create_klass(TRAPS) {
77 constantPoolCacheKlass o;
78 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
79 KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
80 // Make sure size calculation is right
81 assert(k()->size() == align_object_size(header_size()), "wrong size for object");
82 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
83 return k();
84 }
87 void constantPoolCacheKlass::oop_follow_contents(oop obj) {
88 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
89 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
90 // Performance tweak: We skip iterating over the klass pointer since we
91 // know that Universe::constantPoolCacheKlassObj never moves.
92 // gc of constant pool cache instance variables
93 MarkSweep::mark_and_push((oop*)cache->constant_pool_addr());
94 // gc of constant pool cache entries
95 int i = cache->length();
96 while (i-- > 0) cache->entry_at(i)->follow_contents();
97 }
99 #ifndef SERIALGC
100 void constantPoolCacheKlass::oop_follow_contents(ParCompactionManager* cm,
101 oop obj) {
102 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
103 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
104 // Performance tweak: We skip iterating over the klass pointer since we
105 // know that Universe::constantPoolCacheKlassObj never moves.
106 // gc of constant pool cache instance variables
107 PSParallelCompact::mark_and_push(cm, (oop*)cache->constant_pool_addr());
108 // gc of constant pool cache entries
109 int i = cache->length();
110 while (i-- > 0) cache->entry_at(i)->follow_contents(cm);
111 }
112 #endif // SERIALGC
115 int constantPoolCacheKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
116 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
117 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
118 // Get size before changing pointers.
119 // Don't call size() or oop_size() since that is a virtual call.
120 int size = cache->object_size();
121 // Performance tweak: We skip iterating over the klass pointer since we
122 // know that Universe::constantPoolCacheKlassObj never moves.
123 // iteration over constant pool cache instance variables
124 blk->do_oop((oop*)cache->constant_pool_addr());
125 // iteration over constant pool cache entries
126 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate(blk);
127 return size;
128 }
131 int constantPoolCacheKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
132 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
133 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
134 // Get size before changing pointers.
135 // Don't call size() or oop_size() since that is a virtual call.
136 int size = cache->object_size();
137 // Performance tweak: We skip iterating over the klass pointer since we
138 // know that Universe::constantPoolCacheKlassObj never moves.
139 // iteration over constant pool cache instance variables
140 oop* addr = (oop*)cache->constant_pool_addr();
141 if (mr.contains(addr)) blk->do_oop(addr);
142 // iteration over constant pool cache entries
143 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate_m(blk, mr);
144 return size;
145 }
147 int constantPoolCacheKlass::oop_adjust_pointers(oop obj) {
148 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
149 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
150 // Get size before changing pointers.
151 // Don't call size() or oop_size() since that is a virtual call.
152 int size = cache->object_size();
153 // Performance tweak: We skip iterating over the klass pointer since we
154 // know that Universe::constantPoolCacheKlassObj never moves.
155 // Iteration over constant pool cache instance variables
156 MarkSweep::adjust_pointer((oop*)cache->constant_pool_addr());
157 // iteration over constant pool cache entries
158 for (int i = 0; i < cache->length(); i++)
159 cache->entry_at(i)->adjust_pointers();
160 return size;
161 }
163 bool constantPoolCacheKlass::oop_is_conc_safe(oop obj) const {
164 assert(obj->is_constantPoolCache(), "should be constant pool");
165 return constantPoolCacheOop(obj)->is_conc_safe();
166 }
168 #ifndef SERIALGC
169 void constantPoolCacheKlass::oop_copy_contents(PSPromotionManager* pm,
170 oop obj) {
171 assert(obj->is_constantPoolCache(), "should be constant pool");
172 if (EnableInvokeDynamic) {
173 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
174 // during a scavenge, it is safe to inspect my pool, since it is perm
175 constantPoolOop pool = cache->constant_pool();
176 assert(pool->is_constantPool(), "should be constant pool");
177 if (pool->has_invokedynamic()) {
178 for (int i = 0; i < cache->length(); i++) {
179 ConstantPoolCacheEntry* e = cache->entry_at(i);
180 oop* p = (oop*)&e->_f1;
181 if (e->is_secondary_entry()) {
182 if (PSScavenge::should_scavenge(p))
183 pm->claim_or_forward_breadth(p);
184 assert(!(e->is_vfinal() && PSScavenge::should_scavenge((oop*)&e->_f2)),
185 "no live oops here");
186 }
187 }
188 }
189 }
190 }
192 void constantPoolCacheKlass::oop_push_contents(PSPromotionManager* pm,
193 oop obj) {
194 assert(obj->is_constantPoolCache(), "should be constant pool");
195 if (EnableInvokeDynamic) {
196 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
197 // during a scavenge, it is safe to inspect my pool, since it is perm
198 constantPoolOop pool = cache->constant_pool();
199 assert(pool->is_constantPool(), "should be constant pool");
200 if (pool->has_invokedynamic()) {
201 for (int i = 0; i < cache->length(); i++) {
202 ConstantPoolCacheEntry* e = cache->entry_at(i);
203 oop* p = (oop*)&e->_f1;
204 if (e->is_secondary_entry()) {
205 if (PSScavenge::should_scavenge(p))
206 pm->claim_or_forward_depth(p);
207 assert(!(e->is_vfinal() && PSScavenge::should_scavenge((oop*)&e->_f2)),
208 "no live oops here");
209 }
210 }
211 }
212 }
213 }
215 int
216 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
217 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
218 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
220 // Iteration over constant pool cache instance variables
221 PSParallelCompact::adjust_pointer((oop*)cache->constant_pool_addr());
223 // iteration over constant pool cache entries
224 for (int i = 0; i < cache->length(); ++i) {
225 cache->entry_at(i)->update_pointers();
226 }
228 return cache->object_size();
229 }
231 int
232 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
233 HeapWord* beg_addr,
234 HeapWord* end_addr) {
235 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
236 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
238 // Iteration over constant pool cache instance variables
239 oop* p;
240 p = (oop*)cache->constant_pool_addr();
241 PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
243 // Iteration over constant pool cache entries
244 for (int i = 0; i < cache->length(); ++i) {
245 cache->entry_at(i)->update_pointers(beg_addr, end_addr);
246 }
247 return cache->object_size();
248 }
249 #endif // SERIALGC
251 #ifndef PRODUCT
253 void constantPoolCacheKlass::oop_print_on(oop obj, outputStream* st) {
254 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
255 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
256 // super print
257 Klass::oop_print_on(obj, st);
258 // print constant pool cache entries
259 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->print(st, i);
260 }
262 #endif
264 void constantPoolCacheKlass::oop_verify_on(oop obj, outputStream* st) {
265 guarantee(obj->is_constantPoolCache(), "obj must be constant pool cache");
266 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
267 // super verify
268 Klass::oop_verify_on(obj, st);
269 // print constant pool cache entries
270 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->verify(st);
271 }
274 const char* constantPoolCacheKlass::internal_name() const {
275 return "{constant pool cache}";
276 }