Mercurial > hg > truffle
annotate src/cpu/x86/vm/templateInterpreter_x86_64.cpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | bd3237e0e18d |
| children | 096c224171c4 2100bf712e2a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
2 * Copyright (c) 2003, 2013, 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:
1506
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
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:
1506
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
7199
cd3d6a6b95d9
8003240: x86: move MacroAssembler into separate file
twisti
parents:
6725
diff
changeset
|
26 #include "asm/macroAssembler.hpp" |
| 1972 | 27 #include "interpreter/bytecodeHistogram.hpp" |
| 28 #include "interpreter/interpreter.hpp" | |
| 29 #include "interpreter/interpreterGenerator.hpp" | |
| 30 #include "interpreter/interpreterRuntime.hpp" | |
| 31 #include "interpreter/templateTable.hpp" | |
| 32 #include "oops/arrayOop.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
33 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
34 #include "oops/method.hpp" |
| 1972 | 35 #include "oops/oop.inline.hpp" |
| 36 #include "prims/jvmtiExport.hpp" | |
| 37 #include "prims/jvmtiThreadState.hpp" | |
| 38 #include "runtime/arguments.hpp" | |
| 39 #include "runtime/deoptimization.hpp" | |
| 40 #include "runtime/frame.inline.hpp" | |
| 41 #include "runtime/sharedRuntime.hpp" | |
| 42 #include "runtime/stubRoutines.hpp" | |
| 43 #include "runtime/synchronizer.hpp" | |
| 44 #include "runtime/timer.hpp" | |
| 45 #include "runtime/vframeArray.hpp" | |
| 46 #include "utilities/debug.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7402
diff
changeset
|
47 #include "utilities/macros.hpp" |
| 0 | 48 |
| 49 #define __ _masm-> | |
| 50 | |
| 304 | 51 #ifndef CC_INTERP |
| 52 | |
| 0 | 53 const int method_offset = frame::interpreter_frame_method_offset * wordSize; |
| 54 const int bci_offset = frame::interpreter_frame_bcx_offset * wordSize; | |
| 55 const int locals_offset = frame::interpreter_frame_locals_offset * wordSize; | |
| 56 | |
| 57 //----------------------------------------------------------------------------- | |
| 58 | |
| 59 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() { | |
| 60 address entry = __ pc(); | |
| 61 | |
| 62 #ifdef ASSERT | |
| 63 { | |
| 64 Label L; | |
| 304 | 65 __ lea(rax, Address(rbp, |
| 66 frame::interpreter_frame_monitor_block_top_offset * | |
| 67 wordSize)); | |
| 68 __ cmpptr(rax, rsp); // rax = maximal rsp for current rbp (stack | |
| 69 // grows negative) | |
| 0 | 70 __ jcc(Assembler::aboveEqual, L); // check if frame is complete |
| 71 __ stop ("interpreter frame not set up"); | |
| 72 __ bind(L); | |
| 73 } | |
| 74 #endif // ASSERT | |
| 75 // Restore bcp under the assumption that the current frame is still | |
| 76 // interpreted | |
| 77 __ restore_bcp(); | |
| 78 | |
| 79 // expression stack must be empty before entering the VM if an | |
| 80 // exception happened | |
| 81 __ empty_expression_stack(); | |
| 82 // throw exception | |
| 83 __ call_VM(noreg, | |
| 84 CAST_FROM_FN_PTR(address, | |
| 85 InterpreterRuntime::throw_StackOverflowError)); | |
| 86 return entry; | |
| 87 } | |
| 88 | |
| 89 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler( | |
| 90 const char* name) { | |
| 91 address entry = __ pc(); | |
| 92 // expression stack must be empty before entering the VM if an | |
| 93 // exception happened | |
| 94 __ empty_expression_stack(); | |
| 95 // setup parameters | |
| 96 // ??? convention: expect aberrant index in register ebx | |
| 97 __ lea(c_rarg1, ExternalAddress((address)name)); | |
| 98 __ call_VM(noreg, | |
| 99 CAST_FROM_FN_PTR(address, | |
| 100 InterpreterRuntime:: | |
| 101 throw_ArrayIndexOutOfBoundsException), | |
| 102 c_rarg1, rbx); | |
| 103 return entry; | |
| 104 } | |
| 105 | |
| 106 address TemplateInterpreterGenerator::generate_ClassCastException_handler() { | |
| 107 address entry = __ pc(); | |
| 108 | |
| 109 // object is at TOS | |
| 304 | 110 __ pop(c_rarg1); |
| 0 | 111 |
| 112 // expression stack must be empty before entering the VM if an | |
| 113 // exception happened | |
| 114 __ empty_expression_stack(); | |
| 115 | |
| 116 __ call_VM(noreg, | |
| 117 CAST_FROM_FN_PTR(address, | |
| 118 InterpreterRuntime:: | |
| 119 throw_ClassCastException), | |
| 120 c_rarg1); | |
| 121 return entry; | |
| 122 } | |
| 123 | |
| 124 address TemplateInterpreterGenerator::generate_exception_handler_common( | |
| 125 const char* name, const char* message, bool pass_oop) { | |
| 126 assert(!pass_oop || message == NULL, "either oop or message but not both"); | |
| 127 address entry = __ pc(); | |
| 128 if (pass_oop) { | |
| 129 // object is at TOS | |
| 304 | 130 __ pop(c_rarg2); |
| 0 | 131 } |
| 132 // expression stack must be empty before entering the VM if an | |
| 133 // exception happened | |
| 134 __ empty_expression_stack(); | |
| 135 // setup parameters | |
| 136 __ lea(c_rarg1, ExternalAddress((address)name)); | |
| 137 if (pass_oop) { | |
| 138 __ call_VM(rax, CAST_FROM_FN_PTR(address, | |
| 139 InterpreterRuntime:: | |
| 140 create_klass_exception), | |
| 141 c_rarg1, c_rarg2); | |
| 142 } else { | |
| 143 // kind of lame ExternalAddress can't take NULL because | |
| 144 // external_word_Relocation will assert. | |
| 145 if (message != NULL) { | |
| 146 __ lea(c_rarg2, ExternalAddress((address)message)); | |
| 147 } else { | |
| 148 __ movptr(c_rarg2, NULL_WORD); | |
| 149 } | |
| 150 __ call_VM(rax, | |
| 151 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), | |
| 152 c_rarg1, c_rarg2); | |
| 153 } | |
| 154 // throw exception | |
| 155 __ jump(ExternalAddress(Interpreter::throw_exception_entry())); | |
| 156 return entry; | |
| 157 } | |
| 158 | |
| 159 | |
| 160 address TemplateInterpreterGenerator::generate_continuation_for(TosState state) { | |
| 161 address entry = __ pc(); | |
| 162 // NULL last_sp until next java call | |
| 304 | 163 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 164 __ dispatch_next(state); |
| 165 return entry; | |
| 166 } | |
| 167 | |
| 168 | |
|
13010
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
169 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) { |
| 0 | 170 address entry = __ pc(); |
| 171 | |
| 172 // Restore stack bottom in case i2c adjusted stack | |
| 304 | 173 __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); |
| 0 | 174 // and NULL it as marker that esp is now tos until next java call |
| 304 | 175 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 176 |
| 177 __ restore_bcp(); | |
| 178 __ restore_locals(); | |
| 304 | 179 |
|
12882
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
180 if (state == atos) { |
|
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
181 Register mdp = rbx; |
|
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
182 Register tmp = rcx; |
|
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
183 __ profile_return_type(mdp, rax, tmp); |
|
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
184 } |
|
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
12076
diff
changeset
|
185 |
|
13010
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
186 const Register cache = rbx; |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
187 const Register index = rcx; |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
188 __ get_cache_and_index_at_bcp(cache, index, 1, index_size); |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
189 |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
190 const Register flags = cache; |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
191 __ movl(flags, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset())); |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
192 __ andl(flags, ConstantPoolCacheEntry::parameter_size_mask); |
|
bd3237e0e18d
8026328: Setting a breakpoint on invokedynamic crashes the JVM
twisti
parents:
12962
diff
changeset
|
193 __ lea(rsp, Address(rsp, flags, Interpreter::stackElementScale())); |
| 0 | 194 __ dispatch_next(state, step); |
| 1108 | 195 |
| 0 | 196 return entry; |
| 197 } | |
| 198 | |
| 199 | |
| 200 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, | |
| 201 int step) { | |
| 202 address entry = __ pc(); | |
| 203 // NULL last_sp until next java call | |
| 304 | 204 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 205 __ restore_bcp(); |
| 206 __ restore_locals(); | |
| 207 // handle exceptions | |
| 208 { | |
| 209 Label L; | |
| 304 | 210 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD); |
| 0 | 211 __ jcc(Assembler::zero, L); |
| 212 __ call_VM(noreg, | |
| 213 CAST_FROM_FN_PTR(address, | |
| 214 InterpreterRuntime::throw_pending_exception)); | |
| 215 __ should_not_reach_here(); | |
| 216 __ bind(L); | |
| 217 } | |
| 218 __ dispatch_next(state, step); | |
| 219 return entry; | |
| 220 } | |
| 221 | |
| 222 int AbstractInterpreter::BasicType_as_index(BasicType type) { | |
| 223 int i = 0; | |
| 224 switch (type) { | |
| 225 case T_BOOLEAN: i = 0; break; | |
| 226 case T_CHAR : i = 1; break; | |
| 227 case T_BYTE : i = 2; break; | |
| 228 case T_SHORT : i = 3; break; | |
| 229 case T_INT : i = 4; break; | |
| 230 case T_LONG : i = 5; break; | |
| 231 case T_VOID : i = 6; break; | |
| 232 case T_FLOAT : i = 7; break; | |
| 233 case T_DOUBLE : i = 8; break; | |
| 234 case T_OBJECT : i = 9; break; | |
| 235 case T_ARRAY : i = 9; break; | |
| 236 default : ShouldNotReachHere(); | |
| 237 } | |
| 238 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, | |
| 239 "index out of bounds"); | |
| 240 return i; | |
| 241 } | |
| 242 | |
| 243 | |
| 244 address TemplateInterpreterGenerator::generate_result_handler_for( | |
| 245 BasicType type) { | |
| 246 address entry = __ pc(); | |
| 247 switch (type) { | |
| 248 case T_BOOLEAN: __ c2bool(rax); break; | |
| 249 case T_CHAR : __ movzwl(rax, rax); break; | |
| 250 case T_BYTE : __ sign_extend_byte(rax); break; | |
| 251 case T_SHORT : __ sign_extend_short(rax); break; | |
| 252 case T_INT : /* nothing to do */ break; | |
| 253 case T_LONG : /* nothing to do */ break; | |
| 254 case T_VOID : /* nothing to do */ break; | |
| 255 case T_FLOAT : /* nothing to do */ break; | |
| 256 case T_DOUBLE : /* nothing to do */ break; | |
| 257 case T_OBJECT : | |
| 258 // retrieve result from frame | |
| 304 | 259 __ movptr(rax, Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize)); |
| 0 | 260 // and verify it |
| 261 __ verify_oop(rax); | |
| 262 break; | |
| 263 default : ShouldNotReachHere(); | |
| 264 } | |
| 265 __ ret(0); // return from result handler | |
| 266 return entry; | |
| 267 } | |
| 268 | |
| 269 address TemplateInterpreterGenerator::generate_safept_entry_for( | |
| 270 TosState state, | |
| 271 address runtime_entry) { | |
| 272 address entry = __ pc(); | |
| 273 __ push(state); | |
| 274 __ call_VM(noreg, runtime_entry); | |
| 275 __ dispatch_via(vtos, Interpreter::_normal_table.table_for(vtos)); | |
| 276 return entry; | |
| 277 } | |
| 278 | |
| 279 | |
| 280 | |
| 281 // Helpers for commoning out cases in the various type of method entries. | |
| 282 // | |
| 283 | |
| 284 | |
| 285 // increment invocation count & check for overflow | |
| 286 // | |
| 287 // Note: checking for negative value instead of overflow | |
| 288 // so we have a 'sticky' overflow test | |
| 289 // | |
| 290 // rbx: method | |
| 291 // ecx: invocation counter | |
| 292 // | |
| 293 void InterpreterGenerator::generate_counter_incr( | |
| 294 Label* overflow, | |
| 295 Label* profile_method, | |
| 296 Label* profile_method_continue) { | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
297 Label done; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
298 // Note: In tiered we increment either counters in Method* or in MDO depending if we're profiling or not. |
| 1783 | 299 if (TieredCompilation) { |
| 300 int increment = InvocationCounter::count_increment; | |
| 301 int mask = ((1 << Tier0InvokeNotifyFreqLog) - 1) << InvocationCounter::count_shift; | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
302 Label no_mdo; |
| 1783 | 303 if (ProfileInterpreter) { |
| 304 // Are we profiling? | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
305 __ movptr(rax, Address(rbx, Method::method_data_offset())); |
| 1783 | 306 __ testptr(rax, rax); |
| 307 __ jccb(Assembler::zero, no_mdo); | |
| 308 // Increment counter in the MDO | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
309 const Address mdo_invocation_counter(rax, in_bytes(MethodData::invocation_counter_offset()) + |
| 1783 | 310 in_bytes(InvocationCounter::counter_offset())); |
| 311 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, rcx, false, Assembler::zero, overflow); | |
|
10141
47766e2d2527
8013041: guarantee(this->is8bit(imm8)) failed: Short forward jump exceeds 8-bit offset.
jiangli
parents:
10105
diff
changeset
|
312 __ jmp(done); |
| 1783 | 313 } |
| 314 __ bind(no_mdo); | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
315 // Increment counter in MethodCounters |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
316 const Address invocation_counter(rax, |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
317 MethodCounters::invocation_counter_offset() + |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
318 InvocationCounter::counter_offset()); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
319 __ get_method_counters(rbx, rax, done); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
320 __ increment_mask_and_jump(invocation_counter, increment, mask, rcx, |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
321 false, Assembler::zero, overflow); |
| 1783 | 322 __ bind(done); |
| 323 } else { | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
324 const Address backedge_counter(rax, |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
325 MethodCounters::backedge_counter_offset() + |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
326 InvocationCounter::counter_offset()); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
327 const Address invocation_counter(rax, |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
328 MethodCounters::invocation_counter_offset() + |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
329 InvocationCounter::counter_offset()); |
| 0 | 330 |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
331 __ get_method_counters(rbx, rax, done); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
332 |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
333 if (ProfileInterpreter) { |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
334 __ incrementl(Address(rax, |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
335 MethodCounters::interpreter_invocation_counter_offset())); |
| 1783 | 336 } |
| 337 // Update standard invocation counters | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
338 __ movl(rcx, invocation_counter); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
339 __ incrementl(rcx, InvocationCounter::count_increment); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
340 __ movl(invocation_counter, rcx); // save invocation count |
| 0 | 341 |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
342 __ movl(rax, backedge_counter); // load backedge counter |
| 1783 | 343 __ andl(rax, InvocationCounter::count_mask_value); // mask out the status bits |
| 0 | 344 |
| 1783 | 345 __ addl(rcx, rax); // add both counters |
| 0 | 346 |
| 1783 | 347 // profile_method is non-null only for interpreted method so |
| 348 // profile_method != NULL == !native_call | |
| 349 | |
| 350 if (ProfileInterpreter && profile_method != NULL) { | |
| 351 // Test to see if we should create a method data oop | |
| 352 __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterProfileLimit)); | |
| 353 __ jcc(Assembler::less, *profile_method_continue); | |
| 0 | 354 |
| 1783 | 355 // if no method data exists, go to profile_method |
| 356 __ test_method_data_pointer(rax, *profile_method); | |
| 357 } | |
| 358 | |
| 359 __ cmp32(rcx, ExternalAddress((address)&InvocationCounter::InterpreterInvocationLimit)); | |
| 360 __ jcc(Assembler::aboveEqual, *overflow); | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8873
diff
changeset
|
361 __ bind(done); |
| 0 | 362 } |
| 363 } | |
| 364 | |
| 365 void InterpreterGenerator::generate_counter_overflow(Label* do_continue) { | |
| 366 | |
| 367 // Asm interpreter on entry | |
| 368 // r14 - locals | |
| 369 // r13 - bcp | |
| 370 // rbx - method | |
| 371 // edx - cpool --- DOES NOT APPEAR TO BE TRUE | |
| 372 // rbp - interpreter frame | |
| 373 | |
| 374 // On return (i.e. jump to entry_point) [ back to invocation of interpreter ] | |
| 375 // Everything as it was on entry | |
| 376 // rdx is not restored. Doesn't appear to really be set. | |
| 377 | |
| 378 // InterpreterRuntime::frequency_counter_overflow takes two | |
| 379 // arguments, the first (thread) is passed by call_VM, the second | |
| 380 // indicates if the counter overflow occurs at a backwards branch | |
| 381 // (NULL bcp). We pass zero for it. The call returns the address | |
| 382 // of the verified entry point for the method or NULL if the | |
| 383 // compilation did not complete (either went background or bailed | |
| 384 // out). | |
| 385 __ movl(c_rarg1, 0); | |
| 386 __ call_VM(noreg, | |
| 387 CAST_FROM_FN_PTR(address, | |
| 388 InterpreterRuntime::frequency_counter_overflow), | |
| 389 c_rarg1); | |
| 390 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
391 __ movptr(rbx, Address(rbp, method_offset)); // restore Method* |
| 0 | 392 // Preserve invariant that r13/r14 contain bcp/locals of sender frame |
| 393 // and jump to the interpreted entry. | |
| 394 __ jmp(*do_continue, relocInfo::none); | |
| 395 } | |
| 396 | |
| 397 // See if we've got enough room on the stack for locals plus overhead. | |
| 398 // The expression stack grows down incrementally, so the normal guard | |
| 399 // page mechanism will work for that. | |
| 400 // | |
| 401 // NOTE: Since the additional locals are also always pushed (wasn't | |
| 402 // obvious in generate_method_entry) so the guard should work for them | |
| 403 // too. | |
| 404 // | |
| 405 // Args: | |
| 406 // rdx: number of additional locals this frame needs (what we must check) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
407 // rbx: Method* |
| 0 | 408 // |
| 409 // Kills: | |
| 410 // rax | |
| 411 void InterpreterGenerator::generate_stack_overflow_check(void) { | |
| 412 | |
| 413 // monitor entry size: see picture of stack set | |
| 414 // (generate_method_entry) and frame_amd64.hpp | |
| 415 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 416 | |
| 417 // total overhead size: entry_size + (saved rbp through expr stack | |
| 418 // bottom). be sure to change this if you add/subtract anything | |
| 419 // to/from the overhead area | |
| 420 const int overhead_size = | |
| 421 -(frame::interpreter_frame_initial_sp_offset * wordSize) + entry_size; | |
| 422 | |
| 423 const int page_size = os::vm_page_size(); | |
| 424 | |
| 425 Label after_frame_check; | |
| 426 | |
| 427 // see if the frame is greater than one page in size. If so, | |
| 428 // then we need to verify there is enough stack space remaining | |
| 429 // for the additional locals. | |
| 1506 | 430 __ cmpl(rdx, (page_size - overhead_size) / Interpreter::stackElementSize); |
| 0 | 431 __ jcc(Assembler::belowEqual, after_frame_check); |
| 432 | |
| 433 // compute rsp as if this were going to be the last frame on | |
| 434 // the stack before the red zone | |
| 435 | |
| 436 const Address stack_base(r15_thread, Thread::stack_base_offset()); | |
| 437 const Address stack_size(r15_thread, Thread::stack_size_offset()); | |
| 438 | |
| 439 // locals + overhead, in bytes | |
| 304 | 440 __ mov(rax, rdx); |
| 1506 | 441 __ shlptr(rax, Interpreter::logStackElementSize); // 2 slots per parameter. |
| 304 | 442 __ addptr(rax, overhead_size); |
| 0 | 443 |
| 444 #ifdef ASSERT | |
| 445 Label stack_base_okay, stack_size_okay; | |
| 446 // verify that thread stack base is non-zero | |
| 304 | 447 __ cmpptr(stack_base, (int32_t)NULL_WORD); |
| 0 | 448 __ jcc(Assembler::notEqual, stack_base_okay); |
| 449 __ stop("stack base is zero"); | |
| 450 __ bind(stack_base_okay); | |
| 451 // verify that thread stack size is non-zero | |
| 304 | 452 __ cmpptr(stack_size, 0); |
| 0 | 453 __ jcc(Assembler::notEqual, stack_size_okay); |
| 454 __ stop("stack size is zero"); | |
| 455 __ bind(stack_size_okay); | |
| 456 #endif | |
| 457 | |
| 458 // Add stack base to locals and subtract stack size | |
| 304 | 459 __ addptr(rax, stack_base); |
| 460 __ subptr(rax, stack_size); | |
| 0 | 461 |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
462 // Use the maximum number of pages we might bang. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
463 const int max_pages = StackShadowPages > (StackRedPages+StackYellowPages) ? StackShadowPages : |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
464 (StackRedPages+StackYellowPages); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
465 |
| 0 | 466 // add in the red and yellow zone sizes |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
467 __ addptr(rax, max_pages * page_size); |
| 0 | 468 |
| 469 // check against the current stack bottom | |
| 304 | 470 __ cmpptr(rsp, rax); |
| 0 | 471 __ jcc(Assembler::above, after_frame_check); |
| 472 | |
| 4743 | 473 // Restore sender's sp as SP. This is necessary if the sender's |
| 474 // frame is an extended compiled frame (see gen_c2i_adapter()) | |
| 475 // and safer anyway in case of JSR292 adaptations. | |
| 476 | |
| 477 __ pop(rax); // return address must be moved if SP is changed | |
| 478 __ mov(rsp, r13); | |
| 479 __ push(rax); | |
| 480 | |
| 481 // Note: the restored frame is not necessarily interpreted. | |
| 482 // Use the shared runtime version of the StackOverflowError. | |
| 483 assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "stub not yet generated"); | |
| 484 __ jump(ExternalAddress(StubRoutines::throw_StackOverflowError_entry())); | |
| 0 | 485 |
| 486 // all done with frame size check | |
| 487 __ bind(after_frame_check); | |
| 488 } | |
| 489 | |
| 490 // Allocate monitor and lock method (asm interpreter) | |
| 491 // | |
| 492 // Args: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
493 // rbx: Method* |
| 0 | 494 // r14: locals |
| 495 // | |
| 496 // Kills: | |
| 497 // rax | |
| 498 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, ...(param regs) | |
| 499 // rscratch1, rscratch2 (scratch regs) | |
| 500 void InterpreterGenerator::lock_method(void) { | |
| 501 // synchronize method | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
502 const Address access_flags(rbx, Method::access_flags_offset()); |
| 0 | 503 const Address monitor_block_top( |
| 504 rbp, | |
| 505 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 506 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; | |
| 507 | |
| 508 #ifdef ASSERT | |
| 509 { | |
| 510 Label L; | |
| 511 __ movl(rax, access_flags); | |
| 512 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 513 __ jcc(Assembler::notZero, L); | |
| 514 __ stop("method doesn't need synchronization"); | |
| 515 __ bind(L); | |
| 516 } | |
| 517 #endif // ASSERT | |
| 518 | |
| 519 // get synchronization object | |
| 520 { | |
|
4762
069ab3f976d3
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
4042
diff
changeset
|
521 const int mirror_offset = in_bytes(Klass::java_mirror_offset()); |
| 0 | 522 Label done; |
| 523 __ movl(rax, access_flags); | |
| 524 __ testl(rax, JVM_ACC_STATIC); | |
| 525 // get receiver (assume this is frequent case) | |
| 304 | 526 __ movptr(rax, Address(r14, Interpreter::local_offset_in_bytes(0))); |
| 0 | 527 __ jcc(Assembler::zero, done); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
528 __ movptr(rax, Address(rbx, Method::const_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
529 __ movptr(rax, Address(rax, ConstMethod::constants_offset())); |
| 304 | 530 __ movptr(rax, Address(rax, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
531 ConstantPool::pool_holder_offset_in_bytes())); |
| 304 | 532 __ movptr(rax, Address(rax, mirror_offset)); |
| 0 | 533 |
| 534 #ifdef ASSERT | |
| 535 { | |
| 536 Label L; | |
| 304 | 537 __ testptr(rax, rax); |
| 0 | 538 __ jcc(Assembler::notZero, L); |
| 539 __ stop("synchronization object is NULL"); | |
| 540 __ bind(L); | |
| 541 } | |
| 542 #endif // ASSERT | |
| 543 | |
| 544 __ bind(done); | |
| 545 } | |
| 546 | |
| 547 // add space for monitor & lock | |
| 304 | 548 __ subptr(rsp, entry_size); // add space for a monitor entry |
| 549 __ movptr(monitor_block_top, rsp); // set new monitor block top | |
| 0 | 550 // store object |
| 304 | 551 __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax); |
| 552 __ movptr(c_rarg1, rsp); // object address | |
| 0 | 553 __ lock_object(c_rarg1); |
| 554 } | |
| 555 | |
| 556 // Generate a fixed interpreter frame. This is identical setup for | |
| 557 // interpreted methods and for native methods hence the shared code. | |
| 558 // | |
| 559 // Args: | |
| 560 // rax: return address | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
561 // rbx: Method* |
| 0 | 562 // r14: pointer to locals |
| 563 // r13: sender sp | |
| 564 // rdx: cp cache | |
| 565 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) { | |
| 566 // initialize fixed part of activation frame | |
| 304 | 567 __ push(rax); // save return address |
| 0 | 568 __ enter(); // save old & set new rbp |
| 304 | 569 __ push(r13); // set sender sp |
| 570 __ push((int)NULL_WORD); // leave last_sp as null | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
571 __ movptr(r13, Address(rbx, Method::const_offset())); // get ConstMethod* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
572 __ lea(r13, Address(r13, ConstMethod::codes_offset())); // get codebase |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
573 __ push(rbx); // save Method* |
| 0 | 574 if (ProfileInterpreter) { |
| 575 Label method_data_continue; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
576 __ movptr(rdx, Address(rbx, in_bytes(Method::method_data_offset()))); |
| 304 | 577 __ testptr(rdx, rdx); |
| 0 | 578 __ jcc(Assembler::zero, method_data_continue); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
579 __ addptr(rdx, in_bytes(MethodData::data_offset())); |
| 0 | 580 __ bind(method_data_continue); |
| 304 | 581 __ push(rdx); // set the mdp (method data pointer) |
| 0 | 582 } else { |
| 304 | 583 __ push(0); |
| 0 | 584 } |
| 585 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
586 __ movptr(rdx, Address(rbx, Method::const_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
587 __ movptr(rdx, Address(rdx, ConstMethod::constants_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
588 __ movptr(rdx, Address(rdx, ConstantPool::cache_offset_in_bytes())); |
| 304 | 589 __ push(rdx); // set constant pool cache |
| 590 __ push(r14); // set locals pointer | |
| 0 | 591 if (native_call) { |
| 304 | 592 __ push(0); // no bcp |
| 0 | 593 } else { |
| 304 | 594 __ push(r13); // set bcp |
| 0 | 595 } |
| 304 | 596 __ push(0); // reserve word for pointer to expression stack bottom |
| 597 __ movptr(Address(rsp, 0), rsp); // set expression stack bottom | |
| 0 | 598 } |
| 599 | |
| 600 // End of helpers | |
| 601 | |
| 304 | 602 // Various method entries |
| 603 //------------------------------------------------------------------------------------------------------------------------ | |
| 604 // | |
| 605 // | |
| 606 | |
| 607 // Call an accessor method (assuming it is resolved, otherwise drop | |
| 608 // into vanilla (slow path) entry | |
| 609 address InterpreterGenerator::generate_accessor_entry(void) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
610 // rbx: Method* |
| 304 | 611 |
| 612 // r13: senderSP must preserver for slow path, set SP to it on fast path | |
| 613 | |
| 614 address entry_point = __ pc(); | |
| 615 Label xreturn_path; | |
| 616 | |
| 617 // do fastpath for resolved accessor methods | |
| 618 if (UseFastAccessorMethods) { | |
| 619 // Code: _aload_0, _(i|a)getfield, _(i|a)return or any rewrites | |
| 620 // thereof; parameter size = 1 | |
| 621 // Note: We can only use this code if the getfield has been resolved | |
| 622 // and if we don't have a null-pointer exception => check for | |
| 623 // these conditions first and use slow path if necessary. | |
| 624 Label slow_path; | |
| 625 // If we need a safepoint check, generate full interpreter entry. | |
| 626 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), | |
| 627 SafepointSynchronize::_not_synchronized); | |
| 628 | |
| 629 __ jcc(Assembler::notEqual, slow_path); | |
| 630 // rbx: method | |
| 631 __ movptr(rax, Address(rsp, wordSize)); | |
| 632 | |
| 633 // check if local 0 != NULL and read field | |
| 634 __ testptr(rax, rax); | |
| 635 __ jcc(Assembler::zero, slow_path); | |
| 636 | |
| 637 // read first instruction word and extract bytecode @ 1 and index @ 2 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
638 __ movptr(rdx, Address(rbx, Method::const_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
639 __ movptr(rdi, Address(rdx, ConstMethod::constants_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
640 __ movl(rdx, Address(rdx, ConstMethod::codes_offset())); |
| 304 | 641 // Shift codes right to get the index on the right. |
| 642 // The bytecode fetched looks like <index><0xb4><0x2a> | |
| 643 __ shrl(rdx, 2 * BitsPerByte); | |
| 644 __ shll(rdx, exact_log2(in_words(ConstantPoolCacheEntry::size()))); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
645 __ movptr(rdi, Address(rdi, ConstantPool::cache_offset_in_bytes())); |
| 304 | 646 |
| 647 // rax: local 0 | |
| 648 // rbx: method | |
| 649 // rdx: constant pool cache index | |
| 650 // rdi: constant pool cache | |
| 651 | |
| 652 // check if getfield has been resolved and read constant pool cache entry | |
| 653 // check the validity of the cache entry by testing whether _indices field | |
| 654 // contains Bytecode::_getfield in b1 byte. | |
| 655 assert(in_words(ConstantPoolCacheEntry::size()) == 4, | |
| 656 "adjust shift below"); | |
| 657 __ movl(rcx, | |
| 658 Address(rdi, | |
| 659 rdx, | |
| 660 Address::times_8, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
661 ConstantPoolCache::base_offset() + |
| 304 | 662 ConstantPoolCacheEntry::indices_offset())); |
| 663 __ shrl(rcx, 2 * BitsPerByte); | |
| 664 __ andl(rcx, 0xFF); | |
| 665 __ cmpl(rcx, Bytecodes::_getfield); | |
| 666 __ jcc(Assembler::notEqual, slow_path); | |
| 667 | |
| 668 // Note: constant pool entry is not valid before bytecode is resolved | |
| 669 __ movptr(rcx, | |
| 670 Address(rdi, | |
| 671 rdx, | |
| 672 Address::times_8, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
673 ConstantPoolCache::base_offset() + |
| 304 | 674 ConstantPoolCacheEntry::f2_offset())); |
| 675 // edx: flags | |
| 676 __ movl(rdx, | |
| 677 Address(rdi, | |
| 678 rdx, | |
| 679 Address::times_8, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
680 ConstantPoolCache::base_offset() + |
| 304 | 681 ConstantPoolCacheEntry::flags_offset())); |
| 682 | |
| 683 Label notObj, notInt, notByte, notShort; | |
| 684 const Address field_address(rax, rcx, Address::times_1); | |
| 685 | |
| 686 // Need to differentiate between igetfield, agetfield, bgetfield etc. | |
| 687 // because they are different sizes. | |
| 688 // Use the type from the constant pool cache | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
689 __ shrl(rdx, ConstantPoolCacheEntry::tos_state_shift); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
690 // Make sure we don't need to mask edx after the above shift |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
691 ConstantPoolCacheEntry::verify_tos_state_shift(); |
| 304 | 692 |
| 693 __ cmpl(rdx, atos); | |
| 694 __ jcc(Assembler::notEqual, notObj); | |
| 695 // atos | |
| 696 __ load_heap_oop(rax, field_address); | |
| 697 __ jmp(xreturn_path); | |
| 698 | |
| 699 __ bind(notObj); | |
| 700 __ cmpl(rdx, itos); | |
| 701 __ jcc(Assembler::notEqual, notInt); | |
| 702 // itos | |
| 703 __ movl(rax, field_address); | |
| 704 __ jmp(xreturn_path); | |
| 705 | |
| 706 __ bind(notInt); | |
| 707 __ cmpl(rdx, btos); | |
| 708 __ jcc(Assembler::notEqual, notByte); | |
| 709 // btos | |
| 710 __ load_signed_byte(rax, field_address); | |
| 711 __ jmp(xreturn_path); | |
| 712 | |
| 713 __ bind(notByte); | |
| 714 __ cmpl(rdx, stos); | |
| 715 __ jcc(Assembler::notEqual, notShort); | |
| 716 // stos | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
717 __ load_signed_short(rax, field_address); |
| 304 | 718 __ jmp(xreturn_path); |
| 719 | |
| 720 __ bind(notShort); | |
| 721 #ifdef ASSERT | |
| 722 Label okay; | |
| 723 __ cmpl(rdx, ctos); | |
| 724 __ jcc(Assembler::equal, okay); | |
| 725 __ stop("what type is this?"); | |
| 726 __ bind(okay); | |
| 727 #endif | |
| 728 // ctos | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
729 __ load_unsigned_short(rax, field_address); |
| 304 | 730 |
| 731 __ bind(xreturn_path); | |
| 732 | |
| 733 // _ireturn/_areturn | |
| 734 __ pop(rdi); | |
| 735 __ mov(rsp, r13); | |
| 736 __ jmp(rdi); | |
| 737 __ ret(0); | |
| 738 | |
| 739 // generate a vanilla interpreter entry as the slow path | |
| 740 __ bind(slow_path); | |
| 741 (void) generate_normal_entry(false); | |
| 742 } else { | |
| 743 (void) generate_normal_entry(false); | |
| 744 } | |
| 745 | |
| 746 return entry_point; | |
| 747 } | |
| 748 | |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
749 // Method entry for java.lang.ref.Reference.get. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
750 address InterpreterGenerator::generate_Reference_get_entry(void) { |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7402
diff
changeset
|
751 #if INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
752 // Code: _aload_0, _getfield, _areturn |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
753 // parameter size = 1 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
754 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
755 // The code that gets generated by this routine is split into 2 parts: |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
756 // 1. The "intrinsified" code for G1 (or any SATB based GC), |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
757 // 2. The slow path - which is an expansion of the regular method entry. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
758 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
759 // Notes:- |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
760 // * In the G1 code we do not check whether we need to block for |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
761 // a safepoint. If G1 is enabled then we must execute the specialized |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
762 // code for Reference.get (except when the Reference object is null) |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
763 // so that we can log the value in the referent field with an SATB |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
764 // update buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
765 // If the code for the getfield template is modified so that the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
766 // G1 pre-barrier code is executed when the current method is |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
767 // Reference.get() then going through the normal method entry |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
768 // will be fine. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
769 // * The G1 code can, however, check the receiver object (the instance |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
770 // of java.lang.Reference) and jump to the slow path if null. If the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
771 // Reference object is null then we obviously cannot fetch the referent |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
772 // and so we don't need to call the G1 pre-barrier. Thus we can use the |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
773 // regular method entry code to generate the NPE. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
774 // |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
775 // This code is based on generate_accessor_enty. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
776 // |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
777 // rbx: Method* |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
778 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
779 // r13: senderSP must preserve for slow path, set SP to it on fast path |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
780 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
781 address entry = __ pc(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
782 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
783 const int referent_offset = java_lang_ref_Reference::referent_offset; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
784 guarantee(referent_offset > 0, "referent offset not initialized"); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
785 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
786 if (UseG1GC) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
787 Label slow_path; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
788 // rbx: method |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
789 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
790 // Check if local 0 != NULL |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
791 // If the receiver is null then it is OK to jump to the slow path. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
792 __ movptr(rax, Address(rsp, wordSize)); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
793 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
794 __ testptr(rax, rax); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
795 __ jcc(Assembler::zero, slow_path); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
796 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
797 // rax: local 0 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
798 // rbx: method (but can be used as scratch now) |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
799 // rdx: scratch |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
800 // rdi: scratch |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
801 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
802 // Generate the G1 pre-barrier code to log the value of |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
803 // the referent field in an SATB buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
804 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
805 // Load the value of the referent field. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
806 const Address field_address(rax, referent_offset); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
807 __ load_heap_oop(rax, field_address); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
808 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
809 // Generate the G1 pre-barrier code to log the value of |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
810 // the referent field in an SATB buffer. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
811 __ g1_write_barrier_pre(noreg /* obj */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
812 rax /* pre_val */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
813 r15_thread /* thread */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
814 rbx /* tmp */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
815 true /* tosca_live */, |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
816 true /* expand_call */); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
817 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
818 // _areturn |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
819 __ pop(rdi); // get return address |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
820 __ mov(rsp, r13); // set sp to sender sp |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
821 __ jmp(rdi); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
822 __ ret(0); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
823 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
824 // generate a vanilla interpreter entry as the slow path |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
825 __ bind(slow_path); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
826 (void) generate_normal_entry(false); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
827 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
828 return entry; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
829 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7402
diff
changeset
|
830 #endif // INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
831 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
832 // If G1 is not enabled then attempt to go through the accessor entry point |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
833 // Reference.get is an accessor |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
834 return generate_accessor_entry(); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
835 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
836 |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
837 /** |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
838 * Method entry for static native methods: |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
839 * int java.util.zip.CRC32.update(int crc, int b) |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
840 */ |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
841 address InterpreterGenerator::generate_CRC32_update_entry() { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
842 if (UseCRC32Intrinsics) { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
843 address entry = __ pc(); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
844 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
845 // rbx,: Method* |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
846 // r13: senderSP must preserved for slow path, set SP to it on fast path |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
847 // c_rarg0: scratch (rdi on non-Win64, rcx on Win64) |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
848 // c_rarg1: scratch (rsi on non-Win64, rdx on Win64) |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
849 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
850 Label slow_path; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
851 // If we need a safepoint check, generate full interpreter entry. |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
852 ExternalAddress state(SafepointSynchronize::address_of_state()); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
853 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
854 SafepointSynchronize::_not_synchronized); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
855 __ jcc(Assembler::notEqual, slow_path); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
856 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
857 // We don't generate local frame and don't align stack because |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
858 // we call stub code and there is no safepoint on this path. |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
859 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
860 // Load parameters |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
861 const Register crc = rax; // crc |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
862 const Register val = c_rarg0; // source java byte value |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
863 const Register tbl = c_rarg1; // scratch |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
864 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
865 // Arguments are reversed on java expression stack |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
866 __ movl(val, Address(rsp, wordSize)); // byte value |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
867 __ movl(crc, Address(rsp, 2*wordSize)); // Initial CRC |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
868 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
869 __ lea(tbl, ExternalAddress(StubRoutines::crc_table_addr())); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
870 __ notl(crc); // ~crc |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
871 __ update_byte_crc32(crc, val, tbl); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
872 __ notl(crc); // ~crc |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
873 // result in rax |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
874 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
875 // _areturn |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
876 __ pop(rdi); // get return address |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
877 __ mov(rsp, r13); // set sp to sender sp |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
878 __ jmp(rdi); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
879 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
880 // generate a vanilla native entry as the slow path |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
881 __ bind(slow_path); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
882 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
883 (void) generate_native_entry(false); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
884 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
885 return entry; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
886 } |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
887 return generate_native_entry(false); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
888 } |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
889 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
890 /** |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
891 * Method entry for static native methods: |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
892 * int java.util.zip.CRC32.updateBytes(int crc, byte[] b, int off, int len) |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
893 * int java.util.zip.CRC32.updateByteBuffer(int crc, long buf, int off, int len) |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
894 */ |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
895 address InterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
896 if (UseCRC32Intrinsics) { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
897 address entry = __ pc(); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
898 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
899 // rbx,: Method* |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
900 // r13: senderSP must preserved for slow path, set SP to it on fast path |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
901 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
902 Label slow_path; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
903 // If we need a safepoint check, generate full interpreter entry. |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
904 ExternalAddress state(SafepointSynchronize::address_of_state()); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
905 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
906 SafepointSynchronize::_not_synchronized); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
907 __ jcc(Assembler::notEqual, slow_path); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
908 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
909 // We don't generate local frame and don't align stack because |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
910 // we call stub code and there is no safepoint on this path. |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
911 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
912 // Load parameters |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
913 const Register crc = c_rarg0; // crc |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
914 const Register buf = c_rarg1; // source java byte array address |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
915 const Register len = c_rarg2; // length |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
916 const Register off = len; // offset (never overlaps with 'len') |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
917 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
918 // Arguments are reversed on java expression stack |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
919 // Calculate address of start element |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
920 if (kind == Interpreter::java_util_zip_CRC32_updateByteBuffer) { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
921 __ movptr(buf, Address(rsp, 3*wordSize)); // long buf |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
922 __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
923 __ addq(buf, off); // + offset |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
924 __ movl(crc, Address(rsp, 5*wordSize)); // Initial CRC |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
925 } else { |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
926 __ movptr(buf, Address(rsp, 3*wordSize)); // byte[] array |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
927 __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
928 __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
929 __ addq(buf, off); // + offset |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
930 __ movl(crc, Address(rsp, 4*wordSize)); // Initial CRC |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
931 } |
|
12070
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
932 // Can now load 'len' since we're finished with 'off' |
|
afbe18ae0905
8022441: Bad code generated for certain interpreted CRC intrinsics, 2 cases
bharadwaj
parents:
11080
diff
changeset
|
933 __ movl(len, Address(rsp, wordSize)); // Length |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
934 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
935 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, StubRoutines::updateBytesCRC32()), crc, buf, len); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
936 // result in rax |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
937 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
938 // _areturn |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
939 __ pop(rdi); // get return address |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
940 __ mov(rsp, r13); // set sp to sender sp |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
941 __ jmp(rdi); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
942 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
943 // generate a vanilla native entry as the slow path |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
944 __ bind(slow_path); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
945 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
946 (void) generate_native_entry(false); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
947 |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
948 return entry; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
949 } |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
950 return generate_native_entry(false); |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
951 } |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
952 |
| 0 | 953 // Interpreter stub for calling a native method. (asm interpreter) |
| 954 // This sets up a somewhat different looking stack for calling the | |
| 955 // native method than the typical interpreter frame setup. | |
| 956 address InterpreterGenerator::generate_native_entry(bool synchronized) { | |
| 957 // determine code generation flags | |
| 958 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 959 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
960 // rbx: Method* |
| 0 | 961 // r13: sender sp |
| 962 | |
| 963 address entry_point = __ pc(); | |
| 964 | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
965 const Address constMethod (rbx, Method::const_offset()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
966 const Address access_flags (rbx, Method::access_flags_offset()); |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
967 const Address size_of_parameters(rcx, ConstMethod:: |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
968 size_of_parameters_offset()); |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
969 |
| 0 | 970 |
| 971 // get parameter size (always needed) | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
972 __ movptr(rcx, constMethod); |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
973 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 974 |
| 975 // native calls don't need the stack size check since they have no | |
| 976 // expression stack and the arguments are already on the stack and | |
| 977 // we only add a handful of words to the stack | |
| 978 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
979 // rbx: Method* |
| 0 | 980 // rcx: size of parameters |
| 981 // r13: sender sp | |
| 304 | 982 __ pop(rax); // get return address |
| 0 | 983 |
| 984 // for natives the size of locals is zero | |
| 985 | |
| 986 // compute beginning of parameters (r14) | |
| 304 | 987 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 988 |
| 989 // add 2 zero-initialized slots for native calls | |
| 990 // initialize result_handler slot | |
| 304 | 991 __ push((int) NULL_WORD); |
| 0 | 992 // slot for oop temp |
| 993 // (static native method holder mirror/jni oop result) | |
| 304 | 994 __ push((int) NULL_WORD); |
| 0 | 995 |
| 996 // initialize fixed part of activation frame | |
| 997 generate_fixed_frame(true); | |
| 998 | |
| 999 // make sure method is native & not abstract | |
| 1000 #ifdef ASSERT | |
| 1001 __ movl(rax, access_flags); | |
| 1002 { | |
| 1003 Label L; | |
| 1004 __ testl(rax, JVM_ACC_NATIVE); | |
| 1005 __ jcc(Assembler::notZero, L); | |
| 1006 __ stop("tried to execute non-native method as native"); | |
| 1007 __ bind(L); | |
| 1008 } | |
| 1009 { | |
| 1010 Label L; | |
| 1011 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 1012 __ jcc(Assembler::zero, L); | |
| 1013 __ stop("tried to execute abstract method in interpreter"); | |
| 1014 __ bind(L); | |
| 1015 } | |
| 1016 #endif | |
| 1017 | |
| 1018 // Since at this point in the method invocation the exception handler | |
| 1019 // would try to exit the monitor of synchronized methods which hasn't | |
| 1020 // been entered yet, we set the thread local variable | |
| 1021 // _do_not_unlock_if_synchronized to true. The remove_activation will | |
| 1022 // check this flag. | |
| 1023 | |
| 1024 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 1025 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 1026 __ movbool(do_not_unlock_if_synchronized, true); | |
| 1027 | |
| 1028 // increment invocation count & check for overflow | |
| 1029 Label invocation_counter_overflow; | |
| 1030 if (inc_counter) { | |
| 1031 generate_counter_incr(&invocation_counter_overflow, NULL, NULL); | |
| 1032 } | |
| 1033 | |
| 1034 Label continue_after_compile; | |
| 1035 __ bind(continue_after_compile); | |
| 1036 | |
| 1037 bang_stack_shadow_pages(true); | |
| 1038 | |
| 1039 // reset the _do_not_unlock_if_synchronized flag | |
| 1040 __ movbool(do_not_unlock_if_synchronized, false); | |
| 1041 | |
| 1042 // check for synchronized methods | |
| 1043 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 1044 // so method is not locked if overflows. | |
| 1045 if (synchronized) { | |
| 1046 lock_method(); | |
| 1047 } else { | |
| 1048 // no synchronization necessary | |
| 1049 #ifdef ASSERT | |
| 1050 { | |
| 1051 Label L; | |
| 1052 __ movl(rax, access_flags); | |
| 1053 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 1054 __ jcc(Assembler::zero, L); | |
| 1055 __ stop("method needs synchronization"); | |
| 1056 __ bind(L); | |
| 1057 } | |
| 1058 #endif | |
| 1059 } | |
| 1060 | |
| 1061 // start execution | |
| 1062 #ifdef ASSERT | |
| 1063 { | |
| 1064 Label L; | |
| 1065 const Address monitor_block_top(rbp, | |
| 1066 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 1067 __ movptr(rax, monitor_block_top); |
| 1068 __ cmpptr(rax, rsp); | |
| 0 | 1069 __ jcc(Assembler::equal, L); |
| 1070 __ stop("broken stack frame setup in interpreter"); | |
| 1071 __ bind(L); | |
| 1072 } | |
| 1073 #endif | |
| 1074 | |
| 1075 // jvmti support | |
| 1076 __ notify_method_entry(); | |
| 1077 | |
| 1078 // work registers | |
| 1079 const Register method = rbx; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1080 const Register t = r11; |
| 0 | 1081 |
| 1082 // allocate space for parameters | |
| 1083 __ get_method(method); | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1084 __ movptr(t, Address(method, Method::const_offset())); |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1085 __ load_unsigned_short(t, Address(t, ConstMethod::size_of_parameters_offset())); |
| 1506 | 1086 __ shll(t, Interpreter::logStackElementSize); |
| 0 | 1087 |
| 304 | 1088 __ subptr(rsp, t); |
| 1089 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows | |
| 605 | 1090 __ andptr(rsp, -16); // must be 16 byte boundary (see amd64 ABI) |
| 0 | 1091 |
| 1092 // get signature handler | |
| 1093 { | |
| 1094 Label L; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1095 __ movptr(t, Address(method, Method::signature_handler_offset())); |
| 304 | 1096 __ testptr(t, t); |
| 0 | 1097 __ jcc(Assembler::notZero, L); |
| 1098 __ call_VM(noreg, | |
| 1099 CAST_FROM_FN_PTR(address, | |
| 1100 InterpreterRuntime::prepare_native_call), | |
| 1101 method); | |
| 1102 __ get_method(method); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1103 __ movptr(t, Address(method, Method::signature_handler_offset())); |
| 0 | 1104 __ bind(L); |
| 1105 } | |
| 1106 | |
| 1107 // call signature handler | |
| 1108 assert(InterpreterRuntime::SignatureHandlerGenerator::from() == r14, | |
| 1109 "adjust this code"); | |
| 1110 assert(InterpreterRuntime::SignatureHandlerGenerator::to() == rsp, | |
| 1111 "adjust this code"); | |
| 1112 assert(InterpreterRuntime::SignatureHandlerGenerator::temp() == rscratch1, | |
| 1113 "adjust this code"); | |
| 1114 | |
| 1115 // The generated handlers do not touch RBX (the method oop). | |
| 1116 // However, large signatures cannot be cached and are generated | |
| 1117 // each time here. The slow-path generator can do a GC on return, | |
| 1118 // so we must reload it after the call. | |
| 1119 __ call(t); | |
| 1120 __ get_method(method); // slow path can do a GC, reload RBX | |
| 1121 | |
| 1122 | |
| 1123 // result handler is in rax | |
| 1124 // set result handler | |
| 304 | 1125 __ movptr(Address(rbp, |
| 1126 (frame::interpreter_frame_result_handler_offset) * wordSize), | |
| 1127 rax); | |
| 0 | 1128 |
| 1129 // pass mirror handle if static call | |
| 1130 { | |
| 1131 Label L; | |
|
4762
069ab3f976d3
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
4042
diff
changeset
|
1132 const int mirror_offset = in_bytes(Klass::java_mirror_offset()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1133 __ movl(t, Address(method, Method::access_flags_offset())); |
| 0 | 1134 __ testl(t, JVM_ACC_STATIC); |
| 1135 __ jcc(Assembler::zero, L); | |
| 1136 // get mirror | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1137 __ movptr(t, Address(method, Method::const_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1138 __ movptr(t, Address(t, ConstMethod::constants_offset())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1139 __ movptr(t, Address(t, ConstantPool::pool_holder_offset_in_bytes())); |
| 304 | 1140 __ movptr(t, Address(t, mirror_offset)); |
| 0 | 1141 // copy mirror into activation frame |
| 304 | 1142 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize), |
| 0 | 1143 t); |
| 1144 // pass handle to mirror | |
| 304 | 1145 __ lea(c_rarg1, |
| 1146 Address(rbp, frame::interpreter_frame_oop_temp_offset * wordSize)); | |
| 0 | 1147 __ bind(L); |
| 1148 } | |
| 1149 | |
| 1150 // get native function entry point | |
| 1151 { | |
| 1152 Label L; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1153 __ movptr(rax, Address(method, Method::native_function_offset())); |
| 0 | 1154 ExternalAddress unsatisfied(SharedRuntime::native_method_throw_unsatisfied_link_error_entry()); |
| 1155 __ movptr(rscratch2, unsatisfied.addr()); | |
| 304 | 1156 __ cmpptr(rax, rscratch2); |
| 0 | 1157 __ jcc(Assembler::notEqual, L); |
| 1158 __ call_VM(noreg, | |
| 1159 CAST_FROM_FN_PTR(address, | |
| 1160 InterpreterRuntime::prepare_native_call), | |
| 1161 method); | |
| 1162 __ get_method(method); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1163 __ movptr(rax, Address(method, Method::native_function_offset())); |
| 0 | 1164 __ bind(L); |
| 1165 } | |
| 1166 | |
| 1167 // pass JNIEnv | |
| 304 | 1168 __ lea(c_rarg0, Address(r15_thread, JavaThread::jni_environment_offset())); |
| 0 | 1169 |
| 1170 // It is enough that the pc() points into the right code | |
| 1171 // segment. It does not have to be the correct return pc. | |
| 1172 __ set_last_Java_frame(rsp, rbp, (address) __ pc()); | |
| 1173 | |
| 1174 // change thread state | |
| 1175 #ifdef ASSERT | |
| 1176 { | |
| 1177 Label L; | |
| 1178 __ movl(t, Address(r15_thread, JavaThread::thread_state_offset())); | |
| 1179 __ cmpl(t, _thread_in_Java); | |
| 1180 __ jcc(Assembler::equal, L); | |
| 1181 __ stop("Wrong thread state in native stub"); | |
| 1182 __ bind(L); | |
| 1183 } | |
| 1184 #endif | |
| 1185 | |
| 1186 // Change state to native | |
| 1187 | |
| 1188 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1189 _thread_in_native); | |
| 1190 | |
| 1191 // Call the native method. | |
| 1192 __ call(rax); | |
| 1193 // result potentially in rax or xmm0 | |
| 1194 | |
|
8873
e961c11b85fe
8011102: Clear AVX registers after return from JNI call
kvn
parents:
8727
diff
changeset
|
1195 // Verify or restore cpu control state after JNI call |
|
e961c11b85fe
8011102: Clear AVX registers after return from JNI call
kvn
parents:
8727
diff
changeset
|
1196 __ restore_cpu_control_state_after_jni(); |
| 0 | 1197 |
| 1198 // NOTE: The order of these pushes is known to frame::interpreter_frame_result | |
| 1199 // in order to extract the result of a method call. If the order of these | |
| 1200 // pushes change or anything else is added to the stack then the code in | |
| 1201 // interpreter_frame_result must also change. | |
| 1202 | |
| 1203 __ push(dtos); | |
| 1204 __ push(ltos); | |
| 1205 | |
| 1206 // change thread state | |
| 1207 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), | |
| 1208 _thread_in_native_trans); | |
| 1209 | |
| 1210 if (os::is_MP()) { | |
| 1211 if (UseMembar) { | |
| 1212 // Force this write out before the read below | |
| 1213 __ membar(Assembler::Membar_mask_bits( | |
| 1214 Assembler::LoadLoad | Assembler::LoadStore | | |
| 1215 Assembler::StoreLoad | Assembler::StoreStore)); | |
| 1216 } else { | |
| 1217 // Write serialization page so VM thread can do a pseudo remote membar. | |
| 1218 // We use the current thread pointer to calculate a thread specific | |
| 1219 // offset to write to within the page. This minimizes bus traffic | |
| 1220 // due to cache line collision. | |
| 1221 __ serialize_memory(r15_thread, rscratch2); | |
| 1222 } | |
| 1223 } | |
| 1224 | |
| 1225 // check for safepoint operation in progress and/or pending suspend requests | |
| 1226 { | |
| 1227 Label Continue; | |
| 1228 __ cmp32(ExternalAddress(SafepointSynchronize::address_of_state()), | |
| 1229 SafepointSynchronize::_not_synchronized); | |
| 1230 | |
| 1231 Label L; | |
| 1232 __ jcc(Assembler::notEqual, L); | |
| 1233 __ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0); | |
| 1234 __ jcc(Assembler::equal, Continue); | |
| 1235 __ bind(L); | |
| 1236 | |
| 1237 // Don't use call_VM as it will see a possible pending exception | |
| 1238 // and forward it and never return here preventing us from | |
| 1239 // clearing _last_native_pc down below. Also can't use | |
| 1240 // call_VM_leaf either as it will check to see if r13 & r14 are | |
| 1241 // preserved and correspond to the bcp/locals pointers. So we do a | |
| 1242 // runtime call by hand. | |
| 1243 // | |
| 304 | 1244 __ mov(c_rarg0, r15_thread); |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1245 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1246 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1247 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1248 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans))); |
| 304 | 1249 __ mov(rsp, r12); // restore sp |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1250 __ reinit_heapbase(); |
| 0 | 1251 __ bind(Continue); |
| 1252 } | |
| 1253 | |
| 1254 // change thread state | |
| 1255 __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java); | |
| 1256 | |
| 1257 // reset_last_Java_frame | |
| 1258 __ reset_last_Java_frame(true, true); | |
| 1259 | |
| 1260 // reset handle block | |
| 304 | 1261 __ movptr(t, Address(r15_thread, JavaThread::active_handles_offset())); |
| 1262 __ movptr(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD); | |
| 0 | 1263 |
| 1264 // If result is an oop unbox and store it in frame where gc will see it | |
| 1265 // and result handler will pick it up | |
| 1266 | |
| 1267 { | |
| 1268 Label no_oop, store_result; | |
| 1269 __ lea(t, ExternalAddress(AbstractInterpreter::result_handler(T_OBJECT))); | |
| 304 | 1270 __ cmpptr(t, Address(rbp, frame::interpreter_frame_result_handler_offset*wordSize)); |
| 0 | 1271 __ jcc(Assembler::notEqual, no_oop); |
| 1272 // retrieve result | |
| 1273 __ pop(ltos); | |
| 304 | 1274 __ testptr(rax, rax); |
| 0 | 1275 __ jcc(Assembler::zero, store_result); |
| 304 | 1276 __ movptr(rax, Address(rax, 0)); |
| 0 | 1277 __ bind(store_result); |
| 304 | 1278 __ movptr(Address(rbp, frame::interpreter_frame_oop_temp_offset*wordSize), rax); |
| 0 | 1279 // keep stack depth as expected by pushing oop which will eventually be discarde |
| 1280 __ push(ltos); | |
| 1281 __ bind(no_oop); | |
| 1282 } | |
| 1283 | |
| 1284 | |
| 1285 { | |
| 1286 Label no_reguard; | |
| 1287 __ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()), | |
| 1288 JavaThread::stack_guard_yellow_disabled); | |
| 1289 __ jcc(Assembler::notEqual, no_reguard); | |
| 1290 | |
| 304 | 1291 __ pusha(); // XXX only save smashed registers |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
1292 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 1293 __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows |
| 1294 __ andptr(rsp, -16); // align stack as required by ABI | |
| 0 | 1295 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages))); |
| 304 | 1296 __ mov(rsp, r12); // restore sp |
| 1297 __ popa(); // XXX only restore smashed registers | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1298 __ reinit_heapbase(); |
| 0 | 1299 |
| 1300 __ bind(no_reguard); | |
| 1301 } | |
| 1302 | |
| 1303 | |
| 1304 // The method register is junk from after the thread_in_native transition | |
| 1305 // until here. Also can't call_VM until the bcp has been | |
| 1306 // restored. Need bcp for throwing exception below so get it now. | |
| 1307 __ get_method(method); | |
| 1308 | |
| 1309 // restore r13 to have legal interpreter frame, i.e., bci == 0 <=> | |
| 1310 // r13 == code_base() | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1311 __ movptr(r13, Address(method, Method::const_offset())); // get ConstMethod* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1312 __ lea(r13, Address(r13, ConstMethod::codes_offset())); // get codebase |
| 0 | 1313 // handle exceptions (exception handling will handle unlocking!) |
| 1314 { | |
| 1315 Label L; | |
| 304 | 1316 __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t) NULL_WORD); |
| 0 | 1317 __ jcc(Assembler::zero, L); |
| 1318 // Note: At some point we may want to unify this with the code | |
| 1319 // used in call_VM_base(); i.e., we should use the | |
| 1320 // StubRoutines::forward_exception code. For now this doesn't work | |
| 1321 // here because the rsp is not correctly set at this point. | |
| 1322 __ MacroAssembler::call_VM(noreg, | |
| 1323 CAST_FROM_FN_PTR(address, | |
| 1324 InterpreterRuntime::throw_pending_exception)); | |
| 1325 __ should_not_reach_here(); | |
| 1326 __ bind(L); | |
| 1327 } | |
| 1328 | |
| 1329 // do unlocking if necessary | |
| 1330 { | |
| 1331 Label L; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1332 __ movl(t, Address(method, Method::access_flags_offset())); |
| 0 | 1333 __ testl(t, JVM_ACC_SYNCHRONIZED); |
| 1334 __ jcc(Assembler::zero, L); | |
| 1335 // the code below should be shared with interpreter macro | |
| 1336 // assembler implementation | |
| 1337 { | |
| 1338 Label unlock; | |
| 1339 // BasicObjectLock will be first in list, since this is a | |
| 1340 // synchronized method. However, need to check that the object | |
| 1341 // has not been unlocked by an explicit monitorexit bytecode. | |
| 1342 const Address monitor(rbp, | |
| 1343 (intptr_t)(frame::interpreter_frame_initial_sp_offset * | |
| 1344 wordSize - sizeof(BasicObjectLock))); | |
| 1345 | |
| 1346 // monitor expect in c_rarg1 for slow unlock path | |
| 304 | 1347 __ lea(c_rarg1, monitor); // address of first monitor |
| 0 | 1348 |
| 304 | 1349 __ movptr(t, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes())); |
| 1350 __ testptr(t, t); | |
| 0 | 1351 __ jcc(Assembler::notZero, unlock); |
| 1352 | |
| 1353 // Entry already unlocked, need to throw exception | |
| 1354 __ MacroAssembler::call_VM(noreg, | |
| 1355 CAST_FROM_FN_PTR(address, | |
| 1356 InterpreterRuntime::throw_illegal_monitor_state_exception)); | |
| 1357 __ should_not_reach_here(); | |
| 1358 | |
| 1359 __ bind(unlock); | |
| 1360 __ unlock_object(c_rarg1); | |
| 1361 } | |
| 1362 __ bind(L); | |
| 1363 } | |
| 1364 | |
| 1365 // jvmti support | |
| 1366 // Note: This must happen _after_ handling/throwing any exceptions since | |
| 1367 // the exception handler code notifies the runtime of method exits | |
| 1368 // too. If this happens before, method entry/exit notifications are | |
| 1369 // not properly paired (was bug - gri 11/22/99). | |
| 1370 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI); | |
| 1371 | |
| 1372 // restore potential result in edx:eax, call result handler to | |
| 1373 // restore potential result in ST0 & handle result | |
| 1374 | |
| 1375 __ pop(ltos); | |
| 1376 __ pop(dtos); | |
| 1377 | |
| 304 | 1378 __ movptr(t, Address(rbp, |
| 1379 (frame::interpreter_frame_result_handler_offset) * wordSize)); | |
| 0 | 1380 __ call(t); |
| 1381 | |
| 1382 // remove activation | |
| 304 | 1383 __ movptr(t, Address(rbp, |
| 1384 frame::interpreter_frame_sender_sp_offset * | |
| 1385 wordSize)); // get sender sp | |
| 0 | 1386 __ leave(); // remove frame anchor |
| 304 | 1387 __ pop(rdi); // get return address |
| 1388 __ mov(rsp, t); // set sp to sender sp | |
| 0 | 1389 __ jmp(rdi); |
| 1390 | |
| 1391 if (inc_counter) { | |
| 1392 // Handle overflow of counter and compile method | |
| 1393 __ bind(invocation_counter_overflow); | |
| 1394 generate_counter_overflow(&continue_after_compile); | |
| 1395 } | |
| 1396 | |
| 1397 return entry_point; | |
| 1398 } | |
| 1399 | |
| 1400 // | |
| 1401 // Generic interpreted method entry to (asm) interpreter | |
| 1402 // | |
| 1403 address InterpreterGenerator::generate_normal_entry(bool synchronized) { | |
| 1404 // determine code generation flags | |
| 1405 bool inc_counter = UseCompiler || CountCompiledCalls; | |
| 1406 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1407 // ebx: Method* |
| 0 | 1408 // r13: sender sp |
| 1409 address entry_point = __ pc(); | |
| 1410 | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1411 const Address constMethod(rbx, Method::const_offset()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1412 const Address access_flags(rbx, Method::access_flags_offset()); |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1413 const Address size_of_parameters(rdx, |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1414 ConstMethod::size_of_parameters_offset()); |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1415 const Address size_of_locals(rdx, ConstMethod::size_of_locals_offset()); |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1416 |
| 0 | 1417 |
| 1418 // get parameter size (always needed) | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1419 __ movptr(rdx, constMethod); |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1420 __ load_unsigned_short(rcx, size_of_parameters); |
| 0 | 1421 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1422 // rbx: Method* |
| 0 | 1423 // rcx: size of parameters |
| 1424 // r13: sender_sp (could differ from sp+wordSize if we were called via c2i ) | |
| 1425 | |
|
622
56aae7be60d4
6812678: macro assembler needs delayed binding of a few constants (for 6655638)
jrose
parents:
605
diff
changeset
|
1426 __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words |
| 0 | 1427 __ subl(rdx, rcx); // rdx = no. of additional locals |
| 1428 | |
| 1429 // YYY | |
| 1430 // __ incrementl(rdx); | |
| 1431 // __ andl(rdx, -2); | |
| 1432 | |
| 1433 // see if we've got enough room on the stack for locals plus overhead. | |
| 1434 generate_stack_overflow_check(); | |
| 1435 | |
| 1436 // get return address | |
| 304 | 1437 __ pop(rax); |
| 0 | 1438 |
| 1439 // compute beginning of parameters (r14) | |
| 304 | 1440 __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)); |
| 0 | 1441 |
| 1442 // rdx - # of additional locals | |
| 1443 // allocate space for locals | |
| 1444 // explicitly initialize locals | |
| 1445 { | |
| 1446 Label exit, loop; | |
| 1447 __ testl(rdx, rdx); | |
| 1448 __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0 | |
| 1449 __ bind(loop); | |
| 304 | 1450 __ push((int) NULL_WORD); // initialize local variables |
| 0 | 1451 __ decrementl(rdx); // until everything initialized |
| 1452 __ jcc(Assembler::greater, loop); | |
| 1453 __ bind(exit); | |
| 1454 } | |
| 1455 | |
| 1456 // initialize fixed part of activation frame | |
| 1457 generate_fixed_frame(false); | |
| 1458 | |
| 1459 // make sure method is not native & not abstract | |
| 1460 #ifdef ASSERT | |
| 1461 __ movl(rax, access_flags); | |
| 1462 { | |
| 1463 Label L; | |
| 1464 __ testl(rax, JVM_ACC_NATIVE); | |
| 1465 __ jcc(Assembler::zero, L); | |
| 1466 __ stop("tried to execute native method as non-native"); | |
| 1467 __ bind(L); | |
| 1468 } | |
| 1469 { | |
| 1470 Label L; | |
| 1471 __ testl(rax, JVM_ACC_ABSTRACT); | |
| 1472 __ jcc(Assembler::zero, L); | |
| 1473 __ stop("tried to execute abstract method in interpreter"); | |
| 1474 __ bind(L); | |
| 1475 } | |
| 1476 #endif | |
| 1477 | |
| 1478 // Since at this point in the method invocation the exception | |
| 1479 // handler would try to exit the monitor of synchronized methods | |
| 1480 // which hasn't been entered yet, we set the thread local variable | |
| 1481 // _do_not_unlock_if_synchronized to true. The remove_activation | |
| 1482 // will check this flag. | |
| 1483 | |
| 1484 const Address do_not_unlock_if_synchronized(r15_thread, | |
| 1485 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); | |
| 1486 __ movbool(do_not_unlock_if_synchronized, true); | |
| 1487 | |
|
12962
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12882
diff
changeset
|
1488 __ profile_parameters_type(rax, rcx, rdx); |
| 0 | 1489 // increment invocation count & check for overflow |
| 1490 Label invocation_counter_overflow; | |
| 1491 Label profile_method; | |
| 1492 Label profile_method_continue; | |
| 1493 if (inc_counter) { | |
| 1494 generate_counter_incr(&invocation_counter_overflow, | |
| 1495 &profile_method, | |
| 1496 &profile_method_continue); | |
| 1497 if (ProfileInterpreter) { | |
| 1498 __ bind(profile_method_continue); | |
| 1499 } | |
| 1500 } | |
| 1501 | |
| 1502 Label continue_after_compile; | |
| 1503 __ bind(continue_after_compile); | |
| 1504 | |
| 1505 // check for synchronized interpreted methods | |
| 1506 bang_stack_shadow_pages(false); | |
| 1507 | |
| 1508 // reset the _do_not_unlock_if_synchronized flag | |
| 1509 __ movbool(do_not_unlock_if_synchronized, false); | |
| 1510 | |
| 1511 // check for synchronized methods | |
| 1512 // Must happen AFTER invocation_counter check and stack overflow check, | |
| 1513 // so method is not locked if overflows. | |
| 1514 if (synchronized) { | |
| 1515 // Allocate monitor and lock method | |
| 1516 lock_method(); | |
| 1517 } else { | |
| 1518 // no synchronization necessary | |
| 1519 #ifdef ASSERT | |
| 1520 { | |
| 1521 Label L; | |
| 1522 __ movl(rax, access_flags); | |
| 1523 __ testl(rax, JVM_ACC_SYNCHRONIZED); | |
| 1524 __ jcc(Assembler::zero, L); | |
| 1525 __ stop("method needs synchronization"); | |
| 1526 __ bind(L); | |
| 1527 } | |
| 1528 #endif | |
| 1529 } | |
| 1530 | |
| 1531 // start execution | |
| 1532 #ifdef ASSERT | |
| 1533 { | |
| 1534 Label L; | |
| 1535 const Address monitor_block_top (rbp, | |
| 1536 frame::interpreter_frame_monitor_block_top_offset * wordSize); | |
| 304 | 1537 __ movptr(rax, monitor_block_top); |
| 1538 __ cmpptr(rax, rsp); | |
| 0 | 1539 __ jcc(Assembler::equal, L); |
| 1540 __ stop("broken stack frame setup in interpreter"); | |
| 1541 __ bind(L); | |
| 1542 } | |
| 1543 #endif | |
| 1544 | |
| 1545 // jvmti support | |
| 1546 __ notify_method_entry(); | |
| 1547 | |
| 1548 __ dispatch_next(vtos); | |
| 1549 | |
| 1550 // invocation counter overflow | |
| 1551 if (inc_counter) { | |
| 1552 if (ProfileInterpreter) { | |
| 1553 // We have decided to profile this method in the interpreter | |
| 1554 __ bind(profile_method); | |
|
2118
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
1555 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method)); |
|
dd031b2226de
4930919: race condition in MDO creation at back branch locations
iveresov
parents:
1976
diff
changeset
|
1556 __ set_method_data_pointer_for_bcp(); |
|
2141
b599a4c6c2df
7012766: assert(false) failed: DEBUG MESSAGE in MacroAssembler::debug32
iveresov
parents:
2118
diff
changeset
|
1557 __ get_method(rbx); |
| 0 | 1558 __ jmp(profile_method_continue); |
| 1559 } | |
| 1560 // Handle overflow of counter and compile method | |
| 1561 __ bind(invocation_counter_overflow); | |
| 1562 generate_counter_overflow(&continue_after_compile); | |
| 1563 } | |
| 1564 | |
| 1565 return entry_point; | |
| 1566 } | |
| 1567 | |
| 1568 // Entry points | |
| 1569 // | |
| 1570 // Here we generate the various kind of entries into the interpreter. | |
| 1571 // The two main entry type are generic bytecode methods and native | |
| 1572 // call method. These both come in synchronized and non-synchronized | |
| 1573 // versions but the frame layout they create is very similar. The | |
| 1574 // other method entry types are really just special purpose entries | |
| 1575 // that are really entry and interpretation all in one. These are for | |
| 1576 // trivial methods like accessor, empty, or special math methods. | |
| 1577 // | |
| 1578 // When control flow reaches any of the entry types for the interpreter | |
| 1579 // the following holds -> | |
| 1580 // | |
| 1581 // Arguments: | |
| 1582 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1583 // rbx: Method* |
| 0 | 1584 // |
| 1585 // Stack layout immediately at entry | |
| 1586 // | |
| 1587 // [ return address ] <--- rsp | |
| 1588 // [ parameter n ] | |
| 1589 // ... | |
| 1590 // [ parameter 1 ] | |
| 1591 // [ expression stack ] (caller's java expression stack) | |
| 1592 | |
| 1593 // Assuming that we don't go to one of the trivial specialized entries | |
| 1594 // the stack will look like below when we are ready to execute the | |
| 1595 // first bytecode (or call the native routine). The register usage | |
| 1596 // will be as the template based interpreter expects (see | |
| 1597 // interpreter_amd64.hpp). | |
| 1598 // | |
| 1599 // local variables follow incoming parameters immediately; i.e. | |
| 1600 // the return address is moved to the end of the locals). | |
| 1601 // | |
| 1602 // [ monitor entry ] <--- rsp | |
| 1603 // ... | |
| 1604 // [ monitor entry ] | |
| 1605 // [ expr. stack bottom ] | |
| 1606 // [ saved r13 ] | |
| 1607 // [ current r14 ] | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1608 // [ Method* ] |
| 0 | 1609 // [ saved ebp ] <--- rbp |
| 1610 // [ return address ] | |
| 1611 // [ local variable m ] | |
| 1612 // ... | |
| 1613 // [ local variable 1 ] | |
| 1614 // [ parameter n ] | |
| 1615 // ... | |
| 1616 // [ parameter 1 ] <--- r14 | |
| 1617 | |
| 1618 address AbstractInterpreterGenerator::generate_method_entry( | |
| 1619 AbstractInterpreter::MethodKind kind) { | |
| 1620 // determine code generation flags | |
| 1621 bool synchronized = false; | |
| 1622 address entry_point = NULL; | |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1623 InterpreterGenerator* ig_this = (InterpreterGenerator*)this; |
| 0 | 1624 |
| 1625 switch (kind) { | |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1626 case Interpreter::zerolocals : break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1627 case Interpreter::zerolocals_synchronized: synchronized = true; break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1628 case Interpreter::native : entry_point = ig_this->generate_native_entry(false); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1629 case Interpreter::native_synchronized : entry_point = ig_this->generate_native_entry(true); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1630 case Interpreter::empty : entry_point = ig_this->generate_empty_entry(); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1631 case Interpreter::accessor : entry_point = ig_this->generate_accessor_entry(); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1632 case Interpreter::abstract : entry_point = ig_this->generate_abstract_entry(); break; |
|
706
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1633 |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1634 case Interpreter::java_lang_math_sin : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1635 case Interpreter::java_lang_math_cos : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1636 case Interpreter::java_lang_math_tan : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1637 case Interpreter::java_lang_math_abs : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1638 case Interpreter::java_lang_math_log : // fall thru |
|
819880572f09
6539464: Math.log() produces inconsistent results between successive runs.
never
parents:
622
diff
changeset
|
1639 case Interpreter::java_lang_math_log10 : // fall thru |
|
6084
6759698e3140
7133857: exp() and pow() should use the x87 ISA on x86
roland
parents:
4771
diff
changeset
|
1640 case Interpreter::java_lang_math_sqrt : // fall thru |
|
6759698e3140
7133857: exp() and pow() should use the x87 ISA on x86
roland
parents:
4771
diff
changeset
|
1641 case Interpreter::java_lang_math_pow : // fall thru |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1642 case Interpreter::java_lang_math_exp : entry_point = ig_this->generate_math_entry(kind); break; |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2245
diff
changeset
|
1643 case Interpreter::java_lang_ref_reference_get |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1644 : entry_point = ig_this->generate_Reference_get_entry(); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1645 case Interpreter::java_util_zip_CRC32_update |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1646 : entry_point = ig_this->generate_CRC32_update_entry(); break; |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1647 case Interpreter::java_util_zip_CRC32_updateBytes |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1648 : // fall thru |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1649 case Interpreter::java_util_zip_CRC32_updateByteBuffer |
|
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1650 : entry_point = ig_this->generate_CRC32_updateBytes_entry(kind); break; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
1651 default: |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
1652 fatal(err_msg("unexpected method kind: %d", kind)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6123
diff
changeset
|
1653 break; |
| 0 | 1654 } |
| 1655 | |
| 1656 if (entry_point) { | |
| 1657 return entry_point; | |
| 1658 } | |
| 1659 | |
|
11080
b800986664f4
7088419: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32
drchase
parents:
10393
diff
changeset
|
1660 return ig_this->generate_normal_entry(synchronized); |
| 0 | 1661 } |
| 1662 | |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1663 // These should never be compiled since the interpreter will prefer |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1664 // the compiled version to the intrinsic version. |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1665 bool AbstractInterpreter::can_be_compiled(methodHandle m) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1666 switch (method_kind(m)) { |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1667 case Interpreter::java_lang_math_sin : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1668 case Interpreter::java_lang_math_cos : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1669 case Interpreter::java_lang_math_tan : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1670 case Interpreter::java_lang_math_abs : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1671 case Interpreter::java_lang_math_log : // fall thru |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1672 case Interpreter::java_lang_math_log10 : // fall thru |
|
6084
6759698e3140
7133857: exp() and pow() should use the x87 ISA on x86
roland
parents:
4771
diff
changeset
|
1673 case Interpreter::java_lang_math_sqrt : // fall thru |
|
6759698e3140
7133857: exp() and pow() should use the x87 ISA on x86
roland
parents:
4771
diff
changeset
|
1674 case Interpreter::java_lang_math_pow : // fall thru |
|
6759698e3140
7133857: exp() and pow() should use the x87 ISA on x86
roland
parents:
4771
diff
changeset
|
1675 case Interpreter::java_lang_math_exp : |
|
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1676 return false; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1677 default: |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1678 return true; |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1679 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1680 } |
|
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
1135
diff
changeset
|
1681 |
| 0 | 1682 // How much stack a method activation needs in words. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1683 int AbstractInterpreter::size_top_interpreter_activation(Method* method) { |
| 0 | 1684 const int entry_size = frame::interpreter_frame_monitor_size(); |
| 1685 | |
| 1686 // total overhead size: entry_size + (saved rbp thru expr stack | |
| 1687 // bottom). be sure to change this if you add/subtract anything | |
| 1688 // to/from the overhead area | |
| 1689 const int overhead_size = | |
| 1690 -(frame::interpreter_frame_initial_sp_offset) + entry_size; | |
| 1691 | |
| 1692 const int stub_code = frame::entry_frame_after_call_words; | |
|
10393
603ca7e51354
8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292
roland
parents:
10141
diff
changeset
|
1693 const int method_stack = (method->max_locals() + method->max_stack()) * |
| 1506 | 1694 Interpreter::stackElementWords; |
| 0 | 1695 return (overhead_size + method_stack + stub_code); |
| 1696 } | |
| 1697 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1698 int AbstractInterpreter::layout_activation(Method* method, |
| 0 | 1699 int tempcount, |
| 1700 int popframe_extra_args, | |
| 1701 int moncount, | |
|
3369
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3252
diff
changeset
|
1702 int caller_actual_parameters, |
| 0 | 1703 int callee_param_count, |
| 1704 int callee_locals, | |
| 1705 frame* caller, | |
| 1706 frame* interpreter_frame, | |
|
8727
0094485b46c7
8009761: Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates
roland
parents:
8001
diff
changeset
|
1707 bool is_top_frame, |
|
0094485b46c7
8009761: Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates
roland
parents:
8001
diff
changeset
|
1708 bool is_bottom_frame) { |
| 0 | 1709 // Note: This calculation must exactly parallel the frame setup |
| 1710 // in AbstractInterpreterGenerator::generate_method_entry. | |
| 1711 // If interpreter_frame!=NULL, set up the method, locals, and monitors. | |
| 1712 // The frame interpreter_frame, if not NULL, is guaranteed to be the | |
| 1713 // right size, as determined by a previous call to this method. | |
| 1714 // It is also guaranteed to be walkable even though it is in a skeletal state | |
| 1715 | |
| 1716 // fixed size of an interpreter frame: | |
| 1506 | 1717 int max_locals = method->max_locals() * Interpreter::stackElementWords; |
| 0 | 1718 int extra_locals = (method->max_locals() - method->size_of_parameters()) * |
| 1506 | 1719 Interpreter::stackElementWords; |
| 0 | 1720 |
| 1721 int overhead = frame::sender_sp_offset - | |
| 1722 frame::interpreter_frame_initial_sp_offset; | |
| 1723 // Our locals were accounted for by the caller (or last_frame_adjust | |
| 1724 // on the transistion) Since the callee parameters already account | |
| 1725 // for the callee's params we only need to account for the extra | |
| 1726 // locals. | |
| 1727 int size = overhead + | |
| 1506 | 1728 (callee_locals - callee_param_count)*Interpreter::stackElementWords + |
| 0 | 1729 moncount * frame::interpreter_frame_monitor_size() + |
| 1506 | 1730 tempcount* Interpreter::stackElementWords + popframe_extra_args; |
| 0 | 1731 if (interpreter_frame != NULL) { |
| 1732 #ifdef ASSERT | |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2245
diff
changeset
|
1733 if (!EnableInvokeDynamic) |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1734 // @@@ FIXME: Should we correct interpreter_frame_sender_sp in the calling sequences? |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1735 // Probably, since deoptimization doesn't work yet. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1108
diff
changeset
|
1736 assert(caller->unextended_sp() == interpreter_frame->interpreter_frame_sender_sp(), "Frame not properly walkable"); |
| 0 | 1737 assert(caller->sp() == interpreter_frame->sender_sp(), "Frame not properly walkable(2)"); |
| 1738 #endif | |
| 1739 | |
| 1740 interpreter_frame->interpreter_frame_set_method(method); | |
| 1741 // NOTE the difference in using sender_sp and | |
| 1742 // interpreter_frame_sender_sp interpreter_frame_sender_sp is | |
| 1743 // the original sp of the caller (the unextended_sp) and | |
| 1744 // sender_sp is fp+16 XXX | |
| 1745 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1; | |
| 1746 | |
|
4042
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1747 #ifdef ASSERT |
|
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1748 if (caller->is_interpreted_frame()) { |
|
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1749 assert(locals < caller->fp() + frame::interpreter_frame_initial_sp_offset, "bad placement"); |
|
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1750 } |
|
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1751 #endif |
|
b20d64f83668
7090904: JSR 292: JRuby junit test crashes in PSScavengeRootsClosure::do_oop
twisti
parents:
3781
diff
changeset
|
1752 |
| 0 | 1753 interpreter_frame->interpreter_frame_set_locals(locals); |
| 1754 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin(); | |
| 1755 BasicObjectLock* monbot = montop - moncount; | |
| 1756 interpreter_frame->interpreter_frame_set_monitor_end(monbot); | |
| 1757 | |
| 1758 // Set last_sp | |
| 1759 intptr_t* esp = (intptr_t*) monbot - | |
| 1506 | 1760 tempcount*Interpreter::stackElementWords - |
| 0 | 1761 popframe_extra_args; |
| 1762 interpreter_frame->interpreter_frame_set_last_sp(esp); | |
| 1763 | |
| 1764 // All frames but the initial (oldest) interpreter frame we fill in have | |
| 1765 // a value for sender_sp that allows walking the stack but isn't | |
| 1766 // truly correct. Correct the value here. | |
| 1767 if (extra_locals != 0 && | |
| 1768 interpreter_frame->sender_sp() == | |
| 1769 interpreter_frame->interpreter_frame_sender_sp()) { | |
| 1770 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() + | |
| 1771 extra_locals); | |
| 1772 } | |
| 1773 *interpreter_frame->interpreter_frame_cache_addr() = | |
| 1774 method->constants()->cache(); | |
| 1775 } | |
| 1776 return size; | |
| 1777 } | |
| 1778 | |
| 1779 //----------------------------------------------------------------------------- | |
| 1780 // Exceptions | |
| 1781 | |
| 1782 void TemplateInterpreterGenerator::generate_throw_exception() { | |
| 1783 // Entry point in previous activation (i.e., if the caller was | |
| 1784 // interpreted) | |
| 1785 Interpreter::_rethrow_exception_entry = __ pc(); | |
| 1786 // Restore sp to interpreter_frame_last_sp even though we are going | |
| 1787 // to empty the expression stack for the exception processing. | |
| 304 | 1788 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); |
| 0 | 1789 // rax: exception |
| 1790 // rdx: return address/pc that threw exception | |
| 1791 __ restore_bcp(); // r13 points to call/send | |
| 1792 __ restore_locals(); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1793 __ reinit_heapbase(); // restore r12 as heapbase. |
| 0 | 1794 // Entry point for exceptions thrown within interpreter code |
| 1795 Interpreter::_throw_exception_entry = __ pc(); | |
| 1796 // expression stack is undefined here | |
| 1797 // rax: exception | |
| 1798 // r13: exception bcp | |
| 1799 __ verify_oop(rax); | |
| 304 | 1800 __ mov(c_rarg1, rax); |
| 0 | 1801 |
| 1802 // expression stack must be empty before entering the VM in case of | |
| 1803 // an exception | |
| 1804 __ empty_expression_stack(); | |
| 1805 // find exception handler address and preserve exception oop | |
| 1806 __ call_VM(rdx, | |
| 1807 CAST_FROM_FN_PTR(address, | |
| 1808 InterpreterRuntime::exception_handler_for_exception), | |
| 1809 c_rarg1); | |
| 1810 // rax: exception handler entry point | |
| 1811 // rdx: preserved exception oop | |
| 1812 // r13: bcp for exception handler | |
| 1813 __ push_ptr(rdx); // push exception which is now the only value on the stack | |
| 1814 __ jmp(rax); // jump to exception handler (may be _remove_activation_entry!) | |
| 1815 | |
| 1816 // If the exception is not handled in the current frame the frame is | |
| 1817 // removed and the exception is rethrown (i.e. exception | |
| 1818 // continuation is _rethrow_exception). | |
| 1819 // | |
| 1820 // Note: At this point the bci is still the bxi for the instruction | |
| 1821 // which caused the exception and the expression stack is | |
| 1822 // empty. Thus, for any VM calls at this point, GC will find a legal | |
| 1823 // oop map (with empty expression stack). | |
| 1824 | |
| 1825 // In current activation | |
| 1826 // tos: exception | |
| 1827 // esi: exception bcp | |
| 1828 | |
| 1829 // | |
| 1830 // JVMTI PopFrame support | |
| 1831 // | |
| 1832 | |
| 1833 Interpreter::_remove_activation_preserving_args_entry = __ pc(); | |
| 1834 __ empty_expression_stack(); | |
| 1835 // Set the popframe_processing bit in pending_popframe_condition | |
| 1836 // indicating that we are currently handling popframe, so that | |
| 1837 // call_VMs that may happen later do not trigger new popframe | |
| 1838 // handling cycles. | |
| 1839 __ movl(rdx, Address(r15_thread, JavaThread::popframe_condition_offset())); | |
| 1840 __ orl(rdx, JavaThread::popframe_processing_bit); | |
| 1841 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), rdx); | |
| 1842 | |
| 1843 { | |
| 1844 // Check to see whether we are returning to a deoptimized frame. | |
| 1845 // (The PopFrame call ensures that the caller of the popped frame is | |
| 1846 // either interpreted or compiled and deoptimizes it if compiled.) | |
| 1847 // In this case, we can't call dispatch_next() after the frame is | |
| 1848 // popped, but instead must save the incoming arguments and restore | |
| 1849 // them after deoptimization has occurred. | |
| 1850 // | |
| 1851 // Note that we don't compare the return PC against the | |
| 1852 // deoptimization blob's unpack entry because of the presence of | |
| 1853 // adapter frames in C2. | |
| 1854 Label caller_not_deoptimized; | |
| 304 | 1855 __ movptr(c_rarg1, Address(rbp, frame::return_addr_offset * wordSize)); |
| 0 | 1856 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1857 InterpreterRuntime::interpreter_contains), c_rarg1); | |
| 1858 __ testl(rax, rax); | |
| 1859 __ jcc(Assembler::notZero, caller_not_deoptimized); | |
| 1860 | |
| 1861 // Compute size of arguments for saving when returning to | |
| 1862 // deoptimized caller | |
| 1863 __ get_method(rax); | |
|
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1864 __ movptr(rax, Address(rax, Method::const_offset())); |
|
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7199
diff
changeset
|
1865 __ load_unsigned_short(rax, Address(rax, in_bytes(ConstMethod:: |
| 0 | 1866 size_of_parameters_offset()))); |
| 1506 | 1867 __ shll(rax, Interpreter::logStackElementSize); |
| 0 | 1868 __ restore_locals(); // XXX do we need this? |
| 304 | 1869 __ subptr(r14, rax); |
| 1870 __ addptr(r14, wordSize); | |
| 0 | 1871 // Save these arguments |
| 1872 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, | |
| 1873 Deoptimization:: | |
| 1874 popframe_preserve_args), | |
| 1875 r15_thread, rax, r14); | |
| 1876 | |
| 1877 __ remove_activation(vtos, rdx, | |
| 1878 /* throw_monitor_exception */ false, | |
| 1879 /* install_monitor_exception */ false, | |
| 1880 /* notify_jvmdi */ false); | |
| 1881 | |
| 1882 // Inform deoptimization that it is responsible for restoring | |
| 1883 // these arguments | |
| 1884 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1885 JavaThread::popframe_force_deopt_reexecution_bit); | |
| 1886 | |
| 1887 // Continue in deoptimization handler | |
| 1888 __ jmp(rdx); | |
| 1889 | |
| 1890 __ bind(caller_not_deoptimized); | |
| 1891 } | |
| 1892 | |
| 1893 __ remove_activation(vtos, rdx, /* rdx result (retaddr) is not used */ | |
| 1894 /* throw_monitor_exception */ false, | |
| 1895 /* install_monitor_exception */ false, | |
| 1896 /* notify_jvmdi */ false); | |
| 1897 | |
| 1898 // Finish with popframe handling | |
| 1899 // A previous I2C followed by a deoptimization might have moved the | |
| 1900 // outgoing arguments further up the stack. PopFrame expects the | |
| 1901 // mutations to those outgoing arguments to be preserved and other | |
| 1902 // constraints basically require this frame to look exactly as | |
| 1903 // though it had previously invoked an interpreted activation with | |
| 1904 // no space between the top of the expression stack (current | |
| 1905 // last_sp) and the top of stack. Rather than force deopt to | |
| 1906 // maintain this kind of invariant all the time we call a small | |
| 1907 // fixup routine to move the mutated arguments onto the top of our | |
| 1908 // expression stack if necessary. | |
| 304 | 1909 __ mov(c_rarg1, rsp); |
| 1910 __ movptr(c_rarg2, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); | |
| 0 | 1911 // PC must point into interpreter here |
| 1912 __ set_last_Java_frame(noreg, rbp, __ pc()); | |
| 1913 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), r15_thread, c_rarg1, c_rarg2); | |
| 1914 __ reset_last_Java_frame(true, true); | |
| 1915 // Restore the last_sp and null it out | |
| 304 | 1916 __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); |
| 1917 __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); | |
| 0 | 1918 |
| 1919 __ restore_bcp(); // XXX do we need this? | |
| 1920 __ restore_locals(); // XXX do we need this? | |
| 1921 // The method data pointer was incremented already during | |
| 1922 // call profiling. We have to restore the mdp for the current bcp. | |
| 1923 if (ProfileInterpreter) { | |
| 1924 __ set_method_data_pointer_for_bcp(); | |
| 1925 } | |
| 1926 | |
| 1927 // Clear the popframe condition flag | |
| 1928 __ movl(Address(r15_thread, JavaThread::popframe_condition_offset()), | |
| 1929 JavaThread::popframe_inactive); | |
| 1930 | |
|
12010
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1931 #if INCLUDE_JVMTI |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1932 if (EnableInvokeDynamic) { |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1933 Label L_done; |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1934 const Register local0 = r14; |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1935 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1936 __ cmpb(Address(r13, 0), Bytecodes::_invokestatic); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1937 __ jcc(Assembler::notEqual, L_done); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1938 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1939 // The member name argument must be restored if _invokestatic is re-executed after a PopFrame call. |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1940 // Detect such a case in the InterpreterRuntime function and return the member name argument, or NULL. |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1941 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1942 __ get_method(rdx); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1943 __ movptr(rax, Address(local0, 0)); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1944 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::member_name_arg_or_null), rax, rdx, r13); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1945 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1946 __ testptr(rax, rax); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1947 __ jcc(Assembler::zero, L_done); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1948 |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1949 __ movptr(Address(rbx, 0), rax); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1950 __ bind(L_done); |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1951 } |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1952 #endif // INCLUDE_JVMTI |
|
ca0165daa6ec
7187554: JSR 292: JVMTI PopFrame needs to handle appendix arguments
sspitsyn
parents:
11080
diff
changeset
|
1953 |
| 0 | 1954 __ dispatch_next(vtos); |
| 1955 // end of PopFrame support | |
| 1956 | |
| 1957 Interpreter::_remove_activation_entry = __ pc(); | |
| 1958 | |
| 1959 // preserve exception over this code sequence | |
| 1960 __ pop_ptr(rax); | |
| 304 | 1961 __ movptr(Address(r15_thread, JavaThread::vm_result_offset()), rax); |
| 0 | 1962 // remove the activation (without doing throws on illegalMonitorExceptions) |
| 1963 __ remove_activation(vtos, rdx, false, true, false); | |
| 1964 // restore exception | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1965 __ get_vm_result(rax, r15_thread); |
| 0 | 1966 |
| 1967 // In between activations - previous activation type unknown yet | |
| 1968 // compute continuation point - the continuation point expects the | |
| 1969 // following registers set up: | |
| 1970 // | |
| 1971 // rax: exception | |
| 1972 // rdx: return address/pc that threw exception | |
| 1973 // rsp: expression stack of caller | |
| 1974 // rbp: ebp of caller | |
| 304 | 1975 __ push(rax); // save exception |
| 1976 __ push(rdx); // save return address | |
| 0 | 1977 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address, |
| 1978 SharedRuntime::exception_handler_for_return_address), | |
| 1295 | 1979 r15_thread, rdx); |
| 304 | 1980 __ mov(rbx, rax); // save exception handler |
| 1981 __ pop(rdx); // restore return address | |
| 1982 __ pop(rax); // restore exception | |
| 0 | 1983 // Note that an "issuing PC" is actually the next PC after the call |
| 1984 __ jmp(rbx); // jump to exception | |
| 1985 // handler of caller | |
| 1986 } | |
| 1987 | |
| 1988 | |
| 1989 // | |
| 1990 // JVMTI ForceEarlyReturn support | |
| 1991 // | |
| 1992 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) { | |
| 1993 address entry = __ pc(); | |
| 1994 | |
| 1995 __ restore_bcp(); | |
| 1996 __ restore_locals(); | |
| 1997 __ empty_expression_stack(); | |
| 1998 __ load_earlyret_value(state); | |
| 1999 | |
| 304 | 2000 __ movptr(rdx, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); |
| 0 | 2001 Address cond_addr(rdx, JvmtiThreadState::earlyret_state_offset()); |
| 2002 | |
| 2003 // Clear the earlyret state | |
| 2004 __ movl(cond_addr, JvmtiThreadState::earlyret_inactive); | |
| 2005 | |
| 2006 __ remove_activation(state, rsi, | |
| 2007 false, /* throw_monitor_exception */ | |
| 2008 false, /* install_monitor_exception */ | |
| 2009 true); /* notify_jvmdi */ | |
| 2010 __ jmp(rsi); | |
| 2011 | |
| 2012 return entry; | |
| 2013 } // end of ForceEarlyReturn support | |
| 2014 | |
| 2015 | |
| 2016 //----------------------------------------------------------------------------- | |
| 2017 // Helper for vtos entry point generation | |
| 2018 | |
| 2019 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t, | |
| 2020 address& bep, | |
| 2021 address& cep, | |
| 2022 address& sep, | |
| 2023 address& aep, | |
| 2024 address& iep, | |
| 2025 address& lep, | |
| 2026 address& fep, | |
| 2027 address& dep, | |
| 2028 address& vep) { | |
| 2029 assert(t->is_valid() && t->tos_in() == vtos, "illegal template"); | |
| 2030 Label L; | |
| 2031 aep = __ pc(); __ push_ptr(); __ jmp(L); | |
| 2032 fep = __ pc(); __ push_f(); __ jmp(L); | |
| 2033 dep = __ pc(); __ push_d(); __ jmp(L); | |
| 2034 lep = __ pc(); __ push_l(); __ jmp(L); | |
| 2035 bep = cep = sep = | |
| 2036 iep = __ pc(); __ push_i(); | |
| 2037 vep = __ pc(); | |
| 2038 __ bind(L); | |
| 2039 generate_and_dispatch(t); | |
| 2040 } | |
| 2041 | |
| 2042 | |
| 2043 //----------------------------------------------------------------------------- | |
| 2044 // Generation of individual instructions | |
| 2045 | |
| 2046 // helpers for generate_and_dispatch | |
| 2047 | |
| 2048 | |
| 2049 InterpreterGenerator::InterpreterGenerator(StubQueue* code) | |
| 2050 : TemplateInterpreterGenerator(code) { | |
| 2051 generate_all(); // down here so it can be "virtual" | |
| 2052 } | |
| 2053 | |
| 2054 //----------------------------------------------------------------------------- | |
| 2055 | |
| 2056 // Non-product code | |
| 2057 #ifndef PRODUCT | |
| 2058 address TemplateInterpreterGenerator::generate_trace_code(TosState state) { | |
| 2059 address entry = __ pc(); | |
| 2060 | |
| 2061 __ push(state); | |
| 304 | 2062 __ push(c_rarg0); |
| 2063 __ push(c_rarg1); | |
| 2064 __ push(c_rarg2); | |
| 2065 __ push(c_rarg3); | |
| 2066 __ mov(c_rarg2, rax); // Pass itos | |
| 0 | 2067 #ifdef _WIN64 |
| 2068 __ movflt(xmm3, xmm0); // Pass ftos | |
| 2069 #endif | |
| 2070 __ call_VM(noreg, | |
| 2071 CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode), | |
| 2072 c_rarg1, c_rarg2, c_rarg3); | |
| 304 | 2073 __ pop(c_rarg3); |
| 2074 __ pop(c_rarg2); | |
| 2075 __ pop(c_rarg1); | |
| 2076 __ pop(c_rarg0); | |
| 0 | 2077 __ pop(state); |
| 2078 __ ret(0); // return from result handler | |
| 2079 | |
| 2080 return entry; | |
| 2081 } | |
| 2082 | |
| 2083 void TemplateInterpreterGenerator::count_bytecode() { | |
| 2084 __ incrementl(ExternalAddress((address) &BytecodeCounter::_counter_value)); | |
| 2085 } | |
| 2086 | |
| 2087 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { | |
| 2088 __ incrementl(ExternalAddress((address) &BytecodeHistogram::_counters[t->bytecode()])); | |
| 2089 } | |
| 2090 | |
| 2091 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { | |
| 2092 __ mov32(rbx, ExternalAddress((address) &BytecodePairHistogram::_index)); | |
| 2093 __ shrl(rbx, BytecodePairHistogram::log2_number_of_codes); | |
| 2094 __ orl(rbx, | |
| 2095 ((int) t->bytecode()) << | |
| 2096 BytecodePairHistogram::log2_number_of_codes); | |
| 2097 __ mov32(ExternalAddress((address) &BytecodePairHistogram::_index), rbx); | |
| 2098 __ lea(rscratch1, ExternalAddress((address) BytecodePairHistogram::_counters)); | |
| 2099 __ incrementl(Address(rscratch1, rbx, Address::times_4)); | |
| 2100 } | |
| 2101 | |
| 2102 | |
| 2103 void TemplateInterpreterGenerator::trace_bytecode(Template* t) { | |
| 2104 // Call a little run-time stub to avoid blow-up for each bytecode. | |
| 2105 // The run-time runtime saves the right registers, depending on | |
| 2106 // the tosca in-state for the given template. | |
| 2107 | |
| 2108 assert(Interpreter::trace_code(t->tos_in()) != NULL, | |
| 2109 "entry must have been generated"); | |
|
1976
0fc262af204f
6780143: hs203t003 hits SIGSEGV/EXCEPTION_ACCESS_VIOLATION with -XX:+UseCompressedOops
coleenp
parents:
1972
diff
changeset
|
2110 __ mov(r12, rsp); // remember sp (can only use r12 if not using call_VM) |
| 304 | 2111 __ andptr(rsp, -16); // align stack as required by ABI |
| 0 | 2112 __ call(RuntimeAddress(Interpreter::trace_code(t->tos_in()))); |
| 304 | 2113 __ mov(rsp, r12); // restore sp |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
2114 __ reinit_heapbase(); |
| 0 | 2115 } |
| 2116 | |
| 2117 | |
| 2118 void TemplateInterpreterGenerator::stop_interpreter_at() { | |
| 2119 Label L; | |
| 2120 __ cmp32(ExternalAddress((address) &BytecodeCounter::_counter_value), | |
| 2121 StopInterpreterAt); | |
| 2122 __ jcc(Assembler::notEqual, L); | |
| 2123 __ int3(); | |
| 2124 __ bind(L); | |
| 2125 } | |
| 2126 #endif // !PRODUCT | |
| 304 | 2127 #endif // ! CC_INTERP |