|
0
|
1 /*
|
|
|
2 * Copyright 1998-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 */
|
|
|
24
|
|
|
25 #include "incls/_precompiled.incl"
|
|
|
26 #include "incls/_cpCacheKlass.cpp.incl"
|
|
|
27
|
|
|
28
|
|
|
29 int constantPoolCacheKlass::oop_size(oop obj) const {
|
|
|
30 assert(obj->is_constantPoolCache(), "must be constantPool");
|
|
|
31 return constantPoolCacheOop(obj)->object_size();
|
|
|
32 }
|
|
|
33
|
|
|
34
|
|
|
35 constantPoolCacheOop constantPoolCacheKlass::allocate(int length, TRAPS) {
|
|
|
36 // allocate memory
|
|
|
37 int size = constantPoolCacheOopDesc::object_size(length);
|
|
|
38 KlassHandle klass (THREAD, as_klassOop());
|
|
|
39 constantPoolCacheOop cache = (constantPoolCacheOop)
|
|
|
40 CollectedHeap::permanent_array_allocate(klass, size, length, CHECK_NULL);
|
|
|
41 cache->set_constant_pool(NULL);
|
|
|
42 return cache;
|
|
|
43 }
|
|
|
44
|
|
|
45
|
|
|
46 klassOop constantPoolCacheKlass::create_klass(TRAPS) {
|
|
|
47 constantPoolCacheKlass o;
|
|
|
48 KlassHandle klassklass(THREAD, Universe::arrayKlassKlassObj());
|
|
|
49 arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);
|
|
|
50 KlassHandle super (THREAD, k->super());
|
|
|
51 complete_create_array_klass(k, super, CHECK_NULL);
|
|
|
52 return k();
|
|
|
53 }
|
|
|
54
|
|
|
55
|
|
|
56 void constantPoolCacheKlass::oop_follow_contents(oop obj) {
|
|
|
57 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
58 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
59 // Performance tweak: We skip iterating over the klass pointer since we
|
|
|
60 // know that Universe::constantPoolCacheKlassObj never moves.
|
|
|
61 // gc of constant pool cache instance variables
|
|
|
62 MarkSweep::mark_and_push((oop*)cache->constant_pool_addr());
|
|
|
63 // gc of constant pool cache entries
|
|
|
64 int i = cache->length();
|
|
|
65 while (i-- > 0) cache->entry_at(i)->follow_contents();
|
|
|
66 }
|
|
|
67
|
|
|
68 #ifndef SERIALGC
|
|
|
69 void constantPoolCacheKlass::oop_follow_contents(ParCompactionManager* cm,
|
|
|
70 oop obj) {
|
|
|
71 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
72 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
73 // Performance tweak: We skip iterating over the klass pointer since we
|
|
|
74 // know that Universe::constantPoolCacheKlassObj never moves.
|
|
|
75 // gc of constant pool cache instance variables
|
|
|
76 PSParallelCompact::mark_and_push(cm, (oop*)cache->constant_pool_addr());
|
|
|
77 // gc of constant pool cache entries
|
|
|
78 int i = cache->length();
|
|
|
79 while (i-- > 0) cache->entry_at(i)->follow_contents(cm);
|
|
|
80 }
|
|
|
81 #endif // SERIALGC
|
|
|
82
|
|
|
83
|
|
|
84 int constantPoolCacheKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
|
|
|
85 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
86 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
87 // Get size before changing pointers.
|
|
|
88 // Don't call size() or oop_size() since that is a virtual call.
|
|
|
89 int size = cache->object_size();
|
|
|
90 // Performance tweak: We skip iterating over the klass pointer since we
|
|
|
91 // know that Universe::constantPoolCacheKlassObj never moves.
|
|
|
92 // iteration over constant pool cache instance variables
|
|
|
93 blk->do_oop((oop*)cache->constant_pool_addr());
|
|
|
94 // iteration over constant pool cache entries
|
|
|
95 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate(blk);
|
|
|
96 return size;
|
|
|
97 }
|
|
|
98
|
|
|
99
|
|
|
100 int constantPoolCacheKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
|
|
|
101 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
102 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
103 // Get size before changing pointers.
|
|
|
104 // Don't call size() or oop_size() since that is a virtual call.
|
|
|
105 int size = cache->object_size();
|
|
|
106 // Performance tweak: We skip iterating over the klass pointer since we
|
|
|
107 // know that Universe::constantPoolCacheKlassObj never moves.
|
|
|
108 // iteration over constant pool cache instance variables
|
|
|
109 oop* addr = (oop*)cache->constant_pool_addr();
|
|
|
110 if (mr.contains(addr)) blk->do_oop(addr);
|
|
|
111 // iteration over constant pool cache entries
|
|
|
112 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate_m(blk, mr);
|
|
|
113 return size;
|
|
|
114 }
|
|
|
115
|
|
|
116
|
|
|
117 int constantPoolCacheKlass::oop_adjust_pointers(oop obj) {
|
|
|
118 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
119 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
120 // Get size before changing pointers.
|
|
|
121 // Don't call size() or oop_size() since that is a virtual call.
|
|
|
122 int size = cache->object_size();
|
|
|
123 // Performance tweak: We skip iterating over the klass pointer since we
|
|
|
124 // know that Universe::constantPoolCacheKlassObj never moves.
|
|
|
125 // Iteration over constant pool cache instance variables
|
|
|
126 MarkSweep::adjust_pointer((oop*)cache->constant_pool_addr());
|
|
|
127 // iteration over constant pool cache entries
|
|
|
128 for (int i = 0; i < cache->length(); i++)
|
|
|
129 cache->entry_at(i)->adjust_pointers();
|
|
|
130 return size;
|
|
|
131 }
|
|
|
132
|
|
|
133 #ifndef SERIALGC
|
|
|
134 void constantPoolCacheKlass::oop_copy_contents(PSPromotionManager* pm,
|
|
|
135 oop obj) {
|
|
|
136 assert(obj->is_constantPoolCache(), "should be constant pool");
|
|
|
137 }
|
|
|
138
|
|
|
139 void constantPoolCacheKlass::oop_push_contents(PSPromotionManager* pm,
|
|
|
140 oop obj) {
|
|
|
141 assert(obj->is_constantPoolCache(), "should be constant pool");
|
|
|
142 }
|
|
|
143
|
|
|
144 int
|
|
|
145 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
|
|
|
146 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
147 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
148
|
|
|
149 // Iteration over constant pool cache instance variables
|
|
|
150 PSParallelCompact::adjust_pointer((oop*)cache->constant_pool_addr());
|
|
|
151
|
|
|
152 // iteration over constant pool cache entries
|
|
|
153 for (int i = 0; i < cache->length(); ++i) {
|
|
|
154 cache->entry_at(i)->update_pointers();
|
|
|
155 }
|
|
|
156
|
|
|
157 return cache->object_size();
|
|
|
158 }
|
|
|
159
|
|
|
160 int
|
|
|
161 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
|
|
|
162 HeapWord* beg_addr,
|
|
|
163 HeapWord* end_addr) {
|
|
|
164 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
165 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
166
|
|
|
167 // Iteration over constant pool cache instance variables
|
|
|
168 oop* p;
|
|
|
169 p = (oop*)cache->constant_pool_addr();
|
|
|
170 PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
|
|
|
171
|
|
|
172 // Iteration over constant pool cache entries
|
|
|
173 for (int i = 0; i < cache->length(); ++i) {
|
|
|
174 cache->entry_at(i)->update_pointers(beg_addr, end_addr);
|
|
|
175 }
|
|
|
176 return cache->object_size();
|
|
|
177 }
|
|
|
178 #endif // SERIALGC
|
|
|
179
|
|
|
180 #ifndef PRODUCT
|
|
|
181
|
|
|
182 void constantPoolCacheKlass::oop_print_on(oop obj, outputStream* st) {
|
|
|
183 assert(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
184 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
185 // super print
|
|
|
186 arrayKlass::oop_print_on(obj, st);
|
|
|
187 // print constant pool cache entries
|
|
|
188 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->print(st, i);
|
|
|
189 }
|
|
|
190
|
|
|
191 #endif
|
|
|
192
|
|
|
193 void constantPoolCacheKlass::oop_verify_on(oop obj, outputStream* st) {
|
|
|
194 guarantee(obj->is_constantPoolCache(), "obj must be constant pool cache");
|
|
|
195 constantPoolCacheOop cache = (constantPoolCacheOop)obj;
|
|
|
196 // super verify
|
|
|
197 arrayKlass::oop_verify_on(obj, st);
|
|
|
198 // print constant pool cache entries
|
|
|
199 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->verify(st);
|
|
|
200 }
|
|
|
201
|
|
|
202
|
|
|
203 const char* constantPoolCacheKlass::internal_name() const {
|
|
|
204 return "{constant pool cache}";
|
|
|
205 }
|
