Mercurial > hg > truffle
annotate src/share/vm/interpreter/interpreterRuntime.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 134f18d0174b |
| children | d3f3f7677537 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14422
diff
changeset
|
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "compiler/compileBroker.hpp" | |
|
7199
cd3d6a6b95d9
8003240: x86: move MacroAssembler into separate file
twisti
parents:
6985
diff
changeset
|
29 #include "compiler/disassembler.hpp" |
| 1972 | 30 #include "gc_interface/collectedHeap.hpp" |
| 31 #include "interpreter/interpreter.hpp" | |
| 32 #include "interpreter/interpreterRuntime.hpp" | |
| 33 #include "interpreter/linkResolver.hpp" | |
| 34 #include "interpreter/templateTable.hpp" | |
| 35 #include "memory/oopFactory.hpp" | |
| 36 #include "memory/universe.inline.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
37 #include "oops/constantPool.hpp" |
| 1972 | 38 #include "oops/instanceKlass.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
39 #include "oops/methodData.hpp" |
| 1972 | 40 #include "oops/objArrayKlass.hpp" |
| 41 #include "oops/oop.inline.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
42 #include "oops/symbol.hpp" |
| 1972 | 43 #include "prims/jvmtiExport.hpp" |
| 44 #include "prims/nativeLookup.hpp" | |
| 45 #include "runtime/biasedLocking.hpp" | |
| 46 #include "runtime/compilationPolicy.hpp" | |
| 47 #include "runtime/deoptimization.hpp" | |
| 48 #include "runtime/fieldDescriptor.hpp" | |
| 49 #include "runtime/handles.inline.hpp" | |
| 50 #include "runtime/interfaceSupport.hpp" | |
| 51 #include "runtime/java.hpp" | |
| 52 #include "runtime/jfieldIDWorkaround.hpp" | |
| 53 #include "runtime/osThread.hpp" | |
| 54 #include "runtime/sharedRuntime.hpp" | |
| 55 #include "runtime/stubRoutines.hpp" | |
| 56 #include "runtime/synchronizer.hpp" | |
| 57 #include "runtime/threadCritical.hpp" | |
| 58 #include "utilities/events.hpp" | |
| 59 #ifdef TARGET_ARCH_x86 | |
| 60 # include "vm_version_x86.hpp" | |
| 61 #endif | |
| 62 #ifdef TARGET_ARCH_sparc | |
| 63 # include "vm_version_sparc.hpp" | |
| 64 #endif | |
| 65 #ifdef TARGET_ARCH_zero | |
| 66 # include "vm_version_zero.hpp" | |
| 67 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
68 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
69 # include "vm_version_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
70 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
71 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
72 # include "vm_version_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
73 #endif |
| 1972 | 74 #ifdef COMPILER2 |
| 75 #include "opto/runtime.hpp" | |
| 76 #endif | |
| 0 | 77 |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14422
diff
changeset
|
78 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
14422
diff
changeset
|
79 |
| 0 | 80 class UnlockFlagSaver { |
| 81 private: | |
| 82 JavaThread* _thread; | |
| 83 bool _do_not_unlock; | |
| 84 public: | |
| 85 UnlockFlagSaver(JavaThread* t) { | |
| 86 _thread = t; | |
| 87 _do_not_unlock = t->do_not_unlock_if_synchronized(); | |
| 88 t->set_do_not_unlock_if_synchronized(false); | |
| 89 } | |
| 90 ~UnlockFlagSaver() { | |
| 91 _thread->set_do_not_unlock_if_synchronized(_do_not_unlock); | |
| 92 } | |
| 93 }; | |
| 94 | |
| 95 //------------------------------------------------------------------------------------------------------------------------ | |
| 96 // State accessors | |
| 97 | |
| 98 void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread *thread) { | |
| 99 last_frame(thread).interpreter_frame_set_bcp(bcp); | |
| 100 if (ProfileInterpreter) { | |
| 101 // ProfileTraps uses MDOs independently of ProfileInterpreter. | |
| 102 // That is why we must check both ProfileInterpreter and mdo != NULL. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
103 MethodData* mdo = last_frame(thread).interpreter_frame_method()->method_data(); |
| 0 | 104 if (mdo != NULL) { |
| 105 NEEDS_CLEANUP; | |
| 106 last_frame(thread).interpreter_frame_set_mdp(mdo->bci_to_dp(last_frame(thread).interpreter_frame_bci())); | |
| 107 } | |
| 108 } | |
| 109 } | |
| 110 | |
| 111 //------------------------------------------------------------------------------------------------------------------------ | |
| 112 // Constants | |
| 113 | |
| 114 | |
| 115 IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide)) | |
| 116 // access constant pool | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
117 ConstantPool* pool = method(thread)->constants(); |
| 1565 | 118 int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc); |
| 0 | 119 constantTag tag = pool->tag_at(index); |
| 120 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
121 assert (tag.is_unresolved_klass() || tag.is_klass(), "wrong ldc call"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
122 Klass* klass = pool->klass_at(index, CHECK); |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
123 oop java_class = klass->java_mirror(); |
| 0 | 124 thread->set_vm_result(java_class); |
| 125 IRT_END | |
| 126 | |
| 1602 | 127 IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) { |
| 128 assert(bytecode == Bytecodes::_fast_aldc || | |
| 129 bytecode == Bytecodes::_fast_aldc_w, "wrong bc"); | |
| 130 ResourceMark rm(thread); | |
| 131 methodHandle m (thread, method(thread)); | |
| 2142 | 132 Bytecode_loadconstant ldc(m, bci(thread)); |
|
3403
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
133 oop result = ldc.resolve_constant(CHECK); |
|
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
134 #ifdef ASSERT |
|
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
135 { |
|
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
136 // The bytecode wrappers aren't GC-safe so construct a new one |
|
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
137 Bytecode_loadconstant ldc2(m, bci(thread)); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
138 oop coop = m->constants()->resolved_references()->obj_at(ldc2.cache_index()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
139 assert(result == coop, "expected result for assembly code"); |
|
3403
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
140 } |
|
7db2b9499c36
7046732: JSR 292 assert(result == cpce->f1()) failed: expected result for assembly code
never
parents:
2460
diff
changeset
|
141 #endif |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
142 thread->set_vm_result(result); |
| 1602 | 143 } |
| 144 IRT_END | |
| 145 | |
| 0 | 146 |
| 147 //------------------------------------------------------------------------------------------------------------------------ | |
| 148 // Allocation | |
| 149 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
150 IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, ConstantPool* pool, int index)) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
151 Klass* k_oop = pool->klass_at(index, CHECK); |
| 0 | 152 instanceKlassHandle klass (THREAD, k_oop); |
| 153 | |
| 154 // Make sure we are not instantiating an abstract klass | |
| 155 klass->check_valid_for_instantiation(true, CHECK); | |
| 156 | |
| 157 // Make sure klass is initialized | |
| 158 klass->initialize(CHECK); | |
| 159 | |
| 160 // At this point the class may not be fully initialized | |
| 161 // because of recursive initialization. If it is fully | |
| 162 // initialized & has_finalized is not set, we rewrite | |
| 163 // it into its fast version (Note: no locking is needed | |
| 164 // here since this is an atomic byte write and can be | |
| 165 // done more than once). | |
| 166 // | |
| 167 // Note: In case of classes with has_finalized we don't | |
| 168 // rewrite since that saves us an extra check in | |
| 169 // the fast version which then would call the | |
| 170 // slow version anyway (and do a call back into | |
| 171 // Java). | |
| 172 // If we have a breakpoint, then we don't rewrite | |
| 173 // because the _breakpoint bytecode would be lost. | |
| 174 oop obj = klass->allocate_instance(CHECK); | |
| 175 thread->set_vm_result(obj); | |
| 176 IRT_END | |
| 177 | |
| 178 | |
| 179 IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size)) | |
| 180 oop obj = oopFactory::new_typeArray(type, size, CHECK); | |
| 181 thread->set_vm_result(obj); | |
| 182 IRT_END | |
| 183 | |
| 184 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
185 IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size)) |
| 0 | 186 // Note: no oopHandle for pool & klass needed since they are not used |
| 187 // anymore after new_objArray() and no GC can happen before. | |
| 188 // (This may have to change if this code changes!) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 Klass* klass = pool->klass_at(index, CHECK); |
| 0 | 190 objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK); |
| 191 thread->set_vm_result(obj); | |
| 192 IRT_END | |
| 193 | |
| 194 | |
| 195 IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address)) | |
| 196 // We may want to pass in more arguments - could make this slightly faster | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
197 ConstantPool* constants = method(thread)->constants(); |
| 1565 | 198 int i = get_index_u2(thread, Bytecodes::_multianewarray); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
199 Klass* klass = constants->klass_at(i, CHECK); |
| 0 | 200 int nof_dims = number_of_dimensions(thread); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
201 assert(klass->is_klass(), "not a class"); |
| 0 | 202 assert(nof_dims >= 1, "multianewarray rank must be nonzero"); |
| 203 | |
| 204 // We must create an array of jints to pass to multi_allocate. | |
| 205 ResourceMark rm(thread); | |
| 206 const int small_dims = 10; | |
| 207 jint dim_array[small_dims]; | |
| 208 jint *dims = &dim_array[0]; | |
| 209 if (nof_dims > small_dims) { | |
| 210 dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims); | |
| 211 } | |
| 212 for (int index = 0; index < nof_dims; index++) { | |
| 213 // offset from first_size_address is addressed as local[index] | |
| 214 int n = Interpreter::local_offset_in_bytes(index)/jintSize; | |
| 215 dims[index] = first_size_address[n]; | |
| 216 } | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6737
diff
changeset
|
217 oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK); |
| 0 | 218 thread->set_vm_result(obj); |
| 219 IRT_END | |
| 220 | |
| 221 | |
| 222 IRT_ENTRY(void, InterpreterRuntime::register_finalizer(JavaThread* thread, oopDesc* obj)) | |
| 223 assert(obj->is_oop(), "must be a valid oop"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
224 assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
225 InstanceKlass::register_finalizer(instanceOop(obj), CHECK); |
| 0 | 226 IRT_END |
| 227 | |
| 228 | |
| 229 // Quicken instance-of and check-cast bytecodes | |
| 230 IRT_ENTRY(void, InterpreterRuntime::quicken_io_cc(JavaThread* thread)) | |
| 231 // Force resolving; quicken the bytecode | |
| 1565 | 232 int which = get_index_u2(thread, Bytecodes::_checkcast); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
233 ConstantPool* cpool = method(thread)->constants(); |
| 0 | 234 // We'd expect to assert that we're only here to quicken bytecodes, but in a multithreaded |
| 235 // program we might have seen an unquick'd bytecode in the interpreter but have another | |
| 236 // thread quicken the bytecode before we get here. | |
| 237 // assert( cpool->tag_at(which).is_unresolved_klass(), "should only come here to quicken bytecodes" ); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
238 Klass* klass = cpool->klass_at(which, CHECK); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
239 thread->set_vm_result_2(klass); |
| 0 | 240 IRT_END |
| 241 | |
| 242 | |
| 243 //------------------------------------------------------------------------------------------------------------------------ | |
| 244 // Exceptions | |
| 245 | |
|
14420
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
246 void InterpreterRuntime::note_trap_inner(JavaThread* thread, int reason, |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
247 methodHandle trap_method, int trap_bci, TRAPS) { |
| 0 | 248 if (trap_method.not_null()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
249 MethodData* trap_mdo = trap_method->method_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
250 if (trap_mdo == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
251 Method::build_interpreter_method_data(trap_method, THREAD); |
| 0 | 252 if (HAS_PENDING_EXCEPTION) { |
|
14420
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
253 assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
254 "we expect only an OOM error here"); |
| 0 | 255 CLEAR_PENDING_EXCEPTION; |
| 256 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
257 trap_mdo = trap_method->method_data(); |
| 0 | 258 // and fall through... |
| 259 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
260 if (trap_mdo != NULL) { |
| 0 | 261 // Update per-method count of trap events. The interpreter |
| 262 // is updating the MDO to simulate the effect of compiler traps. | |
| 263 Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason); | |
| 264 } | |
| 265 } | |
| 266 } | |
| 267 | |
|
14420
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
268 // Assume the compiler is (or will be) interested in this event. |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
269 // If necessary, create an MDO to hold the information, and record it. |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
270 void InterpreterRuntime::note_trap(JavaThread* thread, int reason, TRAPS) { |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
271 assert(ProfileTraps, "call me only if profiling"); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
272 methodHandle trap_method(thread, method(thread)); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
273 int trap_bci = trap_method->bci_from(bcp(thread)); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
274 note_trap_inner(thread, reason, trap_method, trap_bci, THREAD); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
275 } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
276 |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
277 #ifdef CC_INTERP |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
278 // As legacy note_trap, but we have more arguments. |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
279 IRT_ENTRY(void, InterpreterRuntime::note_trap(JavaThread* thread, int reason, Method *method, int trap_bci)) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
280 methodHandle trap_method(method); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
281 note_trap_inner(thread, reason, trap_method, trap_bci, THREAD); |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
282 IRT_END |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
283 |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
284 // Class Deoptimization is not visible in BytecodeInterpreter, so we need a wrapper |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
285 // for each exception. |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
286 void InterpreterRuntime::note_nullCheck_trap(JavaThread* thread, Method *method, int trap_bci) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
287 { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_null_check, method, trap_bci); } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
288 void InterpreterRuntime::note_div0Check_trap(JavaThread* thread, Method *method, int trap_bci) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
289 { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_div0_check, method, trap_bci); } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
290 void InterpreterRuntime::note_rangeCheck_trap(JavaThread* thread, Method *method, int trap_bci) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
291 { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_range_check, method, trap_bci); } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
292 void InterpreterRuntime::note_classCheck_trap(JavaThread* thread, Method *method, int trap_bci) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
293 { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_class_check, method, trap_bci); } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
294 void InterpreterRuntime::note_arrayCheck_trap(JavaThread* thread, Method *method, int trap_bci) |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
295 { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_array_check, method, trap_bci); } |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
296 #endif // CC_INTERP |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
297 |
|
abe03600372a
8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents:
12010
diff
changeset
|
298 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
299 static Handle get_preinitialized_exception(Klass* k, TRAPS) { |
| 0 | 300 // get klass |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
301 InstanceKlass* klass = InstanceKlass::cast(k); |
| 0 | 302 assert(klass->is_initialized(), |
| 303 "this klass should have been initialized during VM initialization"); | |
| 304 // create instance - do not call constructor since we may have no | |
| 305 // (java) stack space left (should assert constructor is empty) | |
| 306 Handle exception; | |
| 307 oop exception_oop = klass->allocate_instance(CHECK_(exception)); | |
| 308 exception = Handle(THREAD, exception_oop); | |
| 309 if (StackTraceInThrowable) { | |
| 310 java_lang_Throwable::fill_in_stack_trace(exception); | |
| 311 } | |
| 312 return exception; | |
| 313 } | |
| 314 | |
| 315 // Special handling for stack overflow: since we don't have any (java) stack | |
| 316 // space left we use the pre-allocated & pre-initialized StackOverflowError | |
| 317 // klass to create an stack overflow error instance. We do not call its | |
| 318 // constructor for the same reason (it is empty, anyway). | |
| 319 IRT_ENTRY(void, InterpreterRuntime::throw_StackOverflowError(JavaThread* thread)) | |
| 320 Handle exception = get_preinitialized_exception( | |
| 321 SystemDictionary::StackOverflowError_klass(), | |
| 322 CHECK); | |
| 323 THROW_HANDLE(exception); | |
| 324 IRT_END | |
| 325 | |
| 326 | |
| 327 IRT_ENTRY(void, InterpreterRuntime::create_exception(JavaThread* thread, char* name, char* message)) | |
| 328 // lookup exception klass | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
329 TempNewSymbol s = SymbolTable::new_symbol(name, CHECK); |
| 0 | 330 if (ProfileTraps) { |
| 331 if (s == vmSymbols::java_lang_ArithmeticException()) { | |
| 332 note_trap(thread, Deoptimization::Reason_div0_check, CHECK); | |
| 333 } else if (s == vmSymbols::java_lang_NullPointerException()) { | |
| 334 note_trap(thread, Deoptimization::Reason_null_check, CHECK); | |
| 335 } | |
| 336 } | |
| 337 // create exception | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
338 Handle exception = Exceptions::new_exception(thread, s, message); |
| 0 | 339 thread->set_vm_result(exception()); |
| 340 IRT_END | |
| 341 | |
| 342 | |
| 343 IRT_ENTRY(void, InterpreterRuntime::create_klass_exception(JavaThread* thread, char* name, oopDesc* obj)) | |
| 344 ResourceMark rm(thread); | |
| 6983 | 345 const char* klass_name = obj->klass()->external_name(); |
| 0 | 346 // lookup exception klass |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
347 TempNewSymbol s = SymbolTable::new_symbol(name, CHECK); |
| 0 | 348 if (ProfileTraps) { |
| 349 note_trap(thread, Deoptimization::Reason_class_check, CHECK); | |
| 350 } | |
| 351 // create exception, with klass name as detail message | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
352 Handle exception = Exceptions::new_exception(thread, s, klass_name); |
| 0 | 353 thread->set_vm_result(exception()); |
| 354 IRT_END | |
| 355 | |
| 356 | |
| 357 IRT_ENTRY(void, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException(JavaThread* thread, char* name, jint index)) | |
| 358 char message[jintAsStringSize]; | |
| 359 // lookup exception klass | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
360 TempNewSymbol s = SymbolTable::new_symbol(name, CHECK); |
| 0 | 361 if (ProfileTraps) { |
| 362 note_trap(thread, Deoptimization::Reason_range_check, CHECK); | |
| 363 } | |
| 364 // create exception | |
| 365 sprintf(message, "%d", index); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
366 THROW_MSG(s, message); |
| 0 | 367 IRT_END |
| 368 | |
| 369 IRT_ENTRY(void, InterpreterRuntime::throw_ClassCastException( | |
| 370 JavaThread* thread, oopDesc* obj)) | |
| 371 | |
| 372 ResourceMark rm(thread); | |
| 373 char* message = SharedRuntime::generate_class_cast_message( | |
| 6983 | 374 thread, obj->klass()->external_name()); |
| 0 | 375 |
| 376 if (ProfileTraps) { | |
| 377 note_trap(thread, Deoptimization::Reason_class_check, CHECK); | |
| 378 } | |
| 379 | |
| 380 // create exception | |
| 381 THROW_MSG(vmSymbols::java_lang_ClassCastException(), message); | |
| 382 IRT_END | |
| 383 | |
| 384 // exception_handler_for_exception(...) returns the continuation address, | |
| 385 // the exception oop (via TLS) and sets the bci/bcp for the continuation. | |
| 386 // The exception oop is returned to make sure it is preserved over GC (it | |
| 387 // is only on the stack if the exception was thrown explicitly via athrow). | |
| 388 // During this operation, the expression stack contains the values for the | |
| 389 // bci where the exception happened. If the exception was propagated back | |
| 390 // from a call, the expression stack contains the values for the bci at the | |
| 391 // invoke w/o arguments (i.e., as if one were inside the call). | |
| 392 IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception)) | |
| 393 | |
| 394 Handle h_exception(thread, exception); | |
| 395 methodHandle h_method (thread, method(thread)); | |
| 396 constantPoolHandle h_constants(thread, h_method->constants()); | |
| 397 bool should_repeat; | |
| 398 int handler_bci; | |
| 1602 | 399 int current_bci = bci(thread); |
| 0 | 400 |
| 401 // Need to do this check first since when _do_not_unlock_if_synchronized | |
| 402 // is set, we don't want to trigger any classloading which may make calls | |
| 403 // into java, or surprisingly find a matching exception handler for bci 0 | |
| 404 // since at this moment the method hasn't been "officially" entered yet. | |
| 405 if (thread->do_not_unlock_if_synchronized()) { | |
| 406 ResourceMark rm; | |
| 407 assert(current_bci == 0, "bci isn't zero for do_not_unlock_if_synchronized"); | |
| 408 thread->set_vm_result(exception); | |
| 409 #ifdef CC_INTERP | |
| 410 return (address) -1; | |
| 411 #else | |
| 412 return Interpreter::remove_activation_entry(); | |
| 413 #endif | |
| 414 } | |
| 415 | |
| 416 do { | |
| 417 should_repeat = false; | |
| 418 | |
| 419 // assertions | |
| 420 #ifdef ASSERT | |
| 421 assert(h_exception.not_null(), "NULL exceptions should be handled by athrow"); | |
| 422 assert(h_exception->is_oop(), "just checking"); | |
| 423 // Check that exception is a subclass of Throwable, otherwise we have a VerifyError | |
| 1142 | 424 if (!(h_exception->is_a(SystemDictionary::Throwable_klass()))) { |
| 0 | 425 if (ExitVMOnVerifyError) vm_exit(-1); |
| 426 ShouldNotReachHere(); | |
| 427 } | |
| 428 #endif | |
| 429 | |
| 430 // tracing | |
| 431 if (TraceExceptions) { | |
| 432 ttyLocker ttyl; | |
| 433 ResourceMark rm(thread); | |
| 434 tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", h_exception->print_value_string(), (address)h_exception()); | |
| 435 tty->print_cr(" thrown in interpreter method <%s>", h_method->print_value_string()); | |
| 436 tty->print_cr(" at bci %d for thread " INTPTR_FORMAT, current_bci, thread); | |
| 437 } | |
| 438 // Don't go paging in something which won't be used. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
439 // else if (extable->length() == 0) { |
| 0 | 440 // // disabled for now - interpreter is not using shortcut yet |
| 441 // // (shortcut is not to call runtime if we have no exception handlers) | |
| 442 // // warning("performance bug: should not call runtime if method has no exception handlers"); | |
| 443 // } | |
| 444 // for AbortVMOnException flag | |
| 445 NOT_PRODUCT(Exceptions::debug_check_abort(h_exception)); | |
| 446 | |
| 447 // exception handler lookup | |
| 448 KlassHandle h_klass(THREAD, h_exception->klass()); | |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7199
diff
changeset
|
449 handler_bci = Method::fast_exception_handler_bci_for(h_method, h_klass, current_bci, THREAD); |
| 0 | 450 if (HAS_PENDING_EXCEPTION) { |
| 451 // We threw an exception while trying to find the exception handler. | |
| 452 // Transfer the new exception to the exception handle which will | |
| 453 // be set into thread local storage, and do another lookup for an | |
| 454 // exception handler for this exception, this time starting at the | |
| 455 // BCI of the exception handler which caused the exception to be | |
| 456 // thrown (bug 4307310). | |
| 457 h_exception = Handle(THREAD, PENDING_EXCEPTION); | |
| 458 CLEAR_PENDING_EXCEPTION; | |
| 459 if (handler_bci >= 0) { | |
| 460 current_bci = handler_bci; | |
| 461 should_repeat = true; | |
| 462 } | |
| 463 } | |
| 464 } while (should_repeat == true); | |
| 465 | |
| 466 // notify JVMTI of an exception throw; JVMTI will detect if this is a first | |
| 467 // time throw or a stack unwinding throw and accordingly notify the debugger | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1142
diff
changeset
|
468 if (JvmtiExport::can_post_on_exceptions()) { |
| 0 | 469 JvmtiExport::post_exception_throw(thread, h_method(), bcp(thread), h_exception()); |
| 470 } | |
| 471 | |
| 472 #ifdef CC_INTERP | |
| 473 address continuation = (address)(intptr_t) handler_bci; | |
| 474 #else | |
| 475 address continuation = NULL; | |
| 476 #endif | |
| 477 address handler_pc = NULL; | |
| 478 if (handler_bci < 0 || !thread->reguard_stack((address) &continuation)) { | |
| 479 // Forward exception to callee (leaving bci/bcp untouched) because (a) no | |
| 480 // handler in this method, or (b) after a stack overflow there is not yet | |
| 481 // enough stack space available to reprotect the stack. | |
| 482 #ifndef CC_INTERP | |
| 483 continuation = Interpreter::remove_activation_entry(); | |
| 484 #endif | |
| 485 // Count this for compilation purposes | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
486 h_method->interpreter_throwout_increment(THREAD); |
| 0 | 487 } else { |
| 488 // handler in this method => change bci/bcp to handler bci/bcp and continue there | |
| 489 handler_pc = h_method->code_base() + handler_bci; | |
| 490 #ifndef CC_INTERP | |
| 491 set_bcp_and_mdp(handler_pc, thread); | |
| 492 continuation = Interpreter::dispatch_table(vtos)[*handler_pc]; | |
| 493 #endif | |
| 494 } | |
| 495 // notify debugger of an exception catch | |
| 496 // (this is good for exceptions caught in native methods as well) | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1142
diff
changeset
|
497 if (JvmtiExport::can_post_on_exceptions()) { |
| 0 | 498 JvmtiExport::notice_unwind_due_to_exception(thread, h_method(), handler_pc, h_exception(), (handler_pc != NULL)); |
| 499 } | |
| 500 | |
| 501 thread->set_vm_result(h_exception()); | |
| 502 return continuation; | |
| 503 IRT_END | |
| 504 | |
| 505 | |
| 506 IRT_ENTRY(void, InterpreterRuntime::throw_pending_exception(JavaThread* thread)) | |
| 507 assert(thread->has_pending_exception(), "must only ne called if there's an exception pending"); | |
| 508 // nothing to do - eventually we should remove this code entirely (see comments @ call sites) | |
| 509 IRT_END | |
| 510 | |
| 511 | |
| 512 IRT_ENTRY(void, InterpreterRuntime::throw_AbstractMethodError(JavaThread* thread)) | |
| 513 THROW(vmSymbols::java_lang_AbstractMethodError()); | |
| 514 IRT_END | |
| 515 | |
| 516 | |
| 517 IRT_ENTRY(void, InterpreterRuntime::throw_IncompatibleClassChangeError(JavaThread* thread)) | |
| 518 THROW(vmSymbols::java_lang_IncompatibleClassChangeError()); | |
| 519 IRT_END | |
| 520 | |
| 521 | |
| 522 //------------------------------------------------------------------------------------------------------------------------ | |
| 523 // Fields | |
| 524 // | |
| 525 | |
| 526 IRT_ENTRY(void, InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode)) | |
| 527 // resolve field | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
528 fieldDescriptor info; |
| 0 | 529 constantPoolHandle pool(thread, method(thread)->constants()); |
|
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3791
diff
changeset
|
530 bool is_put = (bytecode == Bytecodes::_putfield || bytecode == Bytecodes::_putstatic); |
| 0 | 531 bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic); |
| 532 | |
| 533 { | |
| 534 JvmtiHideSingleStepping jhss(thread); | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
535 LinkResolver::resolve_field_access(info, pool, get_index_u2_cpcache(thread, bytecode), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
536 bytecode, CHECK); |
| 0 | 537 } // end JvmtiHideSingleStepping |
| 538 | |
| 539 // check if link resolution caused cpCache to be updated | |
| 540 if (already_resolved(thread)) return; | |
| 541 | |
| 542 // compute auxiliary field attributes | |
| 543 TosState state = as_TosState(info.field_type()); | |
| 544 | |
| 545 // We need to delay resolving put instructions on final fields | |
| 546 // until we actually invoke one. This is required so we throw | |
| 547 // exceptions at the correct place. If we do not resolve completely | |
| 548 // in the current pass, leaving the put_code set to zero will | |
| 549 // cause the next put instruction to reresolve. | |
| 550 Bytecodes::Code put_code = (Bytecodes::Code)0; | |
| 551 | |
| 552 // We also need to delay resolving getstatic instructions until the | |
| 553 // class is intitialized. This is required so that access to the static | |
| 554 // field will call the initialization function every time until the class | |
| 555 // is completely initialized ala. in 2.17.5 in JVM Specification. | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
556 InstanceKlass* klass = InstanceKlass::cast(info.field_holder()); |
| 0 | 557 bool uninitialized_static = ((bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic) && |
| 558 !klass->is_initialized()); | |
| 559 Bytecodes::Code get_code = (Bytecodes::Code)0; | |
| 560 | |
| 561 if (!uninitialized_static) { | |
| 562 get_code = ((is_static) ? Bytecodes::_getstatic : Bytecodes::_getfield); | |
| 563 if (is_put || !info.access_flags().is_final()) { | |
| 564 put_code = ((is_static) ? Bytecodes::_putstatic : Bytecodes::_putfield); | |
| 565 } | |
| 566 } | |
| 567 | |
| 568 cache_entry(thread)->set_field( | |
| 569 get_code, | |
| 570 put_code, | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
571 info.field_holder(), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
572 info.index(), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
573 info.offset(), |
| 0 | 574 state, |
| 575 info.access_flags().is_final(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
576 info.access_flags().is_volatile(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
577 pool->pool_holder() |
| 0 | 578 ); |
| 579 IRT_END | |
| 580 | |
| 581 | |
| 582 //------------------------------------------------------------------------------------------------------------------------ | |
| 583 // Synchronization | |
| 584 // | |
| 585 // The interpreter's synchronization code is factored out so that it can | |
| 586 // be shared by method invocation and synchronized blocks. | |
| 587 //%note synchronization_3 | |
| 588 | |
| 589 //%note monitor_1 | |
| 590 IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem)) | |
| 591 #ifdef ASSERT | |
| 592 thread->last_frame().interpreter_frame_verify_monitor(elem); | |
| 593 #endif | |
| 594 if (PrintBiasedLockingStatistics) { | |
| 595 Atomic::inc(BiasedLocking::slow_path_entry_count_addr()); | |
| 596 } | |
| 597 Handle h_obj(thread, elem->obj()); | |
| 598 assert(Universe::heap()->is_in_reserved_or_null(h_obj()), | |
| 599 "must be NULL or an object"); | |
| 600 if (UseBiasedLocking) { | |
| 601 // Retry fast entry if bias is revoked to avoid unnecessary inflation | |
| 602 ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK); | |
| 603 } else { | |
| 604 ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK); | |
| 605 } | |
| 606 assert(Universe::heap()->is_in_reserved_or_null(elem->obj()), | |
| 607 "must be NULL or an object"); | |
| 608 #ifdef ASSERT | |
| 609 thread->last_frame().interpreter_frame_verify_monitor(elem); | |
| 610 #endif | |
| 611 IRT_END | |
| 612 | |
| 613 | |
| 614 //%note monitor_1 | |
| 615 IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorexit(JavaThread* thread, BasicObjectLock* elem)) | |
| 616 #ifdef ASSERT | |
| 617 thread->last_frame().interpreter_frame_verify_monitor(elem); | |
| 618 #endif | |
| 619 Handle h_obj(thread, elem->obj()); | |
| 620 assert(Universe::heap()->is_in_reserved_or_null(h_obj()), | |
| 621 "must be NULL or an object"); | |
| 622 if (elem == NULL || h_obj()->is_unlocked()) { | |
| 623 THROW(vmSymbols::java_lang_IllegalMonitorStateException()); | |
| 624 } | |
| 625 ObjectSynchronizer::slow_exit(h_obj(), elem->lock(), thread); | |
| 626 // Free entry. This must be done here, since a pending exception might be installed on | |
| 627 // exit. If it is not cleared, the exception handling code will try to unlock the monitor again. | |
| 628 elem->set_obj(NULL); | |
| 629 #ifdef ASSERT | |
| 630 thread->last_frame().interpreter_frame_verify_monitor(elem); | |
| 631 #endif | |
| 632 IRT_END | |
| 633 | |
| 634 | |
| 635 IRT_ENTRY(void, InterpreterRuntime::throw_illegal_monitor_state_exception(JavaThread* thread)) | |
| 636 THROW(vmSymbols::java_lang_IllegalMonitorStateException()); | |
| 637 IRT_END | |
| 638 | |
| 639 | |
| 640 IRT_ENTRY(void, InterpreterRuntime::new_illegal_monitor_state_exception(JavaThread* thread)) | |
| 641 // Returns an illegal exception to install into the current thread. The | |
| 642 // pending_exception flag is cleared so normal exception handling does not | |
| 643 // trigger. Any current installed exception will be overwritten. This | |
| 644 // method will be called during an exception unwind. | |
| 645 | |
| 646 assert(!HAS_PENDING_EXCEPTION, "no pending exception"); | |
| 647 Handle exception(thread, thread->vm_result()); | |
| 648 assert(exception() != NULL, "vm result should be set"); | |
| 649 thread->set_vm_result(NULL); // clear vm result before continuing (may cause memory leaks and assert failures) | |
| 1142 | 650 if (!exception->is_a(SystemDictionary::ThreadDeath_klass())) { |
| 0 | 651 exception = get_preinitialized_exception( |
| 652 SystemDictionary::IllegalMonitorStateException_klass(), | |
| 653 CATCH); | |
| 654 } | |
| 655 thread->set_vm_result(exception()); | |
| 656 IRT_END | |
| 657 | |
| 658 | |
| 659 //------------------------------------------------------------------------------------------------------------------------ | |
| 660 // Invokes | |
| 661 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
662 IRT_ENTRY(Bytecodes::Code, InterpreterRuntime::get_original_bytecode_at(JavaThread* thread, Method* method, address bcp)) |
| 0 | 663 return method->orig_bytecode_at(method->bci_from(bcp)); |
| 664 IRT_END | |
| 665 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
666 IRT_ENTRY(void, InterpreterRuntime::set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code)) |
| 0 | 667 method->set_orig_bytecode_at(method->bci_from(bcp), new_code); |
| 668 IRT_END | |
| 669 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
670 IRT_ENTRY(void, InterpreterRuntime::_breakpoint(JavaThread* thread, Method* method, address bcp)) |
| 0 | 671 JvmtiExport::post_raw_breakpoint(thread, method, bcp); |
| 672 IRT_END | |
| 673 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
674 IRT_ENTRY(void, InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code bytecode)) { |
| 0 | 675 // extract receiver from the outgoing argument list if necessary |
| 676 Handle receiver(thread, NULL); | |
| 677 if (bytecode == Bytecodes::_invokevirtual || bytecode == Bytecodes::_invokeinterface) { | |
| 678 ResourceMark rm(thread); | |
| 679 methodHandle m (thread, method(thread)); | |
| 2142 | 680 Bytecode_invoke call(m, bci(thread)); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2144
diff
changeset
|
681 Symbol* signature = call.signature(); |
| 0 | 682 receiver = Handle(thread, |
| 683 thread->last_frame().interpreter_callee_receiver(signature)); | |
| 684 assert(Universe::heap()->is_in_reserved_or_null(receiver()), | |
| 685 "sanity check"); | |
| 686 assert(receiver.is_null() || | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
687 !Universe::heap()->is_in_reserved(receiver->klass()), |
| 0 | 688 "sanity check"); |
| 689 } | |
| 690 | |
| 691 // resolve method | |
| 692 CallInfo info; | |
| 693 constantPoolHandle pool(thread, method(thread)->constants()); | |
| 694 | |
| 695 { | |
| 696 JvmtiHideSingleStepping jhss(thread); | |
| 697 LinkResolver::resolve_invoke(info, receiver, pool, | |
| 1565 | 698 get_index_u2_cpcache(thread, bytecode), bytecode, CHECK); |
| 0 | 699 if (JvmtiExport::can_hotswap_or_post_breakpoint()) { |
| 700 int retry_count = 0; | |
| 701 while (info.resolved_method()->is_old()) { | |
| 702 // It is very unlikely that method is redefined more than 100 times | |
| 703 // in the middle of resolve. If it is looping here more than 100 times | |
| 704 // means then there could be a bug here. | |
| 705 guarantee((retry_count++ < 100), | |
| 706 "Could not resolve to latest version of redefined method"); | |
| 707 // method is redefined in the middle of resolve so re-try. | |
| 708 LinkResolver::resolve_invoke(info, receiver, pool, | |
| 1565 | 709 get_index_u2_cpcache(thread, bytecode), bytecode, CHECK); |
| 0 | 710 } |
| 711 } | |
| 712 } // end JvmtiHideSingleStepping | |
| 713 | |
| 714 // check if link resolution caused cpCache to be updated | |
| 715 if (already_resolved(thread)) return; | |
| 716 | |
| 717 if (bytecode == Bytecodes::_invokeinterface) { | |
| 718 if (TraceItables && Verbose) { | |
| 719 ResourceMark rm(thread); | |
| 720 tty->print_cr("Resolving: klass: %s to method: %s", info.resolved_klass()->name()->as_C_string(), info.resolved_method()->name()->as_C_string()); | |
| 721 } | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
722 } |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
723 #ifdef ASSERT |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
724 if (bytecode == Bytecodes::_invokeinterface) { |
| 0 | 725 if (info.resolved_method()->method_holder() == |
| 1142 | 726 SystemDictionary::Object_klass()) { |
| 0 | 727 // NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
728 // (see also CallInfo::set_interface for details) |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
729 assert(info.call_kind() == CallInfo::vtable_call || |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
730 info.call_kind() == CallInfo::direct_call, ""); |
| 0 | 731 methodHandle rm = info.resolved_method(); |
| 732 assert(rm->is_final() || info.has_vtable_index(), | |
| 733 "should have been set already"); | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
734 } else if (!info.resolved_method()->has_itable_index()) { |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
735 // Resolved something like CharSequence.toString. Use vtable not itable. |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
736 assert(info.call_kind() != CallInfo::itable_call, ""); |
| 0 | 737 } else { |
| 738 // Setup itable entry | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
739 assert(info.call_kind() == CallInfo::itable_call, ""); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
740 int index = info.resolved_method()->itable_index(); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
741 assert(info.itable_index() == index, ""); |
| 0 | 742 } |
| 743 } else { | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
744 assert(info.call_kind() == CallInfo::direct_call || |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
745 info.call_kind() == CallInfo::vtable_call, ""); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
746 } |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
747 #endif |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
748 switch (info.call_kind()) { |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
749 case CallInfo::direct_call: |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
750 cache_entry(thread)->set_direct_call( |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
751 bytecode, |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
752 info.resolved_method()); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
753 break; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
754 case CallInfo::vtable_call: |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
755 cache_entry(thread)->set_vtable_call( |
| 0 | 756 bytecode, |
| 757 info.resolved_method(), | |
| 758 info.vtable_index()); | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
759 break; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
760 case CallInfo::itable_call: |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
761 cache_entry(thread)->set_itable_call( |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
762 bytecode, |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
763 info.resolved_method(), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
764 info.itable_index()); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
765 break; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12010
diff
changeset
|
766 default: ShouldNotReachHere(); |
| 0 | 767 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
768 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
769 IRT_END |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
770 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
771 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
772 // First time execution: Resolve symbols, create a permanent MethodType object. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
773 IRT_ENTRY(void, InterpreterRuntime::resolve_invokehandle(JavaThread* thread)) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
774 assert(EnableInvokeDynamic, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
775 const Bytecodes::Code bytecode = Bytecodes::_invokehandle; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
776 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
777 // resolve method |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
778 CallInfo info; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
779 constantPoolHandle pool(thread, method(thread)->constants()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
780 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
781 { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
782 JvmtiHideSingleStepping jhss(thread); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
783 LinkResolver::resolve_invoke(info, Handle(), pool, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
784 get_index_u2_cpcache(thread, bytecode), bytecode, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
785 } // end JvmtiHideSingleStepping |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
786 |
|
6942
64672b22ef05
8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents:
6840
diff
changeset
|
787 cache_entry(thread)->set_method_handle(pool, info); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
788 } |
| 0 | 789 IRT_END |
| 790 | |
| 791 | |
|
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
941
diff
changeset
|
792 // First time execution: Resolve symbols, create a permanent CallSite object. |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
793 IRT_ENTRY(void, InterpreterRuntime::resolve_invokedynamic(JavaThread* thread)) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
794 assert(EnableInvokeDynamic, ""); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
795 const Bytecodes::Code bytecode = Bytecodes::_invokedynamic; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
796 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
797 //TO DO: consider passing BCI to Java. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
798 // int caller_bci = method(thread)->bci_from(bcp(thread)); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
799 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
800 // resolve method |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
801 CallInfo info; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
802 constantPoolHandle pool(thread, method(thread)->constants()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
803 int index = get_index_u4(thread, bytecode); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
804 { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
805 JvmtiHideSingleStepping jhss(thread); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
806 LinkResolver::resolve_invoke(info, Handle(), pool, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
807 index, bytecode, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
808 } // end JvmtiHideSingleStepping |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1603
diff
changeset
|
809 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
810 ConstantPoolCacheEntry* cp_cache_entry = pool->invokedynamic_cp_cache_entry_at(index); |
|
6942
64672b22ef05
8001658: No need to pass resolved_references as argument to ConstantPoolCacheEntry::set_method_handle_common
twisti
parents:
6840
diff
changeset
|
811 cp_cache_entry->set_dynamic_call(pool, info); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
812 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
813 IRT_END |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
814 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
815 |
| 0 | 816 //------------------------------------------------------------------------------------------------------------------------ |
| 817 // Miscellaneous | |
| 818 | |
| 819 | |
| 941 | 820 nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) { |
| 821 nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp); | |
| 822 assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests"); | |
| 823 if (branch_bcp != NULL && nm != NULL) { | |
| 824 // This was a successful request for an OSR nmethod. Because | |
| 825 // frequency_counter_overflow_inner ends with a safepoint check, | |
| 826 // nm could have been unloaded so look it up again. It's unsafe | |
| 827 // to examine nm directly since it might have been freed and used | |
| 828 // for something else. | |
| 829 frame fr = thread->last_frame(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
830 Method* method = fr.interpreter_frame_method(); |
| 941 | 831 int bci = method->bci_from(fr.interpreter_frame_bcp()); |
| 1783 | 832 nm = method->lookup_osr_nmethod_for(bci, CompLevel_none, false); |
| 941 | 833 } |
|
6145
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
834 #ifndef PRODUCT |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
835 if (TraceOnStackReplacement) { |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
836 if (nm != NULL) { |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
837 tty->print("OSR entry @ pc: " INTPTR_FORMAT ": ", nm->osr_entry()); |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
838 nm->print(); |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
839 } |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
840 } |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4825
diff
changeset
|
841 #endif |
| 941 | 842 return nm; |
| 843 } | |
| 844 | |
| 0 | 845 IRT_ENTRY(nmethod*, |
| 941 | 846 InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp)) |
| 0 | 847 // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized |
| 848 // flag, in case this method triggers classloading which will call into Java. | |
| 849 UnlockFlagSaver fs(thread); | |
| 850 | |
| 851 frame fr = thread->last_frame(); | |
| 852 assert(fr.is_interpreted_frame(), "must come from interpreter"); | |
| 853 methodHandle method(thread, fr.interpreter_frame_method()); | |
| 1783 | 854 const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci; |
| 855 const int bci = branch_bcp != NULL ? method->bci_from(fr.interpreter_frame_bcp()) : InvocationEntryBci; | |
| 856 | |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4043
diff
changeset
|
857 assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending"); |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3781
diff
changeset
|
858 nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, NULL, thread); |
|
4825
20334ed5ed3c
7131259: compile_method and CompilationPolicy::event shouldn't be declared TRAPS
iveresov
parents:
4043
diff
changeset
|
859 assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions"); |
| 0 | 860 |
| 1783 | 861 if (osr_nm != NULL) { |
| 862 // We may need to do on-stack replacement which requires that no | |
| 863 // monitors in the activation are biased because their | |
| 864 // BasicObjectLocks will need to migrate during OSR. Force | |
| 865 // unbiasing of all monitors in the activation now (even though | |
| 866 // the OSR nmethod might be invalidated) because we don't have a | |
| 867 // safepoint opportunity later once the migration begins. | |
| 868 if (UseBiasedLocking) { | |
| 869 ResourceMark rm; | |
| 870 GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>(); | |
| 871 for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end(); | |
| 872 kptr < fr.interpreter_frame_monitor_begin(); | |
| 873 kptr = fr.next_monitor_in_interpreter_frame(kptr) ) { | |
| 874 if( kptr->obj() != NULL ) { | |
| 875 objects_to_revoke->append(Handle(THREAD, kptr->obj())); | |
| 876 } | |
| 0 | 877 } |
| 1783 | 878 BiasedLocking::revoke(objects_to_revoke); |
| 0 | 879 } |
| 880 } | |
| 1783 | 881 return osr_nm; |
| 0 | 882 IRT_END |
| 883 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
884 IRT_LEAF(jint, InterpreterRuntime::bcp_to_di(Method* method, address cur_bcp)) |
| 0 | 885 assert(ProfileInterpreter, "must be profiling interpreter"); |
| 886 int bci = method->bci_from(cur_bcp); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
887 MethodData* mdo = method->method_data(); |
| 0 | 888 if (mdo == NULL) return 0; |
| 889 return mdo->bci_to_di(bci); | |
| 890 IRT_END | |
| 891 | |
|
2118
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1986
diff
changeset
|
892 IRT_ENTRY(void, InterpreterRuntime::profile_method(JavaThread* thread)) |
| 0 | 893 // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized |
| 894 // flag, in case this method triggers classloading which will call into Java. | |
| 895 UnlockFlagSaver fs(thread); | |
| 896 | |
| 897 assert(ProfileInterpreter, "must be profiling interpreter"); | |
| 898 frame fr = thread->last_frame(); | |
| 899 assert(fr.is_interpreted_frame(), "must come from interpreter"); | |
| 900 methodHandle method(thread, fr.interpreter_frame_method()); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
901 Method::build_interpreter_method_data(method, THREAD); |
| 0 | 902 if (HAS_PENDING_EXCEPTION) { |
| 903 assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here"); | |
| 904 CLEAR_PENDING_EXCEPTION; | |
| 905 // and fall through... | |
| 906 } | |
| 907 IRT_END | |
| 908 | |
| 909 | |
| 910 #ifdef ASSERT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
911 IRT_LEAF(void, InterpreterRuntime::verify_mdp(Method* method, address bcp, address mdp)) |
| 0 | 912 assert(ProfileInterpreter, "must be profiling interpreter"); |
| 913 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
914 MethodData* mdo = method->method_data(); |
| 0 | 915 assert(mdo != NULL, "must not be null"); |
| 916 | |
| 917 int bci = method->bci_from(bcp); | |
| 918 | |
| 919 address mdp2 = mdo->bci_to_dp(bci); | |
| 920 if (mdp != mdp2) { | |
| 921 ResourceMark rm; | |
| 922 ResetNoHandleMark rnm; // In a LEAF entry. | |
| 923 HandleMark hm; | |
| 924 tty->print_cr("FAILED verify : actual mdp %p expected mdp %p @ bci %d", mdp, mdp2, bci); | |
| 925 int current_di = mdo->dp_to_di(mdp); | |
| 926 int expected_di = mdo->dp_to_di(mdp2); | |
| 927 tty->print_cr(" actual di %d expected di %d", current_di, expected_di); | |
| 928 int expected_approx_bci = mdo->data_at(expected_di)->bci(); | |
| 929 int approx_bci = -1; | |
| 930 if (current_di >= 0) { | |
| 931 approx_bci = mdo->data_at(current_di)->bci(); | |
| 932 } | |
| 933 tty->print_cr(" actual bci is %d expected bci %d", approx_bci, expected_approx_bci); | |
| 934 mdo->print_on(tty); | |
| 935 method->print_codes(); | |
| 936 } | |
| 937 assert(mdp == mdp2, "wrong mdp"); | |
| 938 IRT_END | |
| 939 #endif // ASSERT | |
| 940 | |
| 941 IRT_ENTRY(void, InterpreterRuntime::update_mdp_for_ret(JavaThread* thread, int return_bci)) | |
| 942 assert(ProfileInterpreter, "must be profiling interpreter"); | |
| 943 ResourceMark rm(thread); | |
| 944 HandleMark hm(thread); | |
| 945 frame fr = thread->last_frame(); | |
| 946 assert(fr.is_interpreted_frame(), "must come from interpreter"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
947 MethodData* h_mdo = fr.interpreter_frame_method()->method_data(); |
| 0 | 948 |
| 949 // Grab a lock to ensure atomic access to setting the return bci and | |
| 950 // the displacement. This can block and GC, invalidating all naked oops. | |
| 951 MutexLocker ml(RetData_lock); | |
| 952 | |
| 953 // ProfileData is essentially a wrapper around a derived oop, so we | |
| 954 // need to take the lock before making any ProfileData structures. | |
| 955 ProfileData* data = h_mdo->data_at(h_mdo->dp_to_di(fr.interpreter_frame_mdp())); | |
| 956 RetData* rdata = data->as_RetData(); | |
| 957 address new_mdp = rdata->fixup_ret(return_bci, h_mdo); | |
| 958 fr.interpreter_frame_set_mdp(new_mdp); | |
| 959 IRT_END | |
| 960 | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
961 IRT_ENTRY(MethodCounters*, InterpreterRuntime::build_method_counters(JavaThread* thread, Method* m)) |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
962 MethodCounters* mcs = Method::build_method_counters(m, thread); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
963 if (HAS_PENDING_EXCEPTION) { |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
964 assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here"); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
965 CLEAR_PENDING_EXCEPTION; |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
966 } |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
967 return mcs; |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
968 IRT_END |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
7469
diff
changeset
|
969 |
| 0 | 970 |
| 971 IRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread)) | |
| 972 // We used to need an explict preserve_arguments here for invoke bytecodes. However, | |
| 973 // stack traversal automatically takes care of preserving arguments for invoke, so | |
| 974 // this is no longer needed. | |
| 975 | |
| 976 // IRT_END does an implicit safepoint check, hence we are guaranteed to block | |
| 977 // if this is called during a safepoint | |
| 978 | |
| 979 if (JvmtiExport::should_post_single_step()) { | |
| 980 // We are called during regular safepoints and when the VM is | |
| 981 // single stepping. If any thread is marked for single stepping, | |
| 982 // then we may have JVMTI work to do. | |
| 983 JvmtiExport::at_single_stepping_point(thread, method(thread), bcp(thread)); | |
| 984 } | |
| 985 IRT_END | |
| 986 | |
| 987 IRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread *thread, oopDesc* obj, | |
| 988 ConstantPoolCacheEntry *cp_entry)) | |
| 989 | |
| 990 // check the access_flags for the field in the klass | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
991 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
992 InstanceKlass* ik = InstanceKlass::cast(cp_entry->f1_as_klass()); |
| 0 | 993 int index = cp_entry->field_index(); |
| 3938 | 994 if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return; |
| 0 | 995 |
| 996 switch(cp_entry->flag_state()) { | |
| 997 case btos: // fall through | |
| 998 case ctos: // fall through | |
| 999 case stos: // fall through | |
| 1000 case itos: // fall through | |
| 1001 case ftos: // fall through | |
| 1002 case ltos: // fall through | |
| 1003 case dtos: // fall through | |
| 1004 case atos: break; | |
| 1005 default: ShouldNotReachHere(); return; | |
| 1006 } | |
| 1007 bool is_static = (obj == NULL); | |
| 1008 HandleMark hm(thread); | |
| 1009 | |
| 1010 Handle h_obj; | |
| 1011 if (!is_static) { | |
| 1012 // non-static field accessors have an object, but we need a handle | |
| 1013 h_obj = Handle(thread, obj); | |
| 1014 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1015 instanceKlassHandle h_cp_entry_f1(thread, (Klass*)cp_entry->f1_as_klass()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
1016 jfieldID fid = jfieldIDWorkaround::to_jfieldID(h_cp_entry_f1, cp_entry->f2_as_index(), is_static); |
| 0 | 1017 JvmtiExport::post_field_access(thread, method(thread), bcp(thread), h_cp_entry_f1, h_obj, fid); |
| 1018 IRT_END | |
| 1019 | |
| 1020 IRT_ENTRY(void, InterpreterRuntime::post_field_modification(JavaThread *thread, | |
| 1021 oopDesc* obj, ConstantPoolCacheEntry *cp_entry, jvalue *value)) | |
| 1022 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1023 Klass* k = (Klass*)cp_entry->f1_as_klass(); |
| 0 | 1024 |
| 1025 // check the access_flags for the field in the klass | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1026 InstanceKlass* ik = InstanceKlass::cast(k); |
| 0 | 1027 int index = cp_entry->field_index(); |
| 1028 // bail out if field modifications are not watched | |
| 3938 | 1029 if ((ik->field_access_flags(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return; |
| 0 | 1030 |
| 1031 char sig_type = '\0'; | |
| 1032 | |
| 1033 switch(cp_entry->flag_state()) { | |
| 1034 case btos: sig_type = 'Z'; break; | |
| 1035 case ctos: sig_type = 'C'; break; | |
| 1036 case stos: sig_type = 'S'; break; | |
| 1037 case itos: sig_type = 'I'; break; | |
| 1038 case ftos: sig_type = 'F'; break; | |
| 1039 case atos: sig_type = 'L'; break; | |
| 1040 case ltos: sig_type = 'J'; break; | |
| 1041 case dtos: sig_type = 'D'; break; | |
| 1042 default: ShouldNotReachHere(); return; | |
| 1043 } | |
| 1044 bool is_static = (obj == NULL); | |
| 1045 | |
| 1046 HandleMark hm(thread); | |
| 1047 instanceKlassHandle h_klass(thread, k); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6227
diff
changeset
|
1048 jfieldID fid = jfieldIDWorkaround::to_jfieldID(h_klass, cp_entry->f2_as_index(), is_static); |
| 0 | 1049 jvalue fvalue; |
| 1050 #ifdef _LP64 | |
| 1051 fvalue = *value; | |
| 1052 #else | |
| 1053 // Long/double values are stored unaligned and also noncontiguously with | |
| 1054 // tagged stacks. We can't just do a simple assignment even in the non- | |
| 1055 // J/D cases because a C++ compiler is allowed to assume that a jvalue is | |
| 1056 // 8-byte aligned, and interpreter stack slots are only 4-byte aligned. | |
| 1057 // We assume that the two halves of longs/doubles are stored in interpreter | |
| 1058 // stack slots in platform-endian order. | |
| 1059 jlong_accessor u; | |
| 1060 jint* newval = (jint*)value; | |
| 1061 u.words[0] = newval[0]; | |
| 1506 | 1062 u.words[1] = newval[Interpreter::stackElementWords]; // skip if tag |
| 0 | 1063 fvalue.j = u.long_value; |
| 1064 #endif // _LP64 | |
| 1065 | |
| 1066 Handle h_obj; | |
| 1067 if (!is_static) { | |
| 1068 // non-static field accessors have an object, but we need a handle | |
| 1069 h_obj = Handle(thread, obj); | |
| 1070 } | |
| 1071 | |
| 1072 JvmtiExport::post_raw_field_modification(thread, method(thread), bcp(thread), h_klass, h_obj, | |
| 1073 fid, sig_type, &fvalue); | |
| 1074 IRT_END | |
| 1075 | |
| 1076 IRT_ENTRY(void, InterpreterRuntime::post_method_entry(JavaThread *thread)) | |
| 1077 JvmtiExport::post_method_entry(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread)); | |
| 1078 IRT_END | |
| 1079 | |
| 1080 | |
| 1081 IRT_ENTRY(void, InterpreterRuntime::post_method_exit(JavaThread *thread)) | |
| 1082 JvmtiExport::post_method_exit(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread)); | |
| 1083 IRT_END | |
| 1084 | |
| 1085 IRT_LEAF(int, InterpreterRuntime::interpreter_contains(address pc)) | |
| 1086 { | |
| 1087 return (Interpreter::contains(pc) ? 1 : 0); | |
| 1088 } | |
| 1089 IRT_END | |
| 1090 | |
| 1091 | |
| 1092 // Implementation of SignatureHandlerLibrary | |
| 1093 | |
| 1094 address SignatureHandlerLibrary::set_handler_blob() { | |
| 1095 BufferBlob* handler_blob = BufferBlob::create("native signature handlers", blob_size); | |
| 1096 if (handler_blob == NULL) { | |
| 1097 return NULL; | |
| 1098 } | |
| 1748 | 1099 address handler = handler_blob->code_begin(); |
| 0 | 1100 _handler_blob = handler_blob; |
| 1101 _handler = handler; | |
| 1102 return handler; | |
| 1103 } | |
| 1104 | |
| 1105 void SignatureHandlerLibrary::initialize() { | |
| 1106 if (_fingerprints != NULL) { | |
| 1107 return; | |
| 1108 } | |
| 1109 if (set_handler_blob() == NULL) { | |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10107
diff
changeset
|
1110 vm_exit_out_of_memory(blob_size, OOM_MALLOC_ERROR, "native signature handlers"); |
| 0 | 1111 } |
| 1112 | |
| 1113 BufferBlob* bb = BufferBlob::create("Signature Handler Temp Buffer", | |
| 1114 SignatureHandlerLibrary::buffer_size); | |
| 1748 | 1115 _buffer = bb->code_begin(); |
| 0 | 1116 |
| 6197 | 1117 _fingerprints = new(ResourceObj::C_HEAP, mtCode)GrowableArray<uint64_t>(32, true); |
| 1118 _handlers = new(ResourceObj::C_HEAP, mtCode)GrowableArray<address>(32, true); | |
| 0 | 1119 } |
| 1120 | |
| 1121 address SignatureHandlerLibrary::set_handler(CodeBuffer* buffer) { | |
| 1122 address handler = _handler; | |
| 1748 | 1123 int insts_size = buffer->pure_insts_size(); |
| 1124 if (handler + insts_size > _handler_blob->code_end()) { | |
| 0 | 1125 // get a new handler blob |
| 1126 handler = set_handler_blob(); | |
| 1127 } | |
| 1128 if (handler != NULL) { | |
| 1748 | 1129 memcpy(handler, buffer->insts_begin(), insts_size); |
| 0 | 1130 pd_set_handler(handler); |
| 1748 | 1131 ICache::invalidate_range(handler, insts_size); |
| 1132 _handler = handler + insts_size; | |
| 0 | 1133 } |
| 1134 return handler; | |
| 1135 } | |
| 1136 | |
| 1137 void SignatureHandlerLibrary::add(methodHandle method) { | |
| 1138 if (method->signature_handler() == NULL) { | |
| 1139 // use slow signature handler if we can't do better | |
| 1140 int handler_index = -1; | |
| 1141 // check if we can use customized (fast) signature handler | |
| 1142 if (UseFastSignatureHandlers && method->size_of_parameters() <= Fingerprinter::max_size_of_parameters) { | |
| 1143 // use customized signature handler | |
| 1144 MutexLocker mu(SignatureHandlerLibrary_lock); | |
| 1145 // make sure data structure is initialized | |
| 1146 initialize(); | |
| 1147 // lookup method signature's fingerprint | |
| 1148 uint64_t fingerprint = Fingerprinter(method).fingerprint(); | |
| 1149 handler_index = _fingerprints->find(fingerprint); | |
| 1150 // create handler if necessary | |
| 1151 if (handler_index < 0) { | |
| 1152 ResourceMark rm; | |
| 1153 ptrdiff_t align_offset = (address) | |
| 1154 round_to((intptr_t)_buffer, CodeEntryAlignment) - (address)_buffer; | |
| 1155 CodeBuffer buffer((address)(_buffer + align_offset), | |
| 1156 SignatureHandlerLibrary::buffer_size - align_offset); | |
| 1157 InterpreterRuntime::SignatureHandlerGenerator(method, &buffer).generate(fingerprint); | |
| 1158 // copy into code heap | |
| 1159 address handler = set_handler(&buffer); | |
| 1160 if (handler == NULL) { | |
| 1161 // use slow signature handler | |
| 1162 } else { | |
| 1163 // debugging suppport | |
| 1164 if (PrintSignatureHandlers) { | |
| 1165 tty->cr(); | |
| 1166 tty->print_cr("argument handler #%d for: %s %s (fingerprint = " UINT64_FORMAT ", %d bytes generated)", | |
| 1167 _handlers->length(), | |
| 1168 (method->is_static() ? "static" : "receiver"), | |
| 1169 method->name_and_sig_as_C_string(), | |
| 1170 fingerprint, | |
| 1748 | 1171 buffer.insts_size()); |
| 1172 Disassembler::decode(handler, handler + buffer.insts_size()); | |
| 0 | 1173 #ifndef PRODUCT |
| 1174 tty->print_cr(" --- associated result handler ---"); | |
| 1175 address rh_begin = Interpreter::result_handler(method()->result_type()); | |
| 1176 address rh_end = rh_begin; | |
| 1177 while (*(int*)rh_end != 0) { | |
| 1178 rh_end += sizeof(int); | |
| 1179 } | |
| 1180 Disassembler::decode(rh_begin, rh_end); | |
| 1181 #endif | |
| 1182 } | |
| 1183 // add handler to library | |
| 1184 _fingerprints->append(fingerprint); | |
| 1185 _handlers->append(handler); | |
| 1186 // set handler index | |
| 1187 assert(_fingerprints->length() == _handlers->length(), "sanity check"); | |
| 1188 handler_index = _fingerprints->length() - 1; | |
| 1189 } | |
| 1190 } | |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1191 // Set handler under SignatureHandlerLibrary_lock |
| 0 | 1192 if (handler_index < 0) { |
| 1193 // use generic signature handler | |
| 1194 method->set_signature_handler(Interpreter::slow_signature_handler()); | |
| 1195 } else { | |
| 1196 // set handler | |
| 1197 method->set_signature_handler(_handlers->at(handler_index)); | |
| 1198 } | |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1199 } else { |
|
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1200 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); |
|
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1201 // use generic signature handler |
|
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1202 method->set_signature_handler(Interpreter::slow_signature_handler()); |
|
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1203 } |
| 0 | 1204 } |
|
1986
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1205 #ifdef ASSERT |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1206 int handler_index = -1; |
|
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1207 int fingerprint_index = -2; |
|
1986
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1208 { |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1209 // '_handlers' and '_fingerprints' are 'GrowableArray's and are NOT synchronized |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1210 // in any way if accessed from multiple threads. To avoid races with another |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1211 // thread which may change the arrays in the above, mutex protected block, we |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1212 // have to protect this read access here with the same mutex as well! |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1213 MutexLocker mu(SignatureHandlerLibrary_lock); |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1214 if (_handlers != NULL) { |
|
1986
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1215 handler_index = _handlers->find(method->signature_handler()); |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1216 fingerprint_index = _fingerprints->find(Fingerprinter(method).fingerprint()); |
|
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1217 } |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1218 } |
| 0 | 1219 assert(method->signature_handler() == Interpreter::slow_signature_handler() || |
|
1986
9bc798875b2a
6704010: Internal Error (src/share/vm/interpreter/interpreterRuntime.cpp:1106)
coleenp
parents:
1972
diff
changeset
|
1220 handler_index == fingerprint_index, "sanity check"); |
|
2194
face83fc8882
7012088: jump to 0 address because of lack of memory ordering in SignatureHandlerLibrary::add
coleenp
parents:
2192
diff
changeset
|
1221 #endif // ASSERT |
| 0 | 1222 } |
| 1223 | |
| 1224 | |
| 1225 BufferBlob* SignatureHandlerLibrary::_handler_blob = NULL; | |
| 1226 address SignatureHandlerLibrary::_handler = NULL; | |
| 1227 GrowableArray<uint64_t>* SignatureHandlerLibrary::_fingerprints = NULL; | |
| 1228 GrowableArray<address>* SignatureHandlerLibrary::_handlers = NULL; | |
| 1229 address SignatureHandlerLibrary::_buffer = NULL; | |
| 1230 | |
| 1231 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1232 IRT_ENTRY(void, InterpreterRuntime::prepare_native_call(JavaThread* thread, Method* method)) |
| 0 | 1233 methodHandle m(thread, method); |
| 1234 assert(m->is_native(), "sanity check"); | |
| 1235 // lookup native function entry point if it doesn't exist | |
| 1236 bool in_base_library; | |
| 1237 if (!m->has_native_function()) { | |
| 1238 NativeLookup::lookup(m, in_base_library, CHECK); | |
| 1239 } | |
| 1240 // make sure signature handler is installed | |
| 1241 SignatureHandlerLibrary::add(m); | |
| 1242 // The interpreter entry point checks the signature handler first, | |
| 1243 // before trying to fetch the native entry point and klass mirror. | |
| 1244 // We must set the signature handler last, so that multiple processors | |
| 1245 // preparing the same method will be sure to see non-null entry & mirror. | |
| 1246 IRT_END | |
| 1247 | |
|
3911
2fecca53a2c6
7085012: ARM: com/sun/jdi/PopSynchronousTest.java still fails
roland
parents:
3852
diff
changeset
|
1248 #if defined(IA32) || defined(AMD64) || defined(ARM) |
| 0 | 1249 IRT_LEAF(void, InterpreterRuntime::popframe_move_outgoing_args(JavaThread* thread, void* src_address, void* dest_address)) |
| 1250 if (src_address == dest_address) { | |
| 1251 return; | |
| 1252 } | |
| 1253 ResetNoHandleMark rnm; // In a LEAF entry. | |
| 1254 HandleMark hm; | |
| 1255 ResourceMark rm; | |
| 1256 frame fr = thread->last_frame(); | |
| 1257 assert(fr.is_interpreted_frame(), ""); | |
| 1258 jint bci = fr.interpreter_frame_bci(); | |
| 1259 methodHandle mh(thread, fr.interpreter_frame_method()); | |
| 2142 | 1260 Bytecode_invoke invoke(mh, bci); |
| 1261 ArgumentSizeComputer asc(invoke.signature()); | |
| 1262 int size_of_arguments = (asc.size() + (invoke.has_receiver() ? 1 : 0)); // receiver | |
|
1603
d93949c5bdcc
6730276: JDI_REGRESSION tests fail with "Error: count must be non-zero" error on x86
kvn
parents:
1602
diff
changeset
|
1263 Copy::conjoint_jbytes(src_address, dest_address, |
| 1506 | 1264 size_of_arguments * Interpreter::stackElementSize); |
| 0 | 1265 IRT_END |
| 1266 #endif | |
|
12010
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1267 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1268 #if INCLUDE_JVMTI |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1269 // This is a support of the JVMTI PopFrame interface. |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1270 // Make sure it is an invokestatic of a polymorphic intrinsic that has a member_name argument |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1271 // and return it as a vm_result so that it can be reloaded in the list of invokestatic parameters. |
|
20467
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1272 // The member_name argument is a saved reference (in local#0) to the member_name. |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1273 // For backward compatibility with some JDK versions (7, 8) it can also be a direct method handle. |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1274 // FIXME: remove DMH case after j.l.i.InvokerBytecodeGenerator code shape is updated. |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1275 IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address member_name, |
|
12010
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1276 Method* method, address bcp)) |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1277 Bytecodes::Code code = Bytecodes::code_at(method, bcp); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1278 if (code != Bytecodes::_invokestatic) { |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1279 return; |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1280 } |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1281 ConstantPool* cpool = method->constants(); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1282 int cp_index = Bytes::get_native_u2(bcp + 1) + ConstantPool::CPCACHE_INDEX_TAG; |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1283 Symbol* cname = cpool->klass_name_at(cpool->klass_ref_index_at(cp_index)); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1284 Symbol* mname = cpool->name_ref_at(cp_index); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1285 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1286 if (MethodHandles::has_member_arg(cname, mname)) { |
|
20467
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1287 oop member_name_oop = (oop) member_name; |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1288 if (java_lang_invoke_DirectMethodHandle::is_instance(member_name_oop)) { |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1289 // FIXME: remove after j.l.i.InvokerBytecodeGenerator code shape is updated. |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1290 member_name_oop = java_lang_invoke_DirectMethodHandle::member(member_name_oop); |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1291 } |
|
134f18d0174b
8034935: JSR 292 support for PopFrame has a fragile coupling with DirectMethodHandle
vlivanov
parents:
17937
diff
changeset
|
1292 thread->set_vm_result(member_name_oop); |
|
12010
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1293 } |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1294 IRT_END |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
10161
diff
changeset
|
1295 #endif // INCLUDE_JVMTI |