1 /* 2 * Copyright (c) 1998, 2009, 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/_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, 36 bool is_conc_safe, 37 TRAPS) { 38 // allocate memory 39 int size = constantPoolCacheOopDesc::object_size(length); 40 41 KlassHandle klass (THREAD, as_klassOop()); 42 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); 48 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)); 59 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); 65 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 } 75 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 } 85 86 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 } 98 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 113 114 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 } 129 130 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 } 146 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 } 162 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 } 167 168 #ifndef SERIALGC 169 void constantPoolCacheKlass::oop_push_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_depth(p); 184 assert(!(e->is_vfinal() && PSScavenge::should_scavenge((oop*)&e->_f2)), 185 "no live oops here"); 186 } 187 } 188 } 189 } 190 } 191 192 int 193 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { 194 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); 195 constantPoolCacheOop cache = (constantPoolCacheOop)obj; 196 197 // Iteration over constant pool cache instance variables 198 PSParallelCompact::adjust_pointer((oop*)cache->constant_pool_addr()); 199 200 // iteration over constant pool cache entries 201 for (int i = 0; i < cache->length(); ++i) { 202 cache->entry_at(i)->update_pointers(); 203 } 204 205 return cache->object_size(); 206 } 207 208 int 209 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, 210 HeapWord* beg_addr, 211 HeapWord* end_addr) { 212 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); 213 constantPoolCacheOop cache = (constantPoolCacheOop)obj; 214 215 // Iteration over constant pool cache instance variables 216 oop* p; 217 p = (oop*)cache->constant_pool_addr(); 218 PSParallelCompact::adjust_pointer(p, beg_addr, end_addr); 219 220 // Iteration over constant pool cache entries 221 for (int i = 0; i < cache->length(); ++i) { 222 cache->entry_at(i)->update_pointers(beg_addr, end_addr); 223 } 224 return cache->object_size(); 225 } 226 #endif // SERIALGC 227 228 void constantPoolCacheKlass::oop_print_on(oop obj, outputStream* st) { 229 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); 230 constantPoolCacheOop cache = (constantPoolCacheOop)obj; 231 // super print 232 Klass::oop_print_on(obj, st); 233 // print constant pool cache entries 234 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->print(st, i); 235 } 236 237 void constantPoolCacheKlass::oop_print_value_on(oop obj, outputStream* st) { 238 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); 239 constantPoolCacheOop cache = (constantPoolCacheOop)obj; 240 st->print("cache [%d]", cache->length()); 241 cache->print_address_on(st); 242 st->print(" for "); 243 cache->constant_pool()->print_value_on(st); 244 } 245 246 void constantPoolCacheKlass::oop_verify_on(oop obj, outputStream* st) { 247 guarantee(obj->is_constantPoolCache(), "obj must be constant pool cache"); 248 constantPoolCacheOop cache = (constantPoolCacheOop)obj; 249 // super verify 250 Klass::oop_verify_on(obj, st); 251 // print constant pool cache entries 252 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->verify(st); 253 } 254 255 256 const char* constantPoolCacheKlass::internal_name() const { 257 return "{constant pool cache}"; 258 }