Mercurial > hg > graal-compiler
annotate src/share/vm/ci/ciObjectFactory.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | d804e148cff8 |
| children | e522a00b91aa e0c9a1d29eb4 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2 * Copyright (c) 1999, 2012, 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" | |
| 0 | 49 |
| 50 // ciObjectFactory | |
| 51 // | |
| 52 // This class handles requests for the creation of new instances | |
| 53 // of ciObject and its subclasses. It contains a caching mechanism | |
| 54 // which ensures that for each oop, at most one ciObject is created. | |
| 55 // This invariant allows more efficient implementation of ciObject. | |
| 56 // | |
| 57 // Implementation note: the oop->ciObject mapping is represented as | |
| 58 // a table stored in an array. Even though objects are moved | |
| 59 // by the garbage collector, the compactor preserves their relative | |
| 60 // order; address comparison of oops (in perm space) is safe so long | |
| 61 // as we prohibit GC during our comparisons. We currently use binary | |
| 62 // search to find the oop in the table, and inserting a new oop | |
| 63 // into the table may be costly. If this cost ends up being | |
| 64 // problematic the underlying data structure can be switched to some | |
| 65 // sort of balanced binary tree. | |
| 66 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
67 GrowableArray<ciMetadata*>* ciObjectFactory::_shared_ci_metadata = NULL; |
| 0 | 68 ciSymbol* ciObjectFactory::_shared_ci_symbols[vmSymbols::SID_LIMIT]; |
| 69 int ciObjectFactory::_shared_ident_limit = 0; | |
| 70 volatile bool ciObjectFactory::_initialized = false; | |
| 71 | |
| 72 | |
| 73 // ------------------------------------------------------------------ | |
| 74 // ciObjectFactory::ciObjectFactory | |
| 75 ciObjectFactory::ciObjectFactory(Arena* arena, | |
| 76 int expected_size) { | |
| 77 | |
| 78 for (int i = 0; i < NON_PERM_BUCKETS; i++) { | |
| 79 _non_perm_bucket[i] = NULL; | |
| 80 } | |
| 81 _non_perm_count = 0; | |
| 82 | |
| 83 _next_ident = _shared_ident_limit; | |
| 84 _arena = arena; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
85 _ci_metadata = new (arena) GrowableArray<ciMetadata*>(arena, expected_size, 0, NULL); |
| 0 | 86 |
| 87 // If the shared ci objects exist append them to this factory's objects | |
| 88 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
89 if (_shared_ci_metadata != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
90 _ci_metadata->appendAll(_shared_ci_metadata); |
| 0 | 91 } |
| 92 | |
| 93 _unloaded_methods = new (arena) GrowableArray<ciMethod*>(arena, 4, 0, NULL); | |
| 94 _unloaded_klasses = new (arena) GrowableArray<ciKlass*>(arena, 8, 0, NULL); | |
| 1602 | 95 _unloaded_instances = new (arena) GrowableArray<ciInstance*>(arena, 4, 0, NULL); |
| 0 | 96 _return_addresses = |
| 97 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
|
98 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
99 _symbols = new (arena) GrowableArray<ciSymbol*>(arena, 100, 0, NULL); |
| 0 | 100 } |
| 101 | |
| 102 // ------------------------------------------------------------------ | |
| 103 // ciObjectFactory::ciObjectFactory | |
| 104 void ciObjectFactory::initialize() { | |
| 105 ASSERT_IN_VM; | |
| 106 JavaThread* thread = JavaThread::current(); | |
| 107 HandleMark handle_mark(thread); | |
| 108 | |
| 109 // This Arena is long lived and exists in the resource mark of the | |
| 110 // compiler thread that initializes the initial ciObjectFactory which | |
| 111 // creates the shared ciObjects that all later ciObjectFactories use. | |
| 6197 | 112 Arena* arena = new (mtCompiler) Arena(); |
| 0 | 113 ciEnv initial(arena); |
| 114 ciEnv* env = ciEnv::current(); | |
| 115 env->_factory->init_shared_objects(); | |
| 116 | |
| 117 _initialized = true; | |
| 118 | |
| 119 } | |
| 120 | |
| 121 void ciObjectFactory::init_shared_objects() { | |
| 122 | |
| 123 _next_ident = 1; // start numbering CI objects at 1 | |
| 124 | |
| 125 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
126 // Create the shared symbols, but not in _shared_ci_metadata. |
| 0 | 127 int i; |
| 128 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
|
129 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
130 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
|
131 ciSymbol* sym = new (_arena) ciSymbol(vmsym, (vmSymbols::SID) i); |
| 0 | 132 init_ident_of(sym); |
| 133 _shared_ci_symbols[i] = sym; | |
| 134 } | |
| 135 #ifdef ASSERT | |
| 136 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
|
137 Symbol* vmsym = vmSymbols::symbol_at((vmSymbols::SID) i); |
| 0 | 138 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
|
139 assert(sym->get_symbol() == vmsym, "oop must match"); |
| 0 | 140 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
141 assert(ciSymbol::void_class_signature()->get_symbol() == vmSymbols::void_class_signature(), "spot check"); |
| 0 | 142 #endif |
| 143 } | |
| 144 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
145 _ci_metadata = new (_arena) GrowableArray<ciMetadata*>(_arena, 64, 0, NULL); |
| 0 | 146 |
| 147 for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) { | |
| 148 BasicType t = (BasicType)i; | |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6822
diff
changeset
|
149 if (type2name(t) != NULL && t != T_OBJECT && t != T_ARRAY && t != T_NARROWOOP && t != T_NARROWKLASS) { |
| 0 | 150 ciType::_basic_types[t] = new (_arena) ciType(t); |
| 151 init_ident_of(ciType::_basic_types[t]); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 ciEnv::_null_object_instance = new (_arena) ciNullObject(); | |
| 156 init_ident_of(ciEnv::_null_object_instance); | |
| 1142 | 157 |
| 158 #define WK_KLASS_DEFN(name, ignore_s, opt) \ | |
| 159 if (SystemDictionary::name() != NULL) \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
160 ciEnv::_##name = get_metadata(SystemDictionary::name())->as_instance_klass(); |
| 1142 | 161 |
| 162 WK_KLASSES_DO(WK_KLASS_DEFN) | |
| 163 #undef WK_KLASS_DEFN | |
| 0 | 164 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
165 for (int len = -1; len != _ci_metadata->length(); ) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
166 len = _ci_metadata->length(); |
| 0 | 167 for (int i2 = 0; i2 < len; i2++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
168 ciMetadata* obj = _ci_metadata->at(i2); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
169 assert (obj->is_metadata(), "what else would it be?"); |
| 0 | 170 if (obj->is_loaded() && obj->is_instance_klass()) { |
| 171 obj->as_instance_klass()->compute_nonstatic_fields(); | |
| 172 } | |
| 173 } | |
| 174 } | |
| 175 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
176 ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol()); |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
177 // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents |
| 0 | 178 ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL); |
| 179 init_ident_of(ciEnv::_unloaded_ciinstance_klass); | |
| 180 ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1); | |
| 181 init_ident_of(ciEnv::_unloaded_ciobjarrayklass); | |
| 182 assert(ciEnv::_unloaded_ciobjarrayklass->is_obj_array_klass(), "just checking"); | |
| 183 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
184 get_metadata(Universe::boolArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
185 get_metadata(Universe::charArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
186 get_metadata(Universe::singleArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
187 get_metadata(Universe::doubleArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
188 get_metadata(Universe::byteArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 get_metadata(Universe::shortArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
190 get_metadata(Universe::intArrayKlassObj()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
191 get_metadata(Universe::longArrayKlassObj()); |
| 0 | 192 |
| 193 | |
| 194 | |
| 195 assert(_non_perm_count == 0, "no shared non-perm objects"); | |
| 196 | |
| 197 // The shared_ident_limit is the first ident number that will | |
| 198 // be used for non-shared objects. That is, numbers less than | |
| 199 // this limit are permanently assigned to shared CI objects, | |
| 200 // while the higher numbers are recycled afresh by each new ciEnv. | |
| 201 | |
| 202 _shared_ident_limit = _next_ident; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
203 _shared_ci_metadata = _ci_metadata; |
| 0 | 204 } |
| 205 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
206 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
207 ciSymbol* ciObjectFactory::get_symbol(Symbol* key) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
208 vmSymbols::SID sid = vmSymbols::find_sid(key); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
209 if (sid != vmSymbols::NO_SID) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
210 // do not pollute the main cache with it |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
211 return vm_symbol_at(sid); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
212 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
213 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
214 assert(vmSymbols::find_sid(key) == vmSymbols::NO_SID, ""); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
215 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
|
216 _symbols->push(s); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
217 return s; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
218 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
220 // 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
|
221 void ciObjectFactory::remove_symbols() { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
222 for (int i = 0; i < _symbols->length(); i++) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
223 ciSymbol* s = _symbols->at(i); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
224 s->get_symbol()->decrement_refcount(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
225 } |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
226 // 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
|
227 // but it'll go away just the same. |
|
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 |
| 0 | 230 // ------------------------------------------------------------------ |
| 231 // ciObjectFactory::get | |
| 232 // | |
| 233 // Get the ciObject corresponding to some oop. If the ciObject has | |
| 234 // already been created, it is returned. Otherwise, a new ciObject | |
| 235 // is created. | |
| 236 ciObject* ciObjectFactory::get(oop key) { | |
| 237 ASSERT_IN_VM; | |
| 238 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
239 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
|
240 |
|
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
|
241 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
|
242 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
|
243 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
|
244 } |
| 0 | 245 |
|
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
|
246 // 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
|
247 // 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
|
248 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
|
249 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
|
250 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
|
251 init_ident_of(new_object); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
252 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
|
253 |
|
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
|
254 // 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
|
255 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
|
256 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
|
257 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
258 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
259 // ------------------------------------------------------------------ |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
260 // ciObjectFactory::get |
|
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 // 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
|
263 // 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
|
264 // is created. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
265 ciMetadata* ciObjectFactory::get_metadata(Metadata* key) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
266 ASSERT_IN_VM; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
267 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
268 assert(key == NULL || key->is_metadata(), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
269 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
270 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
271 if (CIObjectFactoryVerify) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
272 Metadata* last = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
273 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
|
274 Metadata* o = _ci_metadata->at(j)->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
275 assert(last < o, "out of order"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
276 last = o; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
277 } |
|
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 #endif // ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
280 int len = _ci_metadata->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
281 int index = find(key, _ci_metadata); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
282 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
283 if (CIObjectFactoryVerify) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
284 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
|
285 if (_ci_metadata->at(i)->constant_encoding() == key) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
286 assert(index == i, " bad lookup"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
287 } |
|
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 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
291 if (!is_found_at(index, key, _ci_metadata)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
292 // 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
|
293 // into the cache. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
294 ciMetadata* new_object = create_new_object(key); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
295 init_ident_of(new_object); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
296 assert(new_object->is_metadata(), "must be"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
297 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
298 if (len != _ci_metadata->length()) { |
| 0 | 299 // creating the new object has recursively entered new objects |
| 300 // 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
|
301 index = find(key, _ci_metadata); |
| 0 | 302 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
303 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
|
304 insert(index, new_object, _ci_metadata); |
| 0 | 305 return new_object; |
| 306 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
307 return _ci_metadata->at(index)->as_metadata(); |
| 0 | 308 } |
| 309 | |
| 310 // ------------------------------------------------------------------ | |
| 311 // ciObjectFactory::create_new_object | |
| 312 // | |
| 313 // Create a new ciObject from an oop. | |
| 314 // | |
| 315 // Implementation note: this functionality could be virtual behavior | |
| 316 // of the oop itself. For now, we explicitly marshal the object. | |
| 317 ciObject* ciObjectFactory::create_new_object(oop o) { | |
| 318 EXCEPTION_CONTEXT; | |
| 319 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
320 if (o->is_instance()) { |
| 0 | 321 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
|
322 if (java_lang_invoke_CallSite::is_instance(o)) |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
323 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
|
324 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
|
325 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
|
326 else if (java_lang_invoke_MethodHandle::is_instance(o)) |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
327 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
|
328 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
|
329 return new (arena()) ciMethodType(h_i); |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
330 else |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
331 return new (arena()) ciInstance(h_i); |
| 0 | 332 } else if (o->is_objArray()) { |
| 333 objArrayHandle h_oa(THREAD, (objArrayOop)o); | |
| 334 return new (arena()) ciObjArray(h_oa); | |
| 335 } else if (o->is_typeArray()) { | |
| 336 typeArrayHandle h_ta(THREAD, (typeArrayOop)o); | |
| 337 return new (arena()) ciTypeArray(h_ta); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
338 } |
|
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 // 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
|
341 ShouldNotReachHere(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
342 return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
343 } |
|
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 // ciObjectFactory::create_new_object |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
347 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
348 // Create a new ciObject from a Metadata*. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
349 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
350 // Implementation note: this functionality could be virtual behavior |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
351 // 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
|
352 ciMetadata* ciObjectFactory::create_new_object(Metadata* o) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
353 EXCEPTION_CONTEXT; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
354 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
355 if (o->is_klass()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
356 KlassHandle h_k(THREAD, (Klass*)o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
357 Klass* k = (Klass*)o; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
358 if (k->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
359 return new (arena()) ciInstanceKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
360 } else if (k->oop_is_objArray()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
361 return new (arena()) ciObjArrayKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
362 } else if (k->oop_is_typeArray()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
363 return new (arena()) ciTypeArrayKlass(h_k); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
364 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
365 } else if (o->is_method()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
366 methodHandle h_m(THREAD, (Method*)o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
367 return new (arena()) ciMethod(h_m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
368 } else if (o->is_methodData()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
369 // Hold methodHandle alive - might not be necessary ??? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
370 methodHandle h_m(THREAD, ((MethodData*)o)->method()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
371 return new (arena()) ciMethodData((MethodData*)o); |
| 0 | 372 } |
| 373 | |
| 374 // The oop is of some type not supported by the compiler interface. | |
| 375 ShouldNotReachHere(); | |
| 376 return NULL; | |
| 377 } | |
| 378 | |
| 379 //------------------------------------------------------------------ | |
| 380 // ciObjectFactory::get_unloaded_method | |
| 381 // | |
| 382 // Get the ciMethod representing an unloaded/unfound method. | |
| 383 // | |
| 384 // Implementation note: unloaded methods are currently stored in | |
| 385 // an unordered array, requiring a linear-time lookup for each | |
| 386 // unloaded method. This may need to change. | |
| 387 ciMethod* ciObjectFactory::get_unloaded_method(ciInstanceKlass* holder, | |
| 388 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
|
389 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
|
390 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
|
391 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
|
392 for (int i = 0; i < _unloaded_methods->length(); i++) { |
| 0 | 393 ciMethod* entry = _unloaded_methods->at(i); |
| 394 if (entry->holder()->equals(holder) && | |
| 395 entry->name()->equals(name) && | |
| 396 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
|
397 // 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
|
398 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
|
399 // 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
|
400 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
|
401 } 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
|
402 // 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
|
403 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
|
404 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
|
405 // 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
|
406 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
|
407 } |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
2376
diff
changeset
|
408 } |
| 0 | 409 } |
| 410 } | |
| 411 | |
| 412 // This is a new unloaded method. Create it and stick it in | |
| 413 // 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
|
414 ciMethod* new_method = new (arena()) ciMethod(holder, name, signature, accessor); |
| 0 | 415 |
| 416 init_ident_of(new_method); | |
| 417 _unloaded_methods->append(new_method); | |
| 418 | |
| 419 return new_method; | |
| 420 } | |
| 421 | |
| 422 //------------------------------------------------------------------ | |
| 423 // ciObjectFactory::get_unloaded_klass | |
| 424 // | |
| 425 // Get a ciKlass representing an unloaded klass. | |
| 426 // | |
| 427 // Implementation note: unloaded klasses are currently stored in | |
| 428 // an unordered array, requiring a linear-time lookup for each | |
| 429 // unloaded klass. This may need to change. | |
| 430 ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass, | |
| 431 ciSymbol* name, | |
| 432 bool create_if_not_found) { | |
| 433 EXCEPTION_CONTEXT; | |
| 434 oop loader = NULL; | |
| 435 oop domain = NULL; | |
| 436 if (accessing_klass != NULL) { | |
| 437 loader = accessing_klass->loader(); | |
| 438 domain = accessing_klass->protection_domain(); | |
| 439 } | |
| 440 for (int i=0; i<_unloaded_klasses->length(); i++) { | |
| 441 ciKlass* entry = _unloaded_klasses->at(i); | |
| 442 if (entry->name()->equals(name) && | |
| 443 entry->loader() == loader && | |
| 444 entry->protection_domain() == domain) { | |
| 445 // We've found a match. | |
| 446 return entry; | |
| 447 } | |
| 448 } | |
| 449 | |
| 450 if (!create_if_not_found) | |
| 451 return NULL; | |
| 452 | |
| 453 // This is a new unloaded klass. Create it and stick it in | |
| 454 // the cache. | |
| 455 ciKlass* new_klass = NULL; | |
| 456 | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
457 // 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
|
458 // unloaded InstanceKlass. Deal with both. |
| 0 | 459 if (name->byte_at(0) == '[') { |
| 460 // Decompose the name.' | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
461 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
462 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
|
463 fd, THREAD); |
| 0 | 464 if (HAS_PENDING_EXCEPTION) { |
| 465 CLEAR_PENDING_EXCEPTION; | |
| 466 CURRENT_THREAD_ENV->record_out_of_memory_failure(); | |
| 467 return ciEnv::_unloaded_ciobjarrayklass; | |
| 468 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
469 int dimension = fd.dimension(); |
| 0 | 470 assert(element_type != T_ARRAY, "unsuccessful decomposition"); |
| 471 ciKlass* element_klass = NULL; | |
| 472 if (element_type == T_OBJECT) { | |
| 473 ciEnv *env = CURRENT_THREAD_ENV; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
474 ciSymbol* ci_name = env->get_symbol(fd.object_key()); |
| 0 | 475 element_klass = |
| 476 env->get_klass_by_name(accessing_klass, ci_name, false)->as_instance_klass(); | |
| 477 } else { | |
| 478 assert(dimension > 1, "one dimensional type arrays are always loaded."); | |
| 479 | |
| 480 // The type array itself takes care of one of the dimensions. | |
| 481 dimension--; | |
| 482 | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
483 // The element klass is a TypeArrayKlass. |
| 0 | 484 element_klass = ciTypeArrayKlass::make(element_type); |
| 485 } | |
| 486 new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension); | |
| 487 } else { | |
| 488 jobject loader_handle = NULL; | |
| 489 jobject domain_handle = NULL; | |
| 490 if (accessing_klass != NULL) { | |
| 491 loader_handle = accessing_klass->loader_handle(); | |
| 492 domain_handle = accessing_klass->protection_domain_handle(); | |
| 493 } | |
| 494 new_klass = new (arena()) ciInstanceKlass(name, loader_handle, domain_handle); | |
| 495 } | |
| 496 init_ident_of(new_klass); | |
| 497 _unloaded_klasses->append(new_klass); | |
| 498 | |
| 499 return new_klass; | |
| 500 } | |
| 501 | |
| 1602 | 502 |
| 503 //------------------------------------------------------------------ | |
| 504 // ciObjectFactory::get_unloaded_instance | |
| 505 // | |
| 506 // Get a ciInstance representing an as-yet undetermined instance of a given class. | |
| 507 // | |
| 508 ciInstance* ciObjectFactory::get_unloaded_instance(ciInstanceKlass* instance_klass) { | |
| 509 for (int i=0; i<_unloaded_instances->length(); i++) { | |
| 510 ciInstance* entry = _unloaded_instances->at(i); | |
| 511 if (entry->klass()->equals(instance_klass)) { | |
| 512 // We've found a match. | |
| 513 return entry; | |
| 514 } | |
| 515 } | |
| 516 | |
| 517 // This is a new unloaded instance. Create it and stick it in | |
| 518 // the cache. | |
| 519 ciInstance* new_instance = new (arena()) ciInstance(instance_klass); | |
| 520 | |
| 521 init_ident_of(new_instance); | |
| 522 _unloaded_instances->append(new_instance); | |
| 523 | |
| 524 // make sure it looks the way we want: | |
| 525 assert(!new_instance->is_loaded(), ""); | |
| 526 assert(new_instance->klass() == instance_klass, ""); | |
| 527 | |
| 528 return new_instance; | |
| 529 } | |
| 530 | |
| 531 | |
| 532 //------------------------------------------------------------------ | |
| 533 // ciObjectFactory::get_unloaded_klass_mirror | |
| 534 // | |
| 535 // Get a ciInstance representing an unresolved klass mirror. | |
| 536 // | |
| 537 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 538 ciInstance* ciObjectFactory::get_unloaded_klass_mirror(ciKlass* type) { | |
| 539 assert(ciEnv::_Class_klass != NULL, ""); | |
| 540 return get_unloaded_instance(ciEnv::_Class_klass->as_instance_klass()); | |
| 541 } | |
| 542 | |
| 543 //------------------------------------------------------------------ | |
| 544 // ciObjectFactory::get_unloaded_method_handle_constant | |
| 545 // | |
| 546 // Get a ciInstance representing an unresolved method handle constant. | |
| 547 // | |
| 548 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 549 ciInstance* ciObjectFactory::get_unloaded_method_handle_constant(ciKlass* holder, | |
| 550 ciSymbol* name, | |
| 551 ciSymbol* signature, | |
| 552 int ref_kind) { | |
| 553 if (ciEnv::_MethodHandle_klass == NULL) return NULL; | |
| 554 return get_unloaded_instance(ciEnv::_MethodHandle_klass->as_instance_klass()); | |
| 555 } | |
| 556 | |
| 557 //------------------------------------------------------------------ | |
| 558 // ciObjectFactory::get_unloaded_method_type_constant | |
| 559 // | |
| 560 // Get a ciInstance representing an unresolved method type constant. | |
| 561 // | |
| 562 // Currently, this ignores the parameters and returns a unique unloaded instance. | |
| 563 ciInstance* ciObjectFactory::get_unloaded_method_type_constant(ciSymbol* signature) { | |
| 564 if (ciEnv::_MethodType_klass == NULL) return NULL; | |
| 565 return get_unloaded_instance(ciEnv::_MethodType_klass->as_instance_klass()); | |
| 566 } | |
| 567 | |
| 568 | |
| 569 | |
| 0 | 570 //------------------------------------------------------------------ |
| 571 // ciObjectFactory::get_empty_methodData | |
| 572 // | |
| 573 // Get the ciMethodData representing the methodData for a method with | |
| 574 // none. | |
| 575 ciMethodData* ciObjectFactory::get_empty_methodData() { | |
| 576 ciMethodData* new_methodData = new (arena()) ciMethodData(); | |
| 577 init_ident_of(new_methodData); | |
| 578 return new_methodData; | |
| 579 } | |
| 580 | |
| 581 //------------------------------------------------------------------ | |
| 582 // ciObjectFactory::get_return_address | |
| 583 // | |
| 584 // Get a ciReturnAddress for a specified bci. | |
| 585 ciReturnAddress* ciObjectFactory::get_return_address(int bci) { | |
| 586 for (int i=0; i<_return_addresses->length(); i++) { | |
| 587 ciReturnAddress* entry = _return_addresses->at(i); | |
| 588 if (entry->bci() == bci) { | |
| 589 // We've found a match. | |
| 590 return entry; | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 ciReturnAddress* new_ret_addr = new (arena()) ciReturnAddress(bci); | |
| 595 init_ident_of(new_ret_addr); | |
| 596 _return_addresses->append(new_ret_addr); | |
| 597 return new_ret_addr; | |
| 598 } | |
| 599 | |
| 600 // ------------------------------------------------------------------ | |
| 601 // ciObjectFactory::init_ident_of | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
602 void ciObjectFactory::init_ident_of(ciBaseObject* obj) { |
| 0 | 603 obj->set_ident(_next_ident++); |
| 604 } | |
| 605 | |
| 606 // ------------------------------------------------------------------ | |
| 607 // ciObjectFactory::find | |
| 608 // | |
| 609 // Use binary search to find the position of this oop in the cache. | |
| 610 // If there is no entry in the cache corresponding to this oop, return | |
| 611 // 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
|
612 int ciObjectFactory::find(Metadata* key, GrowableArray<ciMetadata*>* objects) { |
| 0 | 613 int min = 0; |
| 614 int max = objects->length()-1; | |
| 615 | |
| 616 // print_contents(); | |
| 617 | |
| 618 while (max >= min) { | |
| 619 int mid = (max + min) / 2; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
620 Metadata* value = objects->at(mid)->constant_encoding(); |
| 0 | 621 if (value < key) { |
| 622 min = mid + 1; | |
| 623 } else if (value > key) { | |
| 624 max = mid - 1; | |
| 625 } else { | |
| 626 return mid; | |
| 627 } | |
| 628 } | |
| 629 return min; | |
| 630 } | |
| 631 | |
| 632 // ------------------------------------------------------------------ | |
| 633 // ciObjectFactory::is_found_at | |
| 634 // | |
| 635 // 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
|
636 bool ciObjectFactory::is_found_at(int index, Metadata* key, GrowableArray<ciMetadata*>* objects) { |
| 0 | 637 return (index < objects->length() && |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
638 objects->at(index)->constant_encoding() == key); |
| 0 | 639 } |
| 640 | |
| 641 | |
| 642 // ------------------------------------------------------------------ | |
| 643 // ciObjectFactory::insert | |
| 644 // | |
| 645 // 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
|
646 void ciObjectFactory::insert(int index, ciMetadata* obj, GrowableArray<ciMetadata*>* objects) { |
| 0 | 647 int len = objects->length(); |
| 648 if (len == index) { | |
| 649 objects->append(obj); | |
| 650 } else { | |
| 651 objects->append(objects->at(len-1)); | |
| 652 int pos; | |
| 653 for (pos = len-2; pos >= index; pos--) { | |
| 654 objects->at_put(pos+1,objects->at(pos)); | |
| 655 } | |
| 656 objects->at_put(index, obj); | |
| 657 } | |
| 658 } | |
| 659 | |
| 660 static ciObjectFactory::NonPermObject* emptyBucket = NULL; | |
| 661 | |
| 662 // ------------------------------------------------------------------ | |
| 663 // ciObjectFactory::find_non_perm | |
| 664 // | |
| 665 // Use a small hash table, hashed on the klass of the key. | |
| 666 // If there is no entry in the cache corresponding to this oop, return | |
| 667 // the null tail of the bucket into which the oop should be inserted. | |
| 668 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
|
669 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
|
670 ciMetadata* klass = get_metadata(key->klass()); |
| 0 | 671 NonPermObject* *bp = &_non_perm_bucket[(unsigned) klass->hash() % NON_PERM_BUCKETS]; |
| 672 for (NonPermObject* p; (p = (*bp)) != NULL; bp = &p->next()) { | |
| 673 if (is_equal(p, key)) break; | |
| 674 } | |
| 675 return (*bp); | |
| 676 } | |
| 677 | |
| 678 | |
| 679 | |
| 680 // ------------------------------------------------------------------ | |
| 681 // Code for for NonPermObject | |
| 682 // | |
| 683 inline ciObjectFactory::NonPermObject::NonPermObject(ciObjectFactory::NonPermObject* &bucket, oop key, ciObject* object) { | |
| 684 assert(ciObjectFactory::is_initialized(), ""); | |
| 685 _object = object; | |
| 686 _next = bucket; | |
| 687 bucket = this; | |
| 688 } | |
| 689 | |
| 690 | |
| 691 | |
| 692 // ------------------------------------------------------------------ | |
| 693 // ciObjectFactory::insert_non_perm | |
| 694 // | |
| 695 // Insert a ciObject into the non-perm table. | |
| 696 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
|
697 assert(Universe::heap()->is_in_reserved_or_null(key), "must be"); |
| 0 | 698 assert(&where != &emptyBucket, "must not try to fill empty bucket"); |
| 699 NonPermObject* p = new (arena()) NonPermObject(where, key, obj); | |
| 700 assert(where == p && is_equal(p, key) && p->object() == obj, "entry must match"); | |
| 701 assert(find_non_perm(key) == p, "must find the same spot"); | |
| 702 ++_non_perm_count; | |
| 703 } | |
| 704 | |
| 705 // ------------------------------------------------------------------ | |
| 706 // ciObjectFactory::vm_symbol_at | |
| 707 // Get the ciSymbol corresponding to some index in vmSymbols. | |
| 708 ciSymbol* ciObjectFactory::vm_symbol_at(int index) { | |
| 709 assert(index >= vmSymbols::FIRST_SID && index < vmSymbols::SID_LIMIT, "oob"); | |
| 710 return _shared_ci_symbols[index]; | |
| 711 } | |
| 712 | |
| 713 // ------------------------------------------------------------------ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
714 // ciObjectFactory::metadata_do |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
715 void ciObjectFactory::metadata_do(void f(Metadata*)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
716 if (_ci_metadata == NULL) return; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
717 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
|
718 Metadata* o = _ci_metadata->at(j)->constant_encoding(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
719 f(o); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
720 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
721 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
722 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
723 // ------------------------------------------------------------------ |
| 0 | 724 // ciObjectFactory::print_contents_impl |
| 725 void ciObjectFactory::print_contents_impl() { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
726 int len = _ci_metadata->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
727 tty->print_cr("ciObjectFactory (%d) meta data contents:", len); |
| 0 | 728 for (int i=0; i<len; i++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
729 _ci_metadata->at(i)->print(); |
| 0 | 730 tty->cr(); |
| 731 } | |
| 732 } | |
| 733 | |
| 734 // ------------------------------------------------------------------ | |
| 735 // ciObjectFactory::print_contents | |
| 736 void ciObjectFactory::print_contents() { | |
| 737 print(); | |
| 738 tty->cr(); | |
| 739 GUARDED_VM_ENTRY(print_contents_impl();) | |
| 740 } | |
| 741 | |
| 742 // ------------------------------------------------------------------ | |
| 743 // ciObjectFactory::print | |
| 744 // | |
| 745 // Print debugging information about the object factory | |
| 746 void ciObjectFactory::print() { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
747 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
|
748 _non_perm_count, _ci_metadata->length(), _unloaded_methods->length(), |
| 1602 | 749 _unloaded_instances->length(), |
| 0 | 750 _unloaded_klasses->length()); |
| 751 } |