Mercurial > hg > truffle
annotate src/share/vm/ci/ciObjectFactory.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 833b0f92429a |
| children | 6a528388c7da |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 20360 | 2 * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "ci/ciCallSite.hpp" | |
| 27 #include "ci/ciInstance.hpp" | |
| 28 #include "ci/ciInstanceKlass.hpp" | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
29 #include "ci/ciMemberName.hpp" |
| 1972 | 30 #include "ci/ciMethod.hpp" |
| 31 #include "ci/ciMethodData.hpp" | |
| 32 #include "ci/ciMethodHandle.hpp" | |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
33 #include "ci/ciMethodType.hpp" |
| 1972 | 34 #include "ci/ciNullObject.hpp" |
| 35 #include "ci/ciObjArray.hpp" | |
| 36 #include "ci/ciObjArrayKlass.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
37 #include "ci/ciObject.hpp" |
| 1972 | 38 #include "ci/ciObjectFactory.hpp" |
| 39 #include "ci/ciSymbol.hpp" | |
| 40 #include "ci/ciTypeArray.hpp" | |
| 41 #include "ci/ciTypeArrayKlass.hpp" | |
| 42 #include "ci/ciUtilities.hpp" | |
| 43 #include "classfile/systemDictionary.hpp" | |
| 44 #include "gc_interface/collectedHeap.inline.hpp" | |
| 45 #include "memory/allocation.inline.hpp" | |
| 46 #include "oops/oop.inline.hpp" | |
| 47 #include "oops/oop.inline2.hpp" | |
| 48 #include "runtime/fieldType.hpp" | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
49 #if INCLUDE_ALL_GCS |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
50 # include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp" |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
51 #endif |
| 0 | 52 |
| 53 // ciObjectFactory | |
| 54 // | |
| 55 // This class handles requests for the creation of new instances | |
| 56 // of ciObject and its subclasses. It contains a caching mechanism | |
| 57 // which ensures that for each oop, at most one ciObject is created. | |
| 58 // This invariant allows more efficient implementation of ciObject. | |
| 59 // | |
| 60 // Implementation note: the oop->ciObject mapping is represented as | |
| 61 // a table stored in an array. Even though objects are moved | |
| 62 // by the garbage collector, the compactor preserves their relative | |
| 63 // order; address comparison of oops (in perm space) is safe so long | |
| 64 // as we prohibit GC during our comparisons. We currently use binary | |
| 65 // search to find the oop in the table, and inserting a new oop | |
| 66 // into the table may be costly. If this cost ends up being | |
| 67 // problematic the underlying data structure can be switched to some | |
| 68 // sort of balanced binary tree. | |
| 69 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
70 GrowableArray<ciMetadata*>* ciObjectFactory::_shared_ci_metadata = NULL; |
| 0 | 71 ciSymbol* ciObjectFactory::_shared_ci_symbols[vmSymbols::SID_LIMIT]; |
| 72 int ciObjectFactory::_shared_ident_limit = 0; | |
| 73 volatile bool ciObjectFactory::_initialized = false; | |
| 74 | |
| 75 | |
| 76 // ------------------------------------------------------------------ | |
| 77 // ciObjectFactory::ciObjectFactory | |
| 78 ciObjectFactory::ciObjectFactory(Arena* arena, | |
| 79 int expected_size) { | |
| 80 | |
| 81 for (int i = 0; i < NON_PERM_BUCKETS; i++) { | |
| 82 _non_perm_bucket[i] = NULL; | |
| 83 } | |
| 84 _non_perm_count = 0; | |
| 85 | |
| 86 _next_ident = _shared_ident_limit; | |
| 87 _arena = arena; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
88 _ci_metadata = new (arena) GrowableArray<ciMetadata*>(arena, expected_size, 0, NULL); |
| 0 | 89 |
| 90 // If the shared ci objects exist append them to this factory's objects | |
| 91 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
92 if (_shared_ci_metadata != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
93 _ci_metadata->appendAll(_shared_ci_metadata); |
| 0 | 94 } |
| 95 | |
| 96 _unloaded_methods = new (arena) GrowableArray<ciMethod*>(arena, 4, 0, NULL); | |
| 97 _unloaded_klasses = new (arena) GrowableArray<ciKlass*>(arena, 8, 0, NULL); | |
| 1602 | 98 _unloaded_instances = new (arena) GrowableArray<ciInstance*>(arena, 4, 0, NULL); |
| 0 | 99 _return_addresses = |
| 100 new (arena) GrowableArray<ciReturnAddress*>(arena, 8, 0, NULL); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
101 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
102 _symbols = new (arena) GrowableArray<ciSymbol*>(arena, 100, 0, NULL); |
| 0 | 103 } |
| 104 | |
| 105 // ------------------------------------------------------------------ | |
| 106 // ciObjectFactory::ciObjectFactory | |
| 107 void ciObjectFactory::initialize() { | |
| 108 ASSERT_IN_VM; | |
| 109 JavaThread* thread = JavaThread::current(); | |
| 110 HandleMark handle_mark(thread); | |
| 111 | |
| 112 // This Arena is long lived and exists in the resource mark of the | |
| 113 // compiler thread that initializes the initial ciObjectFactory which | |
| 114 // creates the shared ciObjects that all later ciObjectFactories use. | |
| 20360 | 115 Arena* arena = new (mtCompiler) Arena(mtCompiler); |
| 0 | 116 ciEnv initial(arena); |
| 117 ciEnv* env = ciEnv::current(); | |
| 118 env->_factory->init_shared_objects(); | |
| 119 | |
| 120 _initialized = true; | |
| 121 | |
| 122 } | |
| 123 | |
| 124 void ciObjectFactory::init_shared_objects() { | |
| 125 | |
| 126 _next_ident = 1; // start numbering CI objects at 1 | |
| 127 | |
| 128 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
129 // Create the shared symbols, but not in _shared_ci_metadata. |
| 0 | 130 int i; |
| 131 for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
132 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
133 assert(vmSymbols::find_sid(vmsym) == i, "1-1 mapping"); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
134 ciSymbol* sym = new (_arena) ciSymbol(vmsym, (vmSymbols::SID) i); |
| 0 | 135 init_ident_of(sym); |
| 136 _shared_ci_symbols[i] = sym; | |
| 137 } | |
| 138 #ifdef ASSERT | |
| 139 for (i = vmSymbols::FIRST_SID; i < vmSymbols::SID_LIMIT; i++) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
140 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); |
| 0 | 141 ciSymbol* sym = vm_symbol_at((vmSymbols::SID) i); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
142 assert(sym->get_symbol() == vmsym, "oop must match"); |
| 0 | 143 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
144 assert(ciSymbol::void_class_signature()->get_symbol() == vmSymbols::void_class_signature(), "spot check"); |
| 0 | 145 #endif |
| 146 } | |
| 147 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
148 _ci_metadata = new (_arena) GrowableArray<ciMetadata*>(_arena, 64, 0, NULL); |
| 0 | 149 |
| 150 for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) { | |
| 151 BasicType t = (BasicType)i; | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6822
diff
changeset
|
152 if (type2name(t) != NULL && t != T_OBJECT && t != T_ARRAY && t != T_NARROWOOP && t != T_NARROWKLASS) { |
| 0 | 153 ciType::_basic_types[t] = new (_arena) ciType(t); |
| 154 init_ident_of(ciType::_basic_types[t]); | |
| 155 } | |
| 156 } | |
| 157 | |
| 158 ciEnv::_null_object_instance = new (_arena) ciNullObject(); | |
| 159 init_ident_of(ciEnv::_null_object_instance); | |
| 1142 | 160 |
| 161 #define WK_KLASS_DEFN(name, ignore_s, opt) \ | |
| 162 if (SystemDictionary::name() != NULL) \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
163 ciEnv::_##name = get_metadata(SystemDictionary::name())->as_instance_klass(); |
| 1142 | 164 |
| 165 WK_KLASSES_DO(WK_KLASS_DEFN) | |
| 166 #undef WK_KLASS_DEFN | |
| 0 | 167 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
168 for (int len = -1; len != _ci_metadata->length(); ) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
169 len = _ci_metadata->length(); |
| 0 | 170 for (int i2 = 0; i2 < len; i2++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
171 ciMetadata* obj = _ci_metadata->at(i2); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
172 assert (obj->is_metadata(), "what else would it be?"); |
| 0 | 173 if (obj->is_loaded() && obj->is_instance_klass()) { |
| 174 obj->as_instance_klass()->compute_nonstatic_fields(); | |
| 175 } | |
| 176 } | |
| 177 } | |
| 178 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
179 ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol()); |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
180 // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents |
| 0 | 181 ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL); |
| 182 init_ident_of(ciEnv::_unloaded_ciinstance_klass); | |
| 183 ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1); | |
| 184 init_ident_of(ciEnv::_unloaded_ciobjarrayklass); | |
| 185 assert(ciEnv::_unloaded_ciobjarrayklass->is_obj_array_klass(), "just checking"); | |
| 186 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
187 get_metadata(Universe::boolArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
188 get_metadata(Universe::charArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 get_metadata(Universe::singleArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
190 get_metadata(Universe::doubleArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
191 get_metadata(Universe::byteArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
192 get_metadata(Universe::shortArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
193 get_metadata(Universe::intArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
194 get_metadata(Universe::longArrayKlassObj()); |
| 0 | 195 |
| 196 | |
| 197 | |
| 198 assert(_non_perm_count == 0, "no shared non-perm objects"); | |
| 199 | |
| 200 // The shared_ident_limit is the first ident number that will | |
| 201 // be used for non-shared objects. That is, numbers less than | |
| 202 // this limit are permanently assigned to shared CI objects, | |
| 203 // while the higher numbers are recycled afresh by each new ciEnv. | |
| 204 | |
| 205 _shared_ident_limit = _next_ident; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
206 _shared_ci_metadata = _ci_metadata; |
| 0 | 207 } |
| 208 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
209 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
210 ciSymbol* ciObjectFactory::get_symbol(Symbol* key) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
211 vmSymbols::SID sid = vmSymbols::find_sid(key); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
212 if (sid != vmSymbols::NO_SID) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
213 // do not pollute the main cache with it |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
214 return vm_symbol_at(sid); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
215 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
216 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
217 assert(vmSymbols::find_sid(key) == vmSymbols::NO_SID, ""); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
218 ciSymbol* s = new (arena()) ciSymbol(key, vmSymbols::NO_SID); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 _symbols->push(s); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
220 return s; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
221 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
222 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
223 // Decrement the refcount when done on symbols referenced by this compilation. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
224 void ciObjectFactory::remove_symbols() { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 for (int i = 0; i < _symbols->length(); i++) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
226 ciSymbol* s = _symbols->at(i); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
227 s->get_symbol()->decrement_refcount(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
228 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
229 // Since _symbols is resource allocated we're not allowed to delete it |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
230 // but it'll go away just the same. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
231 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
232 |
| 0 | 233 // ------------------------------------------------------------------ |
| 234 // ciObjectFactory::get | |
| 235 // | |
| 236 // Get the ciObject corresponding to some oop. If the ciObject has | |
| 237 // already been created, it is returned. Otherwise, a new ciObject | |
| 238 // is created. | |
| 239 ciObject* ciObjectFactory::get(oop key) { | |
| 240 ASSERT_IN_VM; | |
| 241 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
242 assert(key == NULL || Universe::heap()->is_in_reserved(key), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
243 |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
244 NonPermObject* &bucket = find_non_perm(key); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
245 if (bucket != NULL) { |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
246 return bucket->object(); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
247 } |
| 0 | 248 |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
249 // The ciObject does not yet exist. Create it and insert it |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
250 // into the cache. |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
251 Handle keyHandle(key); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
252 ciObject* new_object = create_new_object(keyHandle()); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
253 assert(keyHandle() == new_object->get_oop(), "must be properly recorded"); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
254 init_ident_of(new_object); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
255 assert(Universe::heap()->is_in_reserved(new_object->get_oop()), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
256 |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
257 // Not a perm-space object. |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
258 insert_non_perm(bucket, keyHandle(), new_object); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
259 return new_object; |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
260 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
261 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
262 // ------------------------------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
263 // ciObjectFactory::get |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
264 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
265 // Get the ciObject corresponding to some oop. If the ciObject has |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
266 // already been created, it is returned. Otherwise, a new ciObject |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
267 // is created. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
268 ciMetadata* ciObjectFactory::get_metadata(Metadata* key) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
269 ASSERT_IN_VM; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
270 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
271 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
272 if (CIObjectFactoryVerify) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
273 Metadata* last = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
274 for (int j = 0; j< _ci_metadata->length(); j++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
275 Metadata* o = _ci_metadata->at(j)->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
276 assert(last < o, "out of order"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
277 last = o; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
278 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
279 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
280 #endif // ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
281 int len = _ci_metadata->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
282 int index = find(key, _ci_metadata); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
283 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
284 if (CIObjectFactoryVerify) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
285 for (int i=0; i<_ci_metadata->length(); i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
286 if (_ci_metadata->at(i)->constant_encoding() == key) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
287 assert(index == i, " bad lookup"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
288 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
289 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
290 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
291 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
292 if (!is_found_at(index, key, _ci_metadata)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
293 // The ciObject does not yet exist. Create it and insert it |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
294 // into the cache. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
295 ciMetadata* new_object = create_new_object(key); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
296 init_ident_of(new_object); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
297 assert(new_object->is_metadata(), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
298 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
299 if (len != _ci_metadata->length()) { |
| 0 | 300 // creating the new object has recursively entered new objects |
| 301 // into the table. We need to recompute our index. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
302 index = find(key, _ci_metadata); |
| 0 | 303 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
304 assert(!is_found_at(index, key, _ci_metadata), "no double insert"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
305 insert(index, new_object, _ci_metadata); |
| 0 | 306 return new_object; |
| 307 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
308 return _ci_metadata->at(index)->as_metadata(); |
| 0 | 309 } |
| 310 | |
| 311 // ------------------------------------------------------------------ | |
| 312 // ciObjectFactory::create_new_object | |
| 313 // | |
| 314 // Create a new ciObject from an oop. | |
| 315 // | |
| 316 // Implementation note: this functionality could be virtual behavior | |
| 317 // of the oop itself. For now, we explicitly marshal the object. | |
| 318 ciObject* ciObjectFactory::create_new_object(oop o) { | |
| 319 EXCEPTION_CONTEXT; | |
| 320 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
321 if (o->is_instance()) { |
| 0 | 322 instanceHandle h_i(THREAD, (instanceOop)o); |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
323 if (java_lang_invoke_CallSite::is_instance(o)) |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
324 return new (arena()) ciCallSite(h_i); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
325 else if (java_lang_invoke_MemberName::is_instance(o)) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
326 return new (arena()) ciMemberName(h_i); |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2177
diff
changeset
|
327 else if (java_lang_invoke_MethodHandle::is_instance(o)) |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
328 return new (arena()) ciMethodHandle(h_i); |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
329 else if (java_lang_invoke_MethodType::is_instance(o)) |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6725
diff
changeset
|
330 return new (arena()) ciMethodType(h_i); |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
331 else |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
332 return new (arena()) ciInstance(h_i); |
| 0 | 333 } else if (o->is_objArray()) { |
| 334 objArrayHandle h_oa(THREAD, (objArrayOop)o); | |
| 335 return new (arena()) ciObjArray(h_oa); | |
| 336 } else if (o->is_typeArray()) { | |
| 337 typeArrayHandle h_ta(THREAD, (typeArrayOop)o); | |
| 338 return new (arena()) ciTypeArray(h_ta); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
339 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
340 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
341 // The oop is of some type not supported by the compiler interface. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
342 ShouldNotReachHere(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
343 return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
344 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
345 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
346 // ------------------------------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
347 // ciObjectFactory::create_new_object |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
348 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
349 // Create a new ciObject from a Metadata*. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
350 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
351 // Implementation note: this functionality could be virtual behavior |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
352 // of the oop itself. For now, we explicitly marshal the object. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
353 ciMetadata* ciObjectFactory::create_new_object(Metadata* o) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
354 EXCEPTION_CONTEXT; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
355 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
356 if (o->is_klass()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
357 KlassHandle h_k(THREAD, (Klass*)o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
358 Klass* k = (Klass*)o; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
359 if (k->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
360 return new (arena()) ciInstanceKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
361 } else if (k->oop_is_objArray()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
362 return new (arena()) ciObjArrayKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
363 } else if (k->oop_is_typeArray()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
364 return new (arena()) ciTypeArrayKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
365 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
366 } else if (o->is_method()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
367 methodHandle h_m(THREAD, (Method*)o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
368 return new (arena()) ciMethod(h_m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
369 } else if (o->is_methodData()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
370 // Hold methodHandle alive - might not be necessary ??? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
371 methodHandle h_m(THREAD, ((MethodData*)o)->method()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
372 return new (arena()) ciMethodData((MethodData*)o); |
| 0 | 373 } |
| 374 | |
| 375 // The oop is of some type not supported by the compiler interface. | |
| 376 ShouldNotReachHere(); | |
| 377 return NULL; | |
| 378 } | |
| 379 | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
380 // ------------------------------------------------------------------ |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
381 // ciObjectFactory::ensure_metadata_alive |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
382 // |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
383 // Ensure that the metadata wrapped by the ciMetadata is kept alive by GC. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
384 // This is primarily useful for metadata which is considered as weak roots |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
385 // by the GC but need to be strong roots if reachable from a current compilation. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
386 // |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
387 void ciObjectFactory::ensure_metadata_alive(ciMetadata* m) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
388 ASSERT_IN_VM; // We're handling raw oops here. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
389 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
390 #if INCLUDE_ALL_GCS |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
391 if (!UseG1GC) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
392 return; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
393 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
394 Klass* metadata_owner_klass; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
395 if (m->is_klass()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
396 metadata_owner_klass = m->as_klass()->get_Klass(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
397 } else if (m->is_method()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
398 metadata_owner_klass = m->as_method()->get_Method()->constants()->pool_holder(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
399 } else { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
400 fatal("Not implemented for other types of metadata"); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
401 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
402 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
403 oop metadata_holder = metadata_owner_klass->klass_holder(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
404 if (metadata_holder != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
405 G1SATBCardTableModRefBS::enqueue(metadata_holder); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
406 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
407 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
408 #endif |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
409 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
17467
diff
changeset
|
410 |
| 0 | 411 //------------------------------------------------------------------ |
| 412 // ciObjectFactory::get_unloaded_method | |
| 413 // | |
| 414 // Get the ciMethod representing an unloaded/unfound method. | |
| 415 // | |
| 416 // Implementation note: unloaded methods are currently stored in | |
| 417 // an unordered array, requiring a linear-time lookup for each | |
| 418 // unloaded method. This may need to change. | |
| 419 ciMethod* ciObjectFactory::get_unloaded_method(ciInstanceKlass* holder, | |
| 420 ciSymbol* name, | |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
421 ciSymbol* signature, |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
422 ciInstanceKlass* accessor) { |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
423 ciSignature* that = NULL; |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
424 for (int i = 0; i < _unloaded_methods->length(); i++) { |
| 0 | 425 ciMethod* entry = _unloaded_methods->at(i); |
| 426 if (entry->holder()->equals(holder) && | |
| 427 entry->name()->equals(name) && | |
| 428 entry->signature()->as_symbol()->equals(signature)) { | |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
429 // Short-circuit slow resolve. |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
430 if (entry->signature()->accessing_klass() == accessor) { |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
431 // We've found a match. |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
432 return entry; |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
433 } else { |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
434 // Lazily create ciSignature |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
435 if (that == NULL) that = new (arena()) ciSignature(accessor, constantPoolHandle(), signature); |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
436 if (entry->signature()->equals(that)) { |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
437 // We've found a match. |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
438 return entry; |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
439 } |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
440 } |
| 0 | 441 } |
| 442 } | |
| 443 | |
| 444 // This is a new unloaded method. Create it and stick it in | |
| 445 // the cache. | |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
446 ciMethod* new_method = new (arena()) ciMethod(holder, name, signature, accessor); |
| 0 | 447 |
| 448 init_ident_of(new_method); | |
| 449 _unloaded_methods->append(new_method); | |
| 450 | |
| 451 return new_method; | |
| 452 } | |
| 453 | |
| 454 //------------------------------------------------------------------ | |
| 455 // ciObjectFactory::get_unloaded_klass | |
| 456 // | |
| 457 // Get a ciKlass representing an unloaded klass. | |
| 458 // | |
| 459 // Implementation note: unloaded klasses are currently stored in | |
| 460 // an unordered array, requiring a linear-time lookup for each | |
| 461 // unloaded klass. This may need to change. | |
| 462 ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass, | |
| 463 ciSymbol* name, | |
| 464 bool create_if_not_found) { | |
| 465 EXCEPTION_CONTEXT; | |
| 466 oop loader = NULL; | |
| 467 oop domain = NULL; | |
| 468 if (accessing_klass != NULL) { | |
| 469 loader = accessing_klass->loader(); | |
| 470 domain = accessing_klass->protection_domain(); | |
| 471 } | |
| 472 for (int i=0; i<_unloaded_klasses->length(); i++) { | |
| 473 ciKlass* entry = _unloaded_klasses->at(i); | |
| 474 if (entry->name()->equals(name) && | |
| 475 entry->loader() == loader && | |
| 476 entry->protection_domain() == domain) { | |
| 477 // We've found a match. | |
| 478 return entry; | |
| 479 } | |
| 480 } | |
| 481 | |
| 482 if (!create_if_not_found) | |
| 483 return NULL; | |
| 484 | |
| 485 // This is a new unloaded klass. Create it and stick it in | |
| 486 // the cache. | |
| 487 ciKlass* new_klass = NULL; | |
| 488 | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
489 // Two cases: this is an unloaded ObjArrayKlass or an |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
490 // unloaded InstanceKlass. Deal with both. |
| 0 | 491 if (name->byte_at(0) == '[') { |
| 492 // Decompose the name.' | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
493 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
494 BasicType element_type = FieldType::get_array_info(name->get_symbol(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
495 fd, THREAD); |
| 0 | 496 if (HAS_PENDING_EXCEPTION) { |
| 497 CLEAR_PENDING_EXCEPTION; | |
| 498 CURRENT_THREAD_ENV->record_out_of_memory_failure(); | |
| 499 return ciEnv::_unloaded_ciobjarrayklass; | |
| 500 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
501 int dimension = fd.dimension(); |
| 0 | 502 assert(element_type != T_ARRAY, "unsuccessful decomposition"); |
| 503 ciKlass* element_klass = NULL; | |
| 504 if (element_type == T_OBJECT) { | |
| 505 ciEnv *env = CURRENT_THREAD_ENV; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
506 ciSymbol* ci_name = env->get_symbol(fd.object_key()); |
| 0 | 507 element_klass = |
| 508 env->get_klass_by_name(accessing_klass, ci_name, false)->as_instance_klass(); | |
| 509 } else { | |
| 510 assert(dimension > 1, "one dimensional type arrays are always loaded."); | |
| 511 | |
| 512 // The type array itself takes care of one of the dimensions. | |
| 513 dimension--; | |
| 514 | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
515 // The element klass is a TypeArrayKlass. |
| 0 | 516 element_klass = ciTypeArrayKlass::make(element_type); |
| 517 } | |
| 518 new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension); | |
| 519 } else { | |
| 520 jobject loader_handle = NULL; | |
| 521 jobject domain_handle = NULL; | |
| 522 if (accessing_klass != NULL) { | |
| 523 loader_handle = accessing_klass->loader_handle(); | |
| 524 domain_handle = accessing_klass->protection_domain_handle(); | |
| 525 } | |
| 526 new_klass = new (arena()) ciInstanceKlass(name, loader_handle, domain_handle); | |
| 527 } | |
| 528 init_ident_of(new_klass); | |
| 529 _unloaded_klasses->append(new_klass); | |
| 530 | |
| 531 return new_klass; | |
| 532 } | |
| 533 | |
| 1602 | 534 |
| 535 //------------------------------------------------------------------ | |
| 536 // ciObjectFactory::get_unloaded_instance | |
| 537 // | |
| 538 // Get a ciInstance representing an as-yet undetermined instance of a given class. | |
| 539 // | |
| 540 ciInstance* ciObjectFactory::get_unloaded_instance(ciInstanceKlass* instance_klass) { | |
| 541 for (int i=0; i<_unloaded_instances->length(); i++) { | |
| 542 ciInstance* entry = _unloaded_instances->at(i); | |
| 543 if (entry->klass()->equals(instance_klass)) { | |
| 544 // We've found a match. | |
| 545 return entry; | |
| 546 } | |
| 547 } | |
| 548 | |
| 549 // This is a new unloaded instance. Create it and stick it in | |
| 550 // the cache. | |
| 551 ciInstance* new_instance = new (arena()) ciInstance(instance_klass); | |
| 552 | |
| 553 init_ident_of(new_instance); | |
| 554 _unloaded_instances->append(new_instance); | |
| 555 | |
| 556 // make sure it looks the way we want: | |
| 557 assert(!new_instance->is_loaded(), ""); | |
| 558 assert(new_instance->klass() == instance_klass, ""); | |
| 559 | |
| 560 return new_instance; | |
| 561 } | |
| 562 | |
| 563 | |
| 564 //------------------------------------------------------------------ | |
| 565 // ciObjectFactory::get_unloaded_klass_mirror | |
| 566 // | |
| 567 // Get a ciInstance representing an unresolved klass mirror. | |
| 568 // | |
| 569 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 570 ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass* type) { | |
| 571 assert(ciEnv::_Class_klass != NULL, ""); | |
| 572 return get_unloaded_instance(ciEnv::_Class_klass->as_instance_klass()); | |
| 573 } | |
| 574 | |
| 575 //------------------------------------------------------------------ | |
| 576 // ciObjectFactory::get_unloaded_method_handle_constant | |
| 577 // | |
| 578 // Get a ciInstance representing an unresolved method handle constant. | |
| 579 // | |
| 580 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 581 ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass* holder, | |
| 582 ciSymbol* name, | |
| 583 ciSymbol* signature, | |
| 584 int ref_kind) { | |
| 585 if (ciEnv::_MethodHandle_klass == NULL) return NULL; | |
| 586 return get_unloaded_instance(ciEnv::_MethodHandle_klass->as_instance_klass()); | |
| 587 } | |
| 588 | |
| 589 //------------------------------------------------------------------ | |
| 590 // ciObjectFactory::get_unloaded_method_type_constant | |
| 591 // | |
| 592 // Get a ciInstance representing an unresolved method type constant. | |
| 593 // | |
| 594 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 595 ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signature) { | |
| 596 if (ciEnv::_MethodType_klass == NULL) return NULL; | |
| 597 return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass()); | |
| 598 } | |
| 599 | |
|
12160
f98f5d48f511
7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents:
11034
diff
changeset
|
600 ciInstance* ciObjectFactory::get_unloaded_object_constant() { |
|
f98f5d48f511
7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents:
11034
diff
changeset
|
601 if (ciEnv::_Object_klass == NULL) return NULL; |
|
f98f5d48f511
7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents:
11034
diff
changeset
|
602 return get_unloaded_instance(ciEnv::_Object_klass->as_instance_klass()); |
|
f98f5d48f511
7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked
roland
parents:
11034
diff
changeset
|
603 } |
| 1602 | 604 |
| 0 | 605 //------------------------------------------------------------------ |
| 606 // ciObjectFactory::get_empty_methodData | |
| 607 // | |
| 608 // Get the ciMethodData representing the methodData for a method with | |
| 609 // none. | |
| 610 ciMethodData* ciObjectFactory::get_empty_methodData() { | |
| 611 ciMethodData* new_methodData = new (arena()) ciMethodData(); | |
| 612 init_ident_of(new_methodData); | |
| 613 return new_methodData; | |
| 614 } | |
| 615 | |
| 616 //------------------------------------------------------------------ | |
| 617 // ciObjectFactory::get_return_address | |
| 618 // | |
| 619 // Get a ciReturnAddress for a specified bci. | |
| 620 ciReturnAddress* ciObjectFactory::get_return_address(int bci) { | |
| 621 for (int i=0; i<_return_addresses->length(); i++) { | |
| 622 ciReturnAddress* entry = _return_addresses->at(i); | |
| 623 if (entry->bci() == bci) { | |
| 624 // We've found a match. | |
| 625 return entry; | |
| 626 } | |
| 627 } | |
| 628 | |
| 629 ciReturnAddress* new_ret_addr = new (arena()) ciReturnAddress(bci); | |
| 630 init_ident_of(new_ret_addr); | |
| 631 _return_addresses->append(new_ret_addr); | |
| 632 return new_ret_addr; | |
| 633 } | |
| 634 | |
| 635 // ------------------------------------------------------------------ | |
| 636 // ciObjectFactory::init_ident_of | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
637 void ciObjectFactory::init_ident_of(ciBaseObject* obj) { |
| 0 | 638 obj->set_ident(_next_ident++); |
| 639 } | |
| 640 | |
| 641 // ------------------------------------------------------------------ | |
| 642 // ciObjectFactory::find | |
| 643 // | |
| 644 // Use binary search to find the position of this oop in the cache. | |
| 645 // If there is no entry in the cache corresponding to this oop, return | |
| 646 // the position at which the oop should be inserted. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
647 int ciObjectFactory::find(Metadata* key, GrowableArray<ciMetadata*>* objects) { |
| 0 | 648 int min = 0; |
| 649 int max = objects->length()-1; | |
| 650 | |
| 651 // print_contents(); | |
| 652 | |
| 653 while (max >= min) { | |
| 654 int mid = (max + min) / 2; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
655 Metadata* value = objects->at(mid)->constant_encoding(); |
| 0 | 656 if (value < key) { |
| 657 min = mid + 1; | |
| 658 } else if (value > key) { | |
| 659 max = mid - 1; | |
| 660 } else { | |
| 661 return mid; | |
| 662 } | |
| 663 } | |
| 664 return min; | |
| 665 } | |
| 666 | |
| 667 // ------------------------------------------------------------------ | |
| 668 // ciObjectFactory::is_found_at | |
| 669 // | |
| 670 // Verify that the binary seach found the given key. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
671 bool ciObjectFactory::is_found_at(int index, Metadata* key, GrowableArray<ciMetadata*>* objects) { |
| 0 | 672 return (index < objects->length() && |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
673 objects->at(index)->constant_encoding() == key); |
| 0 | 674 } |
| 675 | |
| 676 | |
| 677 // ------------------------------------------------------------------ | |
| 678 // ciObjectFactory::insert | |
| 679 // | |
| 680 // Insert a ciObject into the table at some index. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
681 void ciObjectFactory::insert(int index, ciMetadata* obj, GrowableArray<ciMetadata*>* objects) { |
| 0 | 682 int len = objects->length(); |
| 683 if (len == index) { | |
| 684 objects->append(obj); | |
| 685 } else { | |
| 686 objects->append(objects->at(len-1)); | |
| 687 int pos; | |
| 688 for (pos = len-2; pos >= index; pos--) { | |
| 689 objects->at_put(pos+1,objects->at(pos)); | |
| 690 } | |
| 691 objects->at_put(index, obj); | |
| 692 } | |
| 693 } | |
| 694 | |
| 695 static ciObjectFactory::NonPermObject* emptyBucket = NULL; | |
| 696 | |
| 697 // ------------------------------------------------------------------ | |
| 698 // ciObjectFactory::find_non_perm | |
| 699 // | |
| 700 // Use a small hash table, hashed on the klass of the key. | |
| 701 // If there is no entry in the cache corresponding to this oop, return | |
| 702 // the null tail of the bucket into which the oop should be inserted. | |
| 703 ciObjectFactory::NonPermObject* &ciObjectFactory::find_non_perm(oop key) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
704 assert(Universe::heap()->is_in_reserved_or_null(key), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
705 ciMetadata* klass = get_metadata(key->klass()); |
| 0 | 706 NonPermObject* *bp = &_non_perm_bucket[(unsigned) klass->hash() % NON_PERM_BUCKETS]; |
| 707 for (NonPermObject* p; (p = (*bp)) != NULL; bp = &p->next()) { | |
| 708 if (is_equal(p, key)) break; | |
| 709 } | |
| 710 return (*bp); | |
| 711 } | |
| 712 | |
| 713 | |
| 714 | |
| 715 // ------------------------------------------------------------------ | |
| 716 // Code for for NonPermObject | |
| 717 // | |
| 718 inline ciObjectFactory::NonPermObject::NonPermObject(ciObjectFactory::NonPermObject* &bucket, oop key, ciObject* object) { | |
| 719 assert(ciObjectFactory::is_initialized(), ""); | |
| 720 _object = object; | |
| 721 _next = bucket; | |
| 722 bucket = this; | |
| 723 } | |
| 724 | |
| 725 | |
| 726 | |
| 727 // ------------------------------------------------------------------ | |
| 728 // ciObjectFactory::insert_non_perm | |
| 729 // | |
| 730 // Insert a ciObject into the non-perm table. | |
| 731 void ciObjectFactory::insert_non_perm(ciObjectFactory::NonPermObject* &where, oop key, ciObject* obj) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
732 assert(Universe::heap()->is_in_reserved_or_null(key), "must be"); |
| 0 | 733 assert(&where != &emptyBucket, "must not try to fill empty bucket"); |
| 734 NonPermObject* p = new (arena()) NonPermObject(where, key, obj); | |
| 735 assert(where == p && is_equal(p, key) && p->object() == obj, "entry must match"); | |
| 736 assert(find_non_perm(key) == p, "must find the same spot"); | |
| 737 ++_non_perm_count; | |
| 738 } | |
| 739 | |
| 740 // ------------------------------------------------------------------ | |
| 741 // ciObjectFactory::vm_symbol_at | |
| 742 // Get the ciSymbol corresponding to some index in vmSymbols. | |
| 743 ciSymbol* ciObjectFactory::vm_symbol_at(int index) { | |
| 744 assert(index >= vmSymbols::FIRST_SID && index < vmSymbols::SID_LIMIT, "oob"); | |
| 745 return _shared_ci_symbols[index]; | |
| 746 } | |
| 747 | |
| 748 // ------------------------------------------------------------------ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
749 // ciObjectFactory::metadata_do |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
750 void ciObjectFactory::metadata_do(void f(Metadata*)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
751 if (_ci_metadata == NULL) return; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
752 for (int j = 0; j< _ci_metadata->length(); j++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
753 Metadata* o = _ci_metadata->at(j)->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
754 f(o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
755 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
756 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
757 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
758 // ------------------------------------------------------------------ |
| 0 | 759 // ciObjectFactory::print_contents_impl |
| 760 void ciObjectFactory::print_contents_impl() { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
761 int len = _ci_metadata->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
762 tty->print_cr("ciObjectFactory (%d) meta data contents:", len); |
| 0 | 763 for (int i=0; i<len; i++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
764 _ci_metadata->at(i)->print(); |
| 0 | 765 tty->cr(); |
| 766 } | |
| 767 } | |
| 768 | |
| 769 // ------------------------------------------------------------------ | |
| 770 // ciObjectFactory::print_contents | |
| 771 void ciObjectFactory::print_contents() { | |
| 772 print(); | |
| 773 tty->cr(); | |
| 774 GUARDED_VM_ENTRY(print_contents_impl();) | |
| 775 } | |
| 776 | |
| 777 // ------------------------------------------------------------------ | |
| 778 // ciObjectFactory::print | |
| 779 // | |
| 780 // Print debugging information about the object factory | |
| 781 void ciObjectFactory::print() { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
782 tty->print("<ciObjectFactory oops=%d metadata=%d unloaded_methods=%d unloaded_instances=%d unloaded_klasses=%d>", |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
783 _non_perm_count, _ci_metadata->length(), _unloaded_methods->length(), |
| 1602 | 784 _unloaded_instances->length(), |
| 0 | 785 _unloaded_klasses->length()); |
| 786 } |