Mercurial > hg > graal-compiler
annotate src/share/vm/ci/ciEnv.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 | 18fb7da42534 |
| children | 80e866b1d053 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
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/ciConstant.hpp" | |
| 27 #include "ci/ciEnv.hpp" | |
| 28 #include "ci/ciField.hpp" | |
| 29 #include "ci/ciInstance.hpp" | |
| 30 #include "ci/ciInstanceKlass.hpp" | |
| 31 #include "ci/ciMethod.hpp" | |
| 32 #include "ci/ciNullObject.hpp" | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
33 #include "ci/ciReplay.hpp" |
| 1972 | 34 #include "ci/ciUtilities.hpp" |
| 35 #include "classfile/systemDictionary.hpp" | |
| 36 #include "classfile/vmSymbols.hpp" | |
| 37 #include "code/scopeDesc.hpp" | |
| 38 #include "compiler/compileBroker.hpp" | |
| 39 #include "compiler/compileLog.hpp" | |
| 40 #include "compiler/compilerOracle.hpp" | |
| 41 #include "gc_interface/collectedHeap.inline.hpp" | |
| 42 #include "interpreter/linkResolver.hpp" | |
| 43 #include "memory/allocation.inline.hpp" | |
| 44 #include "memory/oopFactory.hpp" | |
| 45 #include "memory/universe.inline.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
46 #include "oops/methodData.hpp" |
| 1972 | 47 #include "oops/objArrayKlass.hpp" |
| 48 #include "oops/oop.inline.hpp" | |
| 49 #include "oops/oop.inline2.hpp" | |
| 50 #include "prims/jvmtiExport.hpp" | |
| 51 #include "runtime/init.hpp" | |
| 52 #include "runtime/reflection.hpp" | |
| 53 #include "runtime/sharedRuntime.hpp" | |
| 54 #include "utilities/dtrace.hpp" | |
| 55 #ifdef COMPILER1 | |
| 56 #include "c1/c1_Runtime1.hpp" | |
| 57 #endif | |
| 58 #ifdef COMPILER2 | |
| 59 #include "opto/runtime.hpp" | |
| 60 #endif | |
| 0 | 61 |
| 62 // ciEnv | |
| 63 // | |
| 64 // This class is the top level broker for requests from the compiler | |
| 65 // to the VM. | |
| 66 | |
| 67 ciObject* ciEnv::_null_object_instance; | |
| 68 | |
| 1142 | 69 #define WK_KLASS_DEFN(name, ignore_s, ignore_o) ciInstanceKlass* ciEnv::_##name = NULL; |
| 70 WK_KLASSES_DO(WK_KLASS_DEFN) | |
| 71 #undef WK_KLASS_DEFN | |
| 0 | 72 |
| 73 ciSymbol* ciEnv::_unloaded_cisymbol = NULL; | |
| 74 ciInstanceKlass* ciEnv::_unloaded_ciinstance_klass = NULL; | |
| 75 ciObjArrayKlass* ciEnv::_unloaded_ciobjarrayklass = NULL; | |
| 76 | |
| 77 jobject ciEnv::_ArrayIndexOutOfBoundsException_handle = NULL; | |
| 78 jobject ciEnv::_ArrayStoreException_handle = NULL; | |
| 79 jobject ciEnv::_ClassCastException_handle = NULL; | |
| 80 | |
| 81 #ifndef PRODUCT | |
| 82 static bool firstEnv = true; | |
| 83 #endif /* PRODUCT */ | |
| 84 | |
| 85 // ------------------------------------------------------------------ | |
| 86 // ciEnv::ciEnv | |
| 87 ciEnv::ciEnv(CompileTask* task, int system_dictionary_modification_counter) { | |
| 88 VM_ENTRY_MARK; | |
| 89 | |
| 90 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc. | |
| 91 thread->set_env(this); | |
| 92 assert(ciEnv::current() == this, "sanity"); | |
| 93 | |
| 94 _oop_recorder = NULL; | |
| 95 _debug_info = NULL; | |
| 96 _dependencies = NULL; | |
| 97 _failure_reason = NULL; | |
| 98 _compilable = MethodCompilable; | |
| 99 _break_at_compile = false; | |
| 100 _compiler_data = NULL; | |
| 101 #ifndef PRODUCT | |
| 102 assert(!firstEnv, "not initialized properly"); | |
| 103 #endif /* !PRODUCT */ | |
| 104 | |
| 105 _system_dictionary_modification_counter = system_dictionary_modification_counter; | |
| 106 _num_inlined_bytecodes = 0; | |
| 107 assert(task == NULL || thread->task() == task, "sanity"); | |
| 108 _task = task; | |
| 109 _log = NULL; | |
| 110 | |
| 111 // Temporary buffer for creating symbols and such. | |
| 112 _name_buffer = NULL; | |
| 113 _name_buffer_len = 0; | |
| 114 | |
| 115 _arena = &_ciEnv_arena; | |
| 116 _factory = new (_arena) ciObjectFactory(_arena, 128); | |
| 117 | |
| 118 // Preload commonly referenced system ciObjects. | |
| 119 | |
| 120 // During VM initialization, these instances have not yet been created. | |
| 121 // Assertions ensure that these instances are not accessed before | |
| 122 // their initialization. | |
| 123 | |
| 124 assert(Universe::is_fully_initialized(), "should be complete"); | |
| 125 | |
| 126 oop o = Universe::null_ptr_exception_instance(); | |
| 127 assert(o != NULL, "should have been initialized"); | |
| 128 _NullPointerException_instance = get_object(o)->as_instance(); | |
| 129 o = Universe::arithmetic_exception_instance(); | |
| 130 assert(o != NULL, "should have been initialized"); | |
| 131 _ArithmeticException_instance = get_object(o)->as_instance(); | |
| 132 | |
| 133 _ArrayIndexOutOfBoundsException_instance = NULL; | |
| 134 _ArrayStoreException_instance = NULL; | |
| 135 _ClassCastException_instance = NULL; | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
136 _the_null_string = NULL; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
137 _the_min_jint_string = NULL; |
| 0 | 138 } |
| 139 | |
| 140 ciEnv::ciEnv(Arena* arena) { | |
| 141 ASSERT_IN_VM; | |
| 142 | |
| 143 // Set up ciEnv::current immediately, for the sake of ciObjectFactory, etc. | |
| 144 CompilerThread* current_thread = CompilerThread::current(); | |
| 145 assert(current_thread->env() == NULL, "must be"); | |
| 146 current_thread->set_env(this); | |
| 147 assert(ciEnv::current() == this, "sanity"); | |
| 148 | |
| 149 _oop_recorder = NULL; | |
| 150 _debug_info = NULL; | |
| 151 _dependencies = NULL; | |
| 152 _failure_reason = NULL; | |
| 153 _compilable = MethodCompilable_never; | |
| 154 _break_at_compile = false; | |
| 155 _compiler_data = NULL; | |
| 156 #ifndef PRODUCT | |
| 157 assert(firstEnv, "must be first"); | |
| 158 firstEnv = false; | |
| 159 #endif /* !PRODUCT */ | |
| 160 | |
| 161 _system_dictionary_modification_counter = 0; | |
| 162 _num_inlined_bytecodes = 0; | |
| 163 _task = NULL; | |
| 164 _log = NULL; | |
| 165 | |
| 166 // Temporary buffer for creating symbols and such. | |
| 167 _name_buffer = NULL; | |
| 168 _name_buffer_len = 0; | |
| 169 | |
| 170 _arena = arena; | |
| 171 _factory = new (_arena) ciObjectFactory(_arena, 128); | |
| 172 | |
| 173 // Preload commonly referenced system ciObjects. | |
| 174 | |
| 175 // During VM initialization, these instances have not yet been created. | |
| 176 // Assertions ensure that these instances are not accessed before | |
| 177 // their initialization. | |
| 178 | |
| 179 assert(Universe::is_fully_initialized(), "must be"); | |
| 180 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
181 _NullPointerException_instance = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
182 _ArithmeticException_instance = NULL; |
| 0 | 183 _ArrayIndexOutOfBoundsException_instance = NULL; |
| 184 _ArrayStoreException_instance = NULL; | |
| 185 _ClassCastException_instance = NULL; | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
186 _the_null_string = NULL; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
187 _the_min_jint_string = NULL; |
| 0 | 188 } |
| 189 | |
| 190 ciEnv::~ciEnv() { | |
| 191 CompilerThread* current_thread = CompilerThread::current(); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
192 _factory->remove_symbols(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
193 // Need safepoint to clear the env on the thread. RedefineClasses might |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
194 // be reading it. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
195 GUARDED_VM_ENTRY(current_thread->set_env(NULL);) |
| 0 | 196 } |
| 197 | |
| 198 // ------------------------------------------------------------------ | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
199 // Cache Jvmti state |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
200 void ciEnv::cache_jvmti_state() { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
201 VM_ENTRY_MARK; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
202 // Get Jvmti capabilities under lock to get consistant values. |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
203 MutexLocker mu(JvmtiThreadState_lock); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
204 _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint(); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
205 _jvmti_can_access_local_variables = JvmtiExport::can_access_local_variables(); |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1142
diff
changeset
|
206 _jvmti_can_post_on_exceptions = JvmtiExport::can_post_on_exceptions(); |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
207 } |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
208 |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
209 // ------------------------------------------------------------------ |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
210 // Cache DTrace flags |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
211 void ciEnv::cache_dtrace_flags() { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
212 // Need lock? |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
213 _dtrace_extended_probes = ExtendedDTraceProbes; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
214 if (_dtrace_extended_probes) { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
215 _dtrace_monitor_probes = true; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
216 _dtrace_method_probes = true; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
217 _dtrace_alloc_probes = true; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
218 } else { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
219 _dtrace_monitor_probes = DTraceMonitorProbes; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
220 _dtrace_method_probes = DTraceMethodProbes; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
221 _dtrace_alloc_probes = DTraceAllocProbes; |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
222 } |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
223 } |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
224 |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
225 // ------------------------------------------------------------------ |
| 0 | 226 // helper for lazy exception creation |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
227 ciInstance* ciEnv::get_or_create_exception(jobject& handle, Symbol* name) { |
| 0 | 228 VM_ENTRY_MARK; |
| 229 if (handle == NULL) { | |
| 230 // Cf. universe.cpp, creation of Universe::_null_ptr_exception_instance. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
231 Klass* k = SystemDictionary::find(name, Handle(), Handle(), THREAD); |
| 0 | 232 jobject objh = NULL; |
| 233 if (!HAS_PENDING_EXCEPTION && k != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
234 oop obj = InstanceKlass::cast(k)->allocate_instance(THREAD); |
| 0 | 235 if (!HAS_PENDING_EXCEPTION) |
| 236 objh = JNIHandles::make_global(obj); | |
| 237 } | |
| 238 if (HAS_PENDING_EXCEPTION) { | |
| 239 CLEAR_PENDING_EXCEPTION; | |
| 240 } else { | |
| 241 handle = objh; | |
| 242 } | |
| 243 } | |
| 244 oop obj = JNIHandles::resolve(handle); | |
| 245 return obj == NULL? NULL: get_object(obj)->as_instance(); | |
| 246 } | |
| 247 | |
| 248 ciInstance* ciEnv::ArrayIndexOutOfBoundsException_instance() { | |
| 249 if (_ArrayIndexOutOfBoundsException_instance == NULL) { | |
| 250 _ArrayIndexOutOfBoundsException_instance | |
| 251 = get_or_create_exception(_ArrayIndexOutOfBoundsException_handle, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
252 vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); |
| 0 | 253 } |
| 254 return _ArrayIndexOutOfBoundsException_instance; | |
| 255 } | |
| 256 ciInstance* ciEnv::ArrayStoreException_instance() { | |
| 257 if (_ArrayStoreException_instance == NULL) { | |
| 258 _ArrayStoreException_instance | |
| 259 = get_or_create_exception(_ArrayStoreException_handle, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
260 vmSymbols::java_lang_ArrayStoreException()); |
| 0 | 261 } |
| 262 return _ArrayStoreException_instance; | |
| 263 } | |
| 264 ciInstance* ciEnv::ClassCastException_instance() { | |
| 265 if (_ClassCastException_instance == NULL) { | |
| 266 _ClassCastException_instance | |
| 267 = get_or_create_exception(_ClassCastException_handle, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
268 vmSymbols::java_lang_ClassCastException()); |
| 0 | 269 } |
| 270 return _ClassCastException_instance; | |
| 271 } | |
| 272 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
273 ciInstance* ciEnv::the_null_string() { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
274 if (_the_null_string == NULL) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
275 VM_ENTRY_MARK; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
276 _the_null_string = get_object(Universe::the_null_string())->as_instance(); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
277 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
278 return _the_null_string; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
279 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
280 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
281 ciInstance* ciEnv::the_min_jint_string() { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
282 if (_the_min_jint_string == NULL) { |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
283 VM_ENTRY_MARK; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
284 _the_min_jint_string = get_object(Universe::the_min_jint_string())->as_instance(); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
285 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
286 return _the_min_jint_string; |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
287 } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
288 |
| 0 | 289 // ------------------------------------------------------------------ |
| 290 // ciEnv::get_method_from_handle | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
291 ciMethod* ciEnv::get_method_from_handle(Method* method) { |
| 0 | 292 VM_ENTRY_MARK; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
293 return get_metadata(method)->as_method(); |
| 0 | 294 } |
| 295 | |
| 296 // ------------------------------------------------------------------ | |
| 297 // ciEnv::array_element_offset_in_bytes | |
| 298 int ciEnv::array_element_offset_in_bytes(ciArray* a_h, ciObject* o_h) { | |
| 299 VM_ENTRY_MARK; | |
| 300 objArrayOop a = (objArrayOop)a_h->get_oop(); | |
| 301 assert(a->is_objArray(), ""); | |
| 302 int length = a->length(); | |
| 303 oop o = o_h->get_oop(); | |
| 304 for (int i = 0; i < length; i++) { | |
| 305 if (a->obj_at(i) == o) return i; | |
| 306 } | |
| 307 return -1; | |
| 308 } | |
| 309 | |
| 310 | |
| 311 // ------------------------------------------------------------------ | |
| 312 // ciEnv::check_klass_accessiblity | |
| 313 // | |
| 314 // Note: the logic of this method should mirror the logic of | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
315 // ConstantPool::verify_constant_pool_resolve. |
| 0 | 316 bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
317 Klass* resolved_klass) { |
| 0 | 318 if (accessing_klass == NULL || !accessing_klass->is_loaded()) { |
| 319 return true; | |
| 320 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
321 if (accessing_klass->is_obj_array_klass()) { |
| 0 | 322 accessing_klass = accessing_klass->as_obj_array_klass()->base_element_klass(); |
| 323 } | |
| 324 if (!accessing_klass->is_instance_klass()) { | |
| 325 return true; | |
| 326 } | |
| 327 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
328 if (resolved_klass->oop_is_objArray()) { |
| 0 | 329 // Find the element klass, if this is an array. |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6792
diff
changeset
|
330 resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass(); |
| 0 | 331 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
332 if (resolved_klass->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
333 return Reflection::verify_class_access(accessing_klass->get_Klass(), |
| 0 | 334 resolved_klass, |
| 335 true); | |
| 336 } | |
| 337 return true; | |
| 338 } | |
| 339 | |
| 340 // ------------------------------------------------------------------ | |
| 341 // ciEnv::get_klass_by_name_impl | |
| 342 ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass, | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
343 constantPoolHandle cpool, |
| 0 | 344 ciSymbol* name, |
| 345 bool require_local) { | |
| 346 ASSERT_IN_VM; | |
| 347 EXCEPTION_CONTEXT; | |
| 348 | |
| 349 // Now we need to check the SystemDictionary | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
350 Symbol* sym = name->get_symbol(); |
| 0 | 351 if (sym->byte_at(0) == 'L' && |
| 352 sym->byte_at(sym->utf8_length()-1) == ';') { | |
| 353 // This is a name from a signature. Strip off the trimmings. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
354 // Call recursive to keep scope of strippedsym. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
355 TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
356 sym->utf8_length()-2, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
357 KILL_COMPILE_ON_FATAL_(_unloaded_ciinstance_klass)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
358 ciSymbol* strippedname = get_symbol(strippedsym); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
359 return get_klass_by_name_impl(accessing_klass, cpool, strippedname, require_local); |
| 0 | 360 } |
| 361 | |
| 362 // Check for prior unloaded klass. The SystemDictionary's answers | |
| 363 // can vary over time but the compiler needs consistency. | |
| 364 ciKlass* unloaded_klass = check_get_unloaded_klass(accessing_klass, name); | |
| 365 if (unloaded_klass != NULL) { | |
| 366 if (require_local) return NULL; | |
| 367 return unloaded_klass; | |
| 368 } | |
| 369 | |
| 370 Handle loader(THREAD, (oop)NULL); | |
| 371 Handle domain(THREAD, (oop)NULL); | |
| 372 if (accessing_klass != NULL) { | |
| 373 loader = Handle(THREAD, accessing_klass->loader()); | |
| 374 domain = Handle(THREAD, accessing_klass->protection_domain()); | |
| 375 } | |
| 376 | |
| 377 // setup up the proper type to return on OOM | |
| 378 ciKlass* fail_type; | |
| 379 if (sym->byte_at(0) == '[') { | |
| 380 fail_type = _unloaded_ciobjarrayklass; | |
| 381 } else { | |
| 382 fail_type = _unloaded_ciinstance_klass; | |
| 383 } | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
384 KlassHandle found_klass; |
|
2244
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
385 { |
|
2263
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2244
diff
changeset
|
386 ttyUnlocker ttyul; // release tty lock to avoid ordering problems |
|
2244
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
387 MutexLocker ml(Compile_lock); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
388 Klass* kls; |
|
2244
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
389 if (!require_local) { |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
390 kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader, |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
391 KILL_COMPILE_ON_FATAL_(fail_type)); |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
392 } else { |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
393 kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain, |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
394 KILL_COMPILE_ON_FATAL_(fail_type)); |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
395 } |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
396 found_klass = KlassHandle(THREAD, kls); |
| 0 | 397 } |
| 398 | |
| 399 // If we fail to find an array klass, look again for its element type. | |
| 400 // The element type may be available either locally or via constraints. | |
| 401 // In either case, if we can find the element type in the system dictionary, | |
| 402 // we must build an array type around it. The CI requires array klasses | |
| 403 // to be loaded if their element klasses are loaded, except when memory | |
| 404 // is exhausted. | |
| 405 if (sym->byte_at(0) == '[' && | |
| 406 (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) { | |
| 407 // We have an unloaded array. | |
| 408 // Build it on the fly if the element class exists. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
409 TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
410 sym->utf8_length()-1, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
411 KILL_COMPILE_ON_FATAL_(fail_type)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
412 |
| 0 | 413 // Get element ciKlass recursively. |
| 414 ciKlass* elem_klass = | |
| 415 get_klass_by_name_impl(accessing_klass, | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
416 cpool, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
417 get_symbol(elem_sym), |
| 0 | 418 require_local); |
| 419 if (elem_klass != NULL && elem_klass->is_loaded()) { | |
| 420 // Now make an array for it | |
| 421 return ciObjArrayKlass::make_impl(elem_klass); | |
| 422 } | |
| 423 } | |
| 424 | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
425 if (found_klass() == NULL && !cpool.is_null() && cpool->has_preresolution()) { |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
426 // Look inside the constant pool for pre-resolved class entries. |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
427 for (int i = cpool->length() - 1; i >= 1; i--) { |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
428 if (cpool->tag_at(i).is_klass()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
429 Klass* kls = cpool->resolved_klass_at(i); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
430 if (Klass::cast(kls)->name() == sym) { |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
431 found_klass = KlassHandle(THREAD, kls); |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
432 break; |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
433 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
434 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
435 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
436 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
437 |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
1972
diff
changeset
|
438 if (found_klass() != NULL) { |
| 0 | 439 // Found it. Build a CI handle. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
440 return get_klass(found_klass()); |
| 0 | 441 } |
| 442 | |
| 443 if (require_local) return NULL; | |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3959
diff
changeset
|
444 |
| 0 | 445 // Not yet loaded into the VM, or not governed by loader constraints. |
| 446 // Make a CI representative for it. | |
| 447 return get_unloaded_klass(accessing_klass, name); | |
| 448 } | |
| 449 | |
| 450 // ------------------------------------------------------------------ | |
| 451 // ciEnv::get_klass_by_name | |
| 452 ciKlass* ciEnv::get_klass_by_name(ciKlass* accessing_klass, | |
| 453 ciSymbol* klass_name, | |
| 454 bool require_local) { | |
| 455 GUARDED_VM_ENTRY(return get_klass_by_name_impl(accessing_klass, | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
456 constantPoolHandle(), |
| 0 | 457 klass_name, |
| 458 require_local);) | |
| 459 } | |
| 460 | |
| 461 // ------------------------------------------------------------------ | |
| 462 // ciEnv::get_klass_by_index_impl | |
| 463 // | |
| 464 // Implementation of get_klass_by_index. | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
465 ciKlass* ciEnv::get_klass_by_index_impl(constantPoolHandle cpool, |
| 0 | 466 int index, |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
467 bool& is_accessible, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
468 ciInstanceKlass* accessor) { |
| 0 | 469 EXCEPTION_CONTEXT; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
470 KlassHandle klass; // = NULL; |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
471 Symbol* klass_name = NULL; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
472 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
473 if (cpool->tag_at(index).is_symbol()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
474 klass_name = cpool->symbol_at(index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
475 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
476 // Check if it's resolved if it's not a symbol constant pool entry. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
477 klass = KlassHandle(THREAD, ConstantPool::klass_at_if_loaded(cpool, index)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
478 |
| 0 | 479 if (klass.is_null()) { |
| 480 // The klass has not been inserted into the constant pool. | |
| 481 // Try to look it up by name. | |
| 482 { | |
| 483 // We have to lock the cpool to keep the oop from being resolved | |
| 484 // while we are accessing it. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
485 MonitorLockerEx ml(cpool->lock()); |
| 0 | 486 constantTag tag = cpool->tag_at(index); |
| 487 if (tag.is_klass()) { | |
| 488 // The klass has been inserted into the constant pool | |
| 489 // very recently. | |
| 490 klass = KlassHandle(THREAD, cpool->resolved_klass_at(index)); | |
| 491 } else { | |
| 492 assert(cpool->tag_at(index).is_unresolved_klass(), "wrong tag"); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
493 klass_name = cpool->unresolved_klass_at(index); |
| 0 | 494 } |
| 495 } | |
| 496 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
497 } |
| 0 | 498 |
| 499 if (klass.is_null()) { | |
| 500 // Not found in constant pool. Use the name to do the lookup. | |
| 501 ciKlass* k = get_klass_by_name_impl(accessor, | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
502 cpool, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
503 get_symbol(klass_name), |
| 0 | 504 false); |
| 505 // Calculate accessibility the hard way. | |
| 506 if (!k->is_loaded()) { | |
| 507 is_accessible = false; | |
| 508 } else if (k->loader() != accessor->loader() && | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
509 get_klass_by_name_impl(accessor, cpool, k->name(), true) == NULL) { |
| 0 | 510 // Loaded only remotely. Not linked yet. |
| 511 is_accessible = false; | |
| 512 } else { | |
| 513 // Linked locally, and we must also check public/private, etc. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
514 is_accessible = check_klass_accessibility(accessor, k->get_Klass()); |
| 0 | 515 } |
| 516 return k; | |
| 517 } | |
| 518 | |
| 519 // Check for prior unloaded klass. The SystemDictionary's answers | |
| 520 // can vary over time but the compiler needs consistency. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
521 ciSymbol* name = get_symbol(klass()->name()); |
| 0 | 522 ciKlass* unloaded_klass = check_get_unloaded_klass(accessor, name); |
| 523 if (unloaded_klass != NULL) { | |
| 524 is_accessible = false; | |
| 525 return unloaded_klass; | |
| 526 } | |
| 527 | |
| 528 // It is known to be accessible, since it was found in the constant pool. | |
| 529 is_accessible = true; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
530 return get_klass(klass()); |
| 0 | 531 } |
| 532 | |
| 533 // ------------------------------------------------------------------ | |
| 534 // ciEnv::get_klass_by_index | |
| 535 // | |
| 536 // Get a klass from the constant pool. | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
537 ciKlass* ciEnv::get_klass_by_index(constantPoolHandle cpool, |
| 0 | 538 int index, |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
539 bool& is_accessible, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
540 ciInstanceKlass* accessor) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
541 GUARDED_VM_ENTRY(return get_klass_by_index_impl(cpool, index, is_accessible, accessor);) |
| 0 | 542 } |
| 543 | |
| 544 // ------------------------------------------------------------------ | |
| 545 // ciEnv::get_constant_by_index_impl | |
| 546 // | |
| 547 // Implementation of get_constant_by_index(). | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
548 ciConstant ciEnv::get_constant_by_index_impl(constantPoolHandle cpool, |
| 1602 | 549 int pool_index, int cache_index, |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
550 ciInstanceKlass* accessor) { |
| 1602 | 551 bool ignore_will_link; |
| 0 | 552 EXCEPTION_CONTEXT; |
| 1602 | 553 int index = pool_index; |
| 554 if (cache_index >= 0) { | |
| 555 assert(index < 0, "only one kind of index at a time"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
556 oop obj = cpool->resolved_references()->obj_at(cache_index); |
| 1602 | 557 if (obj != NULL) { |
| 558 ciObject* ciobj = get_object(obj); | |
| 559 return ciConstant(T_OBJECT, ciobj); | |
| 560 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
561 index = cpool->object_to_cp_index(cache_index); |
| 1602 | 562 } |
| 0 | 563 constantTag tag = cpool->tag_at(index); |
| 564 if (tag.is_int()) { | |
| 565 return ciConstant(T_INT, (jint)cpool->int_at(index)); | |
| 566 } else if (tag.is_long()) { | |
| 567 return ciConstant((jlong)cpool->long_at(index)); | |
| 568 } else if (tag.is_float()) { | |
| 569 return ciConstant((jfloat)cpool->float_at(index)); | |
| 570 } else if (tag.is_double()) { | |
| 571 return ciConstant((jdouble)cpool->double_at(index)); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
572 } else if (tag.is_string()) { |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
573 oop string = NULL; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
574 assert(cache_index >= 0, "should have a cache index"); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
575 if (cpool->is_pseudo_string_at(index)) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
576 string = cpool->pseudo_string_at(index, cache_index); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
577 } else { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
578 string = cpool->string_at(index, cache_index, THREAD); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
579 if (HAS_PENDING_EXCEPTION) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
580 CLEAR_PENDING_EXCEPTION; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
581 record_out_of_memory_failure(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
582 return ciConstant(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
0
diff
changeset
|
583 } |
| 0 | 584 } |
| 585 ciObject* constant = get_object(string); | |
| 586 assert (constant->is_instance(), "must be an instance, or not? "); | |
| 587 return ciConstant(T_OBJECT, constant); | |
| 588 } else if (tag.is_klass() || tag.is_unresolved_klass()) { | |
| 589 // 4881222: allow ldc to take a class type | |
| 1602 | 590 ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor); |
| 0 | 591 if (HAS_PENDING_EXCEPTION) { |
| 592 CLEAR_PENDING_EXCEPTION; | |
| 593 record_out_of_memory_failure(); | |
| 594 return ciConstant(); | |
| 595 } | |
| 596 assert (klass->is_instance_klass() || klass->is_array_klass(), | |
| 597 "must be an instance or array klass "); | |
| 1602 | 598 return ciConstant(T_OBJECT, klass->java_mirror()); |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
599 } else if (tag.is_object()) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
600 oop obj = cpool->object_at(index); |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
601 ciObject* ciobj = get_object(obj); |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
602 return ciConstant(T_OBJECT, ciobj); |
| 1602 | 603 } else if (tag.is_method_type()) { |
| 604 // must execute Java code to link this CP entry into cache[i].f1 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
605 ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index)); |
| 1602 | 606 ciObject* ciobj = get_unloaded_method_type_constant(signature); |
| 607 return ciConstant(T_OBJECT, ciobj); | |
| 608 } else if (tag.is_method_handle()) { | |
| 609 // must execute Java code to link this CP entry into cache[i].f1 | |
| 610 int ref_kind = cpool->method_handle_ref_kind_at(index); | |
| 611 int callee_index = cpool->method_handle_klass_index_at(index); | |
| 612 ciKlass* callee = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
613 ciSymbol* name = get_symbol(cpool->method_handle_name_ref_at(index)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
614 ciSymbol* signature = get_symbol(cpool->method_handle_signature_ref_at(index)); |
| 1602 | 615 ciObject* ciobj = get_unloaded_method_handle_constant(callee, name, signature, ref_kind); |
| 616 return ciConstant(T_OBJECT, ciobj); | |
| 0 | 617 } else { |
| 618 ShouldNotReachHere(); | |
| 619 return ciConstant(); | |
| 620 } | |
| 621 } | |
| 622 | |
| 623 // ------------------------------------------------------------------ | |
| 624 // ciEnv::get_constant_by_index | |
| 625 // | |
| 626 // Pull a constant out of the constant pool. How appropriate. | |
| 627 // | |
| 628 // Implementation note: this query is currently in no way cached. | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
629 ciConstant ciEnv::get_constant_by_index(constantPoolHandle cpool, |
| 1602 | 630 int pool_index, int cache_index, |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
631 ciInstanceKlass* accessor) { |
| 1602 | 632 GUARDED_VM_ENTRY(return get_constant_by_index_impl(cpool, pool_index, cache_index, accessor);) |
| 0 | 633 } |
| 634 | |
| 635 // ------------------------------------------------------------------ | |
| 636 // ciEnv::get_field_by_index_impl | |
| 637 // | |
| 638 // Implementation of get_field_by_index. | |
| 639 // | |
| 640 // Implementation note: the results of field lookups are cached | |
| 641 // in the accessor klass. | |
| 642 ciField* ciEnv::get_field_by_index_impl(ciInstanceKlass* accessor, | |
| 643 int index) { | |
| 644 ciConstantPoolCache* cache = accessor->field_cache(); | |
| 645 if (cache == NULL) { | |
| 646 ciField* field = new (arena()) ciField(accessor, index); | |
| 647 return field; | |
| 648 } else { | |
| 649 ciField* field = (ciField*)cache->get(index); | |
| 650 if (field == NULL) { | |
| 651 field = new (arena()) ciField(accessor, index); | |
| 652 cache->insert(index, field); | |
| 653 } | |
| 654 return field; | |
| 655 } | |
| 656 } | |
| 657 | |
| 658 // ------------------------------------------------------------------ | |
| 659 // ciEnv::get_field_by_index | |
| 660 // | |
| 661 // Get a field by index from a klass's constant pool. | |
| 662 ciField* ciEnv::get_field_by_index(ciInstanceKlass* accessor, | |
| 663 int index) { | |
| 664 GUARDED_VM_ENTRY(return get_field_by_index_impl(accessor, index);) | |
| 665 } | |
| 666 | |
| 667 // ------------------------------------------------------------------ | |
| 668 // ciEnv::lookup_method | |
| 669 // | |
| 670 // Perform an appropriate method lookup based on accessor, holder, | |
| 671 // name, signature, and bytecode. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
672 Method* ciEnv::lookup_method(InstanceKlass* accessor, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
673 InstanceKlass* holder, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
674 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
675 Symbol* sig, |
| 0 | 676 Bytecodes::Code bc) { |
| 677 EXCEPTION_CONTEXT; | |
| 678 KlassHandle h_accessor(THREAD, accessor); | |
| 679 KlassHandle h_holder(THREAD, holder); | |
| 680 LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL)); | |
| 681 methodHandle dest_method; | |
| 682 switch (bc) { | |
| 683 case Bytecodes::_invokestatic: | |
| 684 dest_method = | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
685 LinkResolver::resolve_static_call_or_null(h_holder, name, sig, h_accessor); |
| 0 | 686 break; |
| 687 case Bytecodes::_invokespecial: | |
| 688 dest_method = | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
689 LinkResolver::resolve_special_call_or_null(h_holder, name, sig, h_accessor); |
| 0 | 690 break; |
| 691 case Bytecodes::_invokeinterface: | |
| 692 dest_method = | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
693 LinkResolver::linktime_resolve_interface_method_or_null(h_holder, name, sig, |
| 0 | 694 h_accessor, true); |
| 695 break; | |
| 696 case Bytecodes::_invokevirtual: | |
| 697 dest_method = | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
698 LinkResolver::linktime_resolve_virtual_method_or_null(h_holder, name, sig, |
| 0 | 699 h_accessor, true); |
| 700 break; | |
| 701 default: ShouldNotReachHere(); | |
| 702 } | |
| 703 | |
| 704 return dest_method(); | |
| 705 } | |
| 706 | |
| 707 | |
| 708 // ------------------------------------------------------------------ | |
| 709 // ciEnv::get_method_by_index_impl | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
710 ciMethod* ciEnv::get_method_by_index_impl(constantPoolHandle cpool, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
711 int index, Bytecodes::Code bc, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
712 ciInstanceKlass* accessor) { |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
713 if (bc == Bytecodes::_invokedynamic) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
714 ConstantPoolCacheEntry* cpce = cpool->invokedynamic_cp_cache_entry_at(index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
715 bool is_resolved = !cpce->is_f1_null(); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
716 // FIXME: code generation could allow for null (unlinked) call site |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
717 // The call site could be made patchable as follows: |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
718 // Load the appendix argument from the constant pool. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
719 // Test the appendix argument and jump to a known deopt routine if it is null. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
720 // Jump through a patchable call site, which is initially a deopt routine. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
721 // Patch the call site to the nmethod entry point of the static compiled lambda form. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
722 // As with other two-component call sites, both values must be independently verified. |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
723 |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
724 if (is_resolved) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
725 // Get the invoker Method* from the constant pool. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
726 // (The appendix argument, if any, will be noted in the method's signature.) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
727 Method* adapter = cpce->f1_as_method(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
728 return get_method(adapter); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
729 } |
| 0 | 730 |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
731 // Fake a method that is equivalent to a declared method. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
732 ciInstanceKlass* holder = get_instance_klass(SystemDictionary::MethodHandle_klass()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
4001
diff
changeset
|
733 ciSymbol* name = ciSymbol::invokeBasic_name(); |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3959
diff
changeset
|
734 ciSymbol* signature = get_symbol(cpool->signature_ref_at(index)); |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3959
diff
changeset
|
735 return get_unloaded_method(holder, name, signature, accessor); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
736 } else { |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
737 const int holder_index = cpool->klass_ref_index_at(index); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
738 bool holder_is_accessible; |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
739 ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
740 ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
741 |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
742 // Get the method's name and signature. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
743 Symbol* name_sym = cpool->name_ref_at(index); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
744 Symbol* sig_sym = cpool->signature_ref_at(index); |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
745 |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
746 if (cpool->has_preresolution() |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
747 || (holder == ciEnv::MethodHandle_klass() && |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
748 MethodHandles::is_signature_polymorphic_name(holder->get_Klass(), name_sym))) { |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
749 // Short-circuit lookups for JSR 292-related call sites. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
750 // That is, do not rely only on name-based lookups, because they may fail |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
751 // if the names are not resolvable in the boot class loader (7056328). |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
752 switch (bc) { |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
753 case Bytecodes::_invokevirtual: |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
754 case Bytecodes::_invokeinterface: |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
755 case Bytecodes::_invokespecial: |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
756 case Bytecodes::_invokestatic: |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
757 { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
758 Method* m = ConstantPool::method_at_if_loaded(cpool, index); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
759 if (m != NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
760 return get_method(m); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
761 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
762 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
763 break; |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
764 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
765 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
766 |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
767 if (holder_is_accessible) { // Our declared holder is loaded. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
768 InstanceKlass* lookup = declared_holder->get_instanceKlass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
769 Method* m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
770 if (m != NULL && |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
771 (bc == Bytecodes::_invokestatic |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6853
diff
changeset
|
772 ? m->method_holder()->is_not_initialized() |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6853
diff
changeset
|
773 : !m->method_holder()->is_loaded())) { |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
774 m = NULL; |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
775 } |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
776 #ifdef ASSERT |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
777 if (m != NULL && ReplayCompiles && !ciReplay::is_loaded(m)) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
778 m = NULL; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
779 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
780 #endif |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
781 if (m != NULL) { |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
782 // We found the method. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
783 return get_method(m); |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
784 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
785 } |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
786 |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
787 // Either the declared holder was not loaded, or the method could |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
788 // not be found. Create a dummy ciMethod to represent the failed |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
789 // lookup. |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
790 ciSymbol* name = get_symbol(name_sym); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
791 ciSymbol* signature = get_symbol(sig_sym); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
792 return get_unloaded_method(declared_holder, name, signature, accessor); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
793 } |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
794 } |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
795 |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
796 |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
797 // ------------------------------------------------------------------ |
| 0 | 798 // ciEnv::get_instance_klass_for_declared_method_holder |
| 799 ciInstanceKlass* ciEnv::get_instance_klass_for_declared_method_holder(ciKlass* method_holder) { | |
| 800 // For the case of <array>.clone(), the method holder can be a ciArrayKlass | |
| 801 // instead of a ciInstanceKlass. For that case simply pretend that the | |
| 802 // declared holder is Object.clone since that's where the call will bottom out. | |
| 803 // A more correct fix would trickle out through many interfaces in CI, | |
| 804 // requiring ciInstanceKlass* to become ciKlass* and many more places would | |
| 805 // require checks to make sure the expected type was found. Given that this | |
| 806 // only occurs for clone() the more extensive fix seems like overkill so | |
| 807 // instead we simply smear the array type into Object. | |
| 808 if (method_holder->is_instance_klass()) { | |
| 809 return method_holder->as_instance_klass(); | |
| 810 } else if (method_holder->is_array_klass()) { | |
| 811 return current()->Object_klass(); | |
| 812 } else { | |
| 813 ShouldNotReachHere(); | |
| 814 } | |
| 815 return NULL; | |
| 816 } | |
| 817 | |
| 818 | |
| 819 // ------------------------------------------------------------------ | |
| 820 // ciEnv::get_method_by_index | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
821 ciMethod* ciEnv::get_method_by_index(constantPoolHandle cpool, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
822 int index, Bytecodes::Code bc, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
823 ciInstanceKlass* accessor) { |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
824 GUARDED_VM_ENTRY(return get_method_by_index_impl(cpool, index, bc, accessor);) |
| 0 | 825 } |
| 826 | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
1080
diff
changeset
|
827 |
| 0 | 828 // ------------------------------------------------------------------ |
| 829 // ciEnv::name_buffer | |
| 830 char *ciEnv::name_buffer(int req_len) { | |
| 831 if (_name_buffer_len < req_len) { | |
| 832 if (_name_buffer == NULL) { | |
| 833 _name_buffer = (char*)arena()->Amalloc(sizeof(char)*req_len); | |
| 834 _name_buffer_len = req_len; | |
| 835 } else { | |
| 836 _name_buffer = | |
| 837 (char*)arena()->Arealloc(_name_buffer, _name_buffer_len, req_len); | |
| 838 _name_buffer_len = req_len; | |
| 839 } | |
| 840 } | |
| 841 return _name_buffer; | |
| 842 } | |
| 843 | |
| 844 // ------------------------------------------------------------------ | |
| 845 // ciEnv::is_in_vm | |
| 846 bool ciEnv::is_in_vm() { | |
| 847 return JavaThread::current()->thread_state() == _thread_in_vm; | |
| 848 } | |
| 849 | |
| 850 bool ciEnv::system_dictionary_modification_counter_changed() { | |
| 851 return _system_dictionary_modification_counter != SystemDictionary::number_of_modifications(); | |
| 852 } | |
| 853 | |
| 854 // ------------------------------------------------------------------ | |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
855 // ciEnv::validate_compile_task_dependencies |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
856 // |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
857 // Check for changes during compilation (e.g. class loads, evolution, |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
858 // breakpoints, call site invalidation). |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
859 void ciEnv::validate_compile_task_dependencies(ciMethod* target) { |
| 0 | 860 if (failing()) return; // no need for further checks |
| 861 | |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
862 // First, check non-klass dependencies as we might return early and |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
863 // not check klass dependencies if the system dictionary |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
864 // modification counter hasn't changed (see below). |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
865 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) { |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
866 if (deps.is_klass_type()) continue; // skip klass dependencies |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
867 Klass* witness = deps.check_dependency(); |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
868 if (witness != NULL) { |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
869 record_failure("invalid non-klass dependency"); |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
870 return; |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
871 } |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
872 } |
| 0 | 873 |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
874 // Klass dependencies must be checked when the system dictionary |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
875 // changes. If logging is enabled all violated dependences will be |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
876 // recorded in the log. In debug mode check dependencies even if |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
877 // the system dictionary hasn't changed to verify that no invalid |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
878 // dependencies were inserted. Any violated dependences in this |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
879 // case are dumped to the tty. |
| 0 | 880 bool counter_changed = system_dictionary_modification_counter_changed(); |
| 881 | |
| 3959 | 882 bool verify_deps = trueInDebug; |
| 883 if (!counter_changed && !verify_deps) return; | |
| 884 | |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
885 int klass_violations = 0; |
| 0 | 886 for (Dependencies::DepStream deps(dependencies()); deps.next(); ) { |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
887 if (!deps.is_klass_type()) continue; // skip non-klass dependencies |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
888 Klass* witness = deps.check_dependency(); |
| 0 | 889 if (witness != NULL) { |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
890 klass_violations++; |
| 3959 | 891 if (!counter_changed) { |
| 892 // Dependence failed but counter didn't change. Log a message | |
| 893 // describing what failed and allow the assert at the end to | |
| 894 // trigger. | |
| 895 deps.print_dependency(witness); | |
| 896 } else if (xtty == NULL) { | |
| 897 // If we're not logging then a single violation is sufficient, | |
| 898 // otherwise we want to log all the dependences which were | |
| 899 // violated. | |
| 900 break; | |
| 901 } | |
| 0 | 902 } |
| 903 } | |
| 904 | |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
905 if (klass_violations != 0) { |
| 3959 | 906 #ifdef ASSERT |
| 907 if (!counter_changed && !PrintCompilation) { | |
| 908 // Print out the compile task that failed | |
| 909 _task->print_line(); | |
| 910 } | |
| 911 #endif | |
| 0 | 912 assert(counter_changed, "failed dependencies, but counter didn't change"); |
| 913 record_failure("concurrent class loading"); | |
| 914 } | |
| 915 } | |
| 916 | |
| 917 // ------------------------------------------------------------------ | |
| 918 // ciEnv::register_method | |
| 919 void ciEnv::register_method(ciMethod* target, | |
| 920 int entry_bci, | |
| 921 CodeOffsets* offsets, | |
| 922 int orig_pc_offset, | |
| 923 CodeBuffer* code_buffer, | |
| 924 int frame_words, | |
| 925 OopMapSet* oop_map_set, | |
| 926 ExceptionHandlerTable* handler_table, | |
| 927 ImplicitExceptionTable* inc_table, | |
| 928 AbstractCompiler* compiler, | |
| 929 int comp_level, | |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
930 bool has_unsafe_access, |
|
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
931 bool has_wide_vectors) { |
| 0 | 932 VM_ENTRY_MARK; |
| 933 nmethod* nm = NULL; | |
| 934 { | |
| 935 // To prevent compile queue updates. | |
| 936 MutexLocker locker(MethodCompileQueue_lock, THREAD); | |
| 937 | |
| 938 // Prevent SystemDictionary::add_to_hierarchy from running | |
| 939 // and invalidating our dependencies until we install this method. | |
| 940 MutexLocker ml(Compile_lock); | |
| 941 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
942 // Change in Jvmti state may invalidate compilation. |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
943 if (!failing() && |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
944 ( (!jvmti_can_hotswap_or_post_breakpoint() && |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
945 JvmtiExport::can_hotswap_or_post_breakpoint()) || |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
946 (!jvmti_can_access_local_variables() && |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
947 JvmtiExport::can_access_local_variables()) || |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1142
diff
changeset
|
948 (!jvmti_can_post_on_exceptions() && |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1142
diff
changeset
|
949 JvmtiExport::can_post_on_exceptions()) )) { |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
950 record_failure("Jvmti state change invalidated dependencies"); |
| 0 | 951 } |
| 952 | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
953 // Change in DTrace flags may invalidate compilation. |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
954 if (!failing() && |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
955 ( (!dtrace_extended_probes() && ExtendedDTraceProbes) || |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
956 (!dtrace_method_probes() && DTraceMethodProbes) || |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
957 (!dtrace_alloc_probes() && DTraceAllocProbes) )) { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
958 record_failure("DTrace flags change invalidated dependencies"); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
959 } |
| 0 | 960 |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
961 if (!failing()) { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
962 if (log() != NULL) { |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
963 // Log the dependencies which this compilation declares. |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
964 dependencies()->log_all_dependencies(); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
965 } |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
966 |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
967 // Encode the dependencies now, so we can check them right away. |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
968 dependencies()->encode_content_bytes(); |
|
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
969 |
|
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
970 // Check for {class loads, evolution, breakpoints, ...} during compilation |
|
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3785
diff
changeset
|
971 validate_compile_task_dependencies(target); |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
470
diff
changeset
|
972 } |
| 0 | 973 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
974 methodHandle method(THREAD, target->get_Method()); |
| 0 | 975 |
| 976 if (failing()) { | |
| 977 // While not a true deoptimization, it is a preemptive decompile. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
978 MethodData* mdo = method()->method_data(); |
| 0 | 979 if (mdo != NULL) { |
| 980 mdo->inc_decompile_count(); | |
| 981 } | |
| 982 | |
| 983 // All buffers in the CodeBuffer are allocated in the CodeCache. | |
| 984 // If the code buffer is created on each compile attempt | |
| 985 // as in C2, then it must be freed. | |
| 986 code_buffer->free_blob(); | |
| 987 return; | |
| 988 } | |
| 989 | |
| 990 assert(offsets->value(CodeOffsets::Deopt) != -1, "must have deopt entry"); | |
| 991 assert(offsets->value(CodeOffsets::Exceptions) != -1, "must have exception entry"); | |
| 992 | |
| 993 nm = nmethod::new_nmethod(method, | |
| 994 compile_id(), | |
| 995 entry_bci, | |
| 996 offsets, | |
| 997 orig_pc_offset, | |
| 998 debug_info(), dependencies(), code_buffer, | |
| 999 frame_words, oop_map_set, | |
| 1000 handler_table, inc_table, | |
| 1001 compiler, comp_level); | |
| 1002 | |
| 1003 // Free codeBlobs | |
| 1004 code_buffer->free_blob(); | |
| 1005 | |
| 1006 // stress test 6243940 by immediately making the method | |
| 1007 // non-entrant behind the system's back. This has serious | |
| 1008 // side effects on the code cache and is not meant for | |
| 1009 // general stress testing | |
| 1010 if (nm != NULL && StressNonEntrant) { | |
| 1011 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag); | |
| 1012 NativeJump::patch_verified_entry(nm->entry_point(), nm->verified_entry_point(), | |
| 1013 SharedRuntime::get_handle_wrong_method_stub()); | |
| 1014 } | |
| 1015 | |
| 1016 if (nm == NULL) { | |
| 1017 // The CodeCache is full. Print out warning and disable compilation. | |
| 1018 record_failure("code cache is full"); | |
| 1202 | 1019 { |
| 1020 MutexUnlocker ml(Compile_lock); | |
| 1021 MutexUnlocker locker(MethodCompileQueue_lock); | |
| 1022 CompileBroker::handle_full_code_cache(); | |
| 0 | 1023 } |
| 1024 } else { | |
| 1025 nm->set_has_unsafe_access(has_unsafe_access); | |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
1026 nm->set_has_wide_vectors(has_wide_vectors); |
| 0 | 1027 |
| 1028 // Record successful registration. | |
| 1029 // (Put nm into the task handle *before* publishing to the Java heap.) | |
| 1030 if (task() != NULL) task()->set_code(nm); | |
| 1031 | |
| 1032 if (entry_bci == InvocationEntryBci) { | |
| 1783 | 1033 if (TieredCompilation) { |
| 1034 // If there is an old version we're done with it | |
| 1035 nmethod* old = method->code(); | |
| 1036 if (TraceMethodReplacement && old != NULL) { | |
| 1037 ResourceMark rm; | |
| 1038 char *method_name = method->name_and_sig_as_C_string(); | |
| 1039 tty->print_cr("Replacing method %s", method_name); | |
| 1040 } | |
| 1041 if (old != NULL ) { | |
| 1042 old->make_not_entrant(); | |
| 1043 } | |
| 0 | 1044 } |
| 1045 if (TraceNMethodInstalls ) { | |
| 1046 ResourceMark rm; | |
| 1047 char *method_name = method->name_and_sig_as_C_string(); | |
| 1048 ttyLocker ttyl; | |
| 1049 tty->print_cr("Installing method (%d) %s ", | |
| 1050 comp_level, | |
| 1051 method_name); | |
| 1052 } | |
| 1053 // Allow the code to be executed | |
| 1054 method->set_code(method, nm); | |
| 1055 } else { | |
| 1056 if (TraceNMethodInstalls ) { | |
| 1057 ResourceMark rm; | |
| 1058 char *method_name = method->name_and_sig_as_C_string(); | |
| 1059 ttyLocker ttyl; | |
| 1060 tty->print_cr("Installing osr method (%d) %s @ %d", | |
| 1061 comp_level, | |
| 1062 method_name, | |
| 1063 entry_bci); | |
| 1064 } | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6853
diff
changeset
|
1065 method->method_holder()->add_osr_nmethod(nm); |
| 0 | 1066 |
| 1067 } | |
| 1068 } | |
| 1069 } | |
| 1070 // JVMTI -- compiled method notification (must be done outside lock) | |
| 1071 if (nm != NULL) { | |
| 1072 nm->post_compiled_method_load_event(); | |
| 1073 } | |
| 1074 | |
| 1075 } | |
| 1076 | |
| 1077 | |
| 1078 // ------------------------------------------------------------------ | |
| 1079 // ciEnv::find_system_klass | |
| 1080 ciKlass* ciEnv::find_system_klass(ciSymbol* klass_name) { | |
| 1081 VM_ENTRY_MARK; | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3279
diff
changeset
|
1082 return get_klass_by_name_impl(NULL, constantPoolHandle(), klass_name, false); |
| 0 | 1083 } |
| 1084 | |
| 1085 // ------------------------------------------------------------------ | |
| 1086 // ciEnv::comp_level | |
| 1087 int ciEnv::comp_level() { | |
| 1783 | 1088 if (task() == NULL) return CompLevel_highest_tier; |
| 0 | 1089 return task()->comp_level(); |
| 1090 } | |
| 1091 | |
| 1092 // ------------------------------------------------------------------ | |
| 1093 // ciEnv::compile_id | |
| 1094 uint ciEnv::compile_id() { | |
| 1095 if (task() == NULL) return 0; | |
| 1096 return task()->compile_id(); | |
| 1097 } | |
| 1098 | |
| 1099 // ------------------------------------------------------------------ | |
| 1100 // ciEnv::notice_inlined_method() | |
| 1101 void ciEnv::notice_inlined_method(ciMethod* method) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
4001
diff
changeset
|
1102 _num_inlined_bytecodes += method->code_size_for_inlining(); |
| 0 | 1103 } |
| 1104 | |
| 1105 // ------------------------------------------------------------------ | |
| 1106 // ciEnv::num_inlined_bytecodes() | |
| 1107 int ciEnv::num_inlined_bytecodes() const { | |
| 1108 return _num_inlined_bytecodes; | |
| 1109 } | |
| 1110 | |
| 1111 // ------------------------------------------------------------------ | |
| 1112 // ciEnv::record_failure() | |
| 1113 void ciEnv::record_failure(const char* reason) { | |
| 1114 if (log() != NULL) { | |
| 1115 log()->elem("failure reason='%s'", reason); | |
| 1116 } | |
| 1117 if (_failure_reason == NULL) { | |
| 1118 // Record the first failure reason. | |
| 1119 _failure_reason = reason; | |
| 1120 } | |
| 1121 } | |
| 1122 | |
| 1123 // ------------------------------------------------------------------ | |
| 1124 // ciEnv::record_method_not_compilable() | |
| 1125 void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) { | |
| 1126 int new_compilable = | |
| 1127 all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ; | |
| 1128 | |
| 1129 // Only note transitions to a worse state | |
| 1130 if (new_compilable > _compilable) { | |
| 1131 if (log() != NULL) { | |
| 1132 if (all_tiers) { | |
| 1133 log()->elem("method_not_compilable"); | |
| 1134 } else { | |
| 6843 | 1135 log()->elem("method_not_compilable_at_tier level='%d'", |
| 1136 current()->task()->comp_level()); | |
| 0 | 1137 } |
| 1138 } | |
| 1139 _compilable = new_compilable; | |
| 1140 | |
| 1141 // Reset failure reason; this one is more important. | |
| 1142 _failure_reason = NULL; | |
| 1143 record_failure(reason); | |
| 1144 } | |
| 1145 } | |
| 1146 | |
| 1147 // ------------------------------------------------------------------ | |
| 1148 // ciEnv::record_out_of_memory_failure() | |
| 1149 void ciEnv::record_out_of_memory_failure() { | |
| 1150 // If memory is low, we stop compiling methods. | |
| 1151 record_method_not_compilable("out of memory"); | |
| 1152 } | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1153 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1154 fileStream* ciEnv::_replay_data_stream = NULL; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1155 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1156 void ciEnv::dump_replay_data() { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1157 VM_ENTRY_MARK; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1158 MutexLocker ml(Compile_lock); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1159 if (_replay_data_stream == NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1160 _replay_data_stream = new (ResourceObj::C_HEAP, mtCompiler) fileStream(ReplayDataFile); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1161 if (_replay_data_stream == NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1162 fatal(err_msg("Can't open %s for replay data", ReplayDataFile)); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1163 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1164 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1165 dump_replay_data(_replay_data_stream); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1166 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1167 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1168 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1169 void ciEnv::dump_replay_data(outputStream* out) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1170 ASSERT_IN_VM; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1171 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1172 #if INCLUDE_JVMTI |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1173 out->print_cr("JvmtiExport can_access_local_variables %d", _jvmti_can_access_local_variables); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1174 out->print_cr("JvmtiExport can_hotswap_or_post_breakpoint %d", _jvmti_can_hotswap_or_post_breakpoint); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1175 out->print_cr("JvmtiExport can_post_on_exceptions %d", _jvmti_can_post_on_exceptions); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1176 #endif // INCLUDE_JVMTI |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1177 |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1178 GrowableArray<ciMetadata*>* objects = _factory->get_ci_metadata(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1179 out->print_cr("# %d ciObject found", objects->length()); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1180 for (int i = 0; i < objects->length(); i++) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1181 objects->at(i)->dump_replay_data(out); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1182 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1183 Method* method = task()->method(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1184 int entry_bci = task()->osr_bci(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1185 // Klass holder = method->method_holder(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1186 out->print_cr("compile %s %s %s %d", |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1187 method->klass_name()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1188 method->name()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1189 method->signature()->as_quoted_ascii(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1190 entry_bci); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1191 out->flush(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1192 } |