Mercurial > hg > truffle
annotate src/share/vm/ci/ciMethod.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 | 849eb7bfceac |
| children | 96d2c94bbdd0 d8a0bb6f62a5 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
2 * Copyright (c) 1999, 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:
1251
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1251
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:
1251
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "ci/ciCallProfile.hpp" | |
| 27 #include "ci/ciExceptionHandler.hpp" | |
| 28 #include "ci/ciInstanceKlass.hpp" | |
| 29 #include "ci/ciMethod.hpp" | |
| 30 #include "ci/ciMethodBlocks.hpp" | |
| 31 #include "ci/ciMethodData.hpp" | |
| 32 #include "ci/ciStreams.hpp" | |
| 33 #include "ci/ciSymbol.hpp" | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
34 #include "ci/ciReplay.hpp" |
| 1972 | 35 #include "ci/ciUtilities.hpp" |
| 36 #include "classfile/systemDictionary.hpp" | |
| 37 #include "compiler/abstractCompiler.hpp" | |
| 38 #include "compiler/compilerOracle.hpp" | |
| 39 #include "compiler/methodLiveness.hpp" | |
| 40 #include "interpreter/interpreter.hpp" | |
| 41 #include "interpreter/linkResolver.hpp" | |
| 42 #include "interpreter/oopMapCache.hpp" | |
| 43 #include "memory/allocation.inline.hpp" | |
| 44 #include "memory/resourceArea.hpp" | |
| 45 #include "oops/generateOopMap.hpp" | |
| 46 #include "oops/oop.inline.hpp" | |
| 47 #include "prims/nativeLookup.hpp" | |
| 48 #include "runtime/deoptimization.hpp" | |
| 49 #include "utilities/bitMap.inline.hpp" | |
| 50 #include "utilities/xmlstream.hpp" | |
| 51 #ifdef COMPILER2 | |
| 52 #include "ci/bcEscapeAnalyzer.hpp" | |
| 53 #include "ci/ciTypeFlow.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
54 #include "oops/method.hpp" |
| 1972 | 55 #endif |
| 56 #ifdef SHARK | |
| 57 #include "ci/ciTypeFlow.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
58 #include "oops/method.hpp" |
| 1972 | 59 #endif |
| 0 | 60 |
| 61 // ciMethod | |
| 62 // | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
63 // This class represents a Method* in the HotSpot virtual |
| 0 | 64 // machine. |
| 65 | |
| 66 | |
| 67 // ------------------------------------------------------------------ | |
| 68 // ciMethod::ciMethod | |
| 69 // | |
| 70 // Loaded method. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
71 ciMethod::ciMethod(methodHandle h_m) : ciMetadata(h_m()) { |
| 0 | 72 assert(h_m() != NULL, "no null method"); |
| 73 | |
| 74 // These fields are always filled in in loaded methods. | |
| 75 _flags = ciFlags(h_m()->access_flags()); | |
| 76 | |
| 77 // Easy to compute, so fill them in now. | |
| 78 _max_stack = h_m()->max_stack(); | |
| 79 _max_locals = h_m()->max_locals(); | |
| 80 _code_size = h_m()->code_size(); | |
| 81 _intrinsic_id = h_m()->intrinsic_id(); | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
82 _handler_count = h_m()->exception_table_length(); |
| 0 | 83 _uses_monitors = h_m()->access_flags().has_monitor_bytecodes(); |
| 84 _balanced_monitors = !_uses_monitors || h_m()->access_flags().is_monitor_matching(); | |
| 1783 | 85 _is_c1_compilable = !h_m()->is_not_c1_compilable(); |
| 86 _is_c2_compilable = !h_m()->is_not_c2_compilable(); | |
| 0 | 87 // Lazy fields, filled in on demand. Require allocation. |
| 88 _code = NULL; | |
| 89 _exception_handlers = NULL; | |
| 90 _liveness = NULL; | |
| 91 _method_blocks = NULL; | |
| 1692 | 92 #if defined(COMPILER2) || defined(SHARK) |
| 0 | 93 _flow = NULL; |
|
1648
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
94 _bcea = NULL; |
| 1692 | 95 #endif // COMPILER2 || SHARK |
| 0 | 96 |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
710
diff
changeset
|
97 ciEnv *env = CURRENT_ENV; |
| 1783 | 98 if (env->jvmti_can_hotswap_or_post_breakpoint() && can_be_compiled()) { |
| 0 | 99 // 6328518 check hotswap conditions under the right lock. |
| 100 MutexLocker locker(Compile_lock); | |
| 101 if (Dependencies::check_evol_method(h_m()) != NULL) { | |
| 1783 | 102 _is_c1_compilable = false; |
| 103 _is_c2_compilable = false; | |
| 0 | 104 } |
| 105 } else { | |
| 106 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | |
| 107 } | |
| 108 | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6725
diff
changeset
|
109 if (h_m()->method_holder()->is_linked()) { |
| 0 | 110 _can_be_statically_bound = h_m()->can_be_statically_bound(); |
| 111 } else { | |
| 112 // Have to use a conservative value in this case. | |
| 113 _can_be_statically_bound = false; | |
| 114 } | |
| 115 | |
| 116 // Adjust the definition of this condition to be more useful: | |
| 117 // %%% take these conditions into account in vtable generation | |
| 118 if (!_can_be_statically_bound && h_m()->is_private()) | |
| 119 _can_be_statically_bound = true; | |
| 120 if (_can_be_statically_bound && h_m()->is_abstract()) | |
| 121 _can_be_statically_bound = false; | |
| 122 | |
| 123 // generating _signature may allow GC and therefore move m. | |
| 124 // These fields are always filled in. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
125 _name = env->get_symbol(h_m()->name()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
126 _holder = env->get_instance_klass(h_m()->method_holder()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
127 ciSymbol* sig_symbol = env->get_symbol(h_m()->signature()); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
2357
diff
changeset
|
128 constantPoolHandle cpool = h_m()->constants(); |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
2357
diff
changeset
|
129 _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol); |
| 0 | 130 _method_data = NULL; |
| 131 // Take a snapshot of these values, so they will be commensurate with the MDO. | |
| 1783 | 132 if (ProfileInterpreter || TieredCompilation) { |
| 0 | 133 int invcnt = h_m()->interpreter_invocation_count(); |
| 134 // if the value overflowed report it as max int | |
| 135 _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ; | |
| 136 _interpreter_throwout_count = h_m()->interpreter_throwout_count(); | |
| 137 } else { | |
| 138 _interpreter_invocation_count = 0; | |
| 139 _interpreter_throwout_count = 0; | |
| 140 } | |
| 141 if (_interpreter_invocation_count == 0) | |
| 142 _interpreter_invocation_count = 1; | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
143 _instructions_size = -1; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
144 #ifdef ASSERT |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
145 if (ReplayCompiles) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
146 ciReplay::initialize(this); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
147 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
148 #endif |
| 0 | 149 } |
| 150 | |
| 151 | |
| 152 // ------------------------------------------------------------------ | |
| 153 // ciMethod::ciMethod | |
| 154 // | |
| 155 // Unloaded method. | |
| 156 ciMethod::ciMethod(ciInstanceKlass* holder, | |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
157 ciSymbol* name, |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
158 ciSymbol* signature, |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
159 ciInstanceKlass* accessor) : |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
160 ciMetadata((Metadata*)NULL), |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
161 _name( name), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
162 _holder( holder), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
163 _intrinsic_id( vmIntrinsics::_none), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
164 _liveness( NULL), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
165 _can_be_statically_bound(false), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
166 _method_blocks( NULL), |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
167 _method_data( NULL) |
| 1692 | 168 #if defined(COMPILER2) || defined(SHARK) |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
169 , |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
170 _flow( NULL), |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
171 _bcea( NULL), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
172 _instructions_size(-1) |
| 1692 | 173 #endif // COMPILER2 || SHARK |
|
4001
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
174 { |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
175 // Usually holder and accessor are the same type but in some cases |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
176 // the holder has the wrong class loader (e.g. invokedynamic call |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
177 // sites) so we pass the accessor. |
|
5eb9169b1a14
7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents:
3897
diff
changeset
|
178 _signature = new (CURRENT_ENV->arena()) ciSignature(accessor, constantPoolHandle(), signature); |
| 0 | 179 } |
| 180 | |
| 181 | |
| 182 // ------------------------------------------------------------------ | |
| 183 // ciMethod::load_code | |
| 184 // | |
| 185 // Load the bytecodes and exception handler table for this method. | |
| 186 void ciMethod::load_code() { | |
| 187 VM_ENTRY_MARK; | |
| 188 assert(is_loaded(), "only loaded methods have code"); | |
| 189 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
190 Method* me = get_Method(); |
| 0 | 191 Arena* arena = CURRENT_THREAD_ENV->arena(); |
| 192 | |
| 193 // Load the bytecodes. | |
| 194 _code = (address)arena->Amalloc(code_size()); | |
| 195 memcpy(_code, me->code_base(), code_size()); | |
| 196 | |
| 197 // Revert any breakpoint bytecodes in ci's copy | |
|
27
1f530c629c7d
6498878: client compiler crashes on windows when dealing with breakpoint instructions
kvn
parents:
0
diff
changeset
|
198 if (me->number_of_breakpoints() > 0) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6725
diff
changeset
|
199 BreakpointInfo* bp = me->method_holder()->breakpoints(); |
| 0 | 200 for (; bp != NULL; bp = bp->next()) { |
| 201 if (bp->match(me)) { | |
| 202 code_at_put(bp->bci(), bp->orig_bytecode()); | |
| 203 } | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 // And load the exception table. | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
208 ExceptionTable exc_table(me); |
| 0 | 209 |
| 210 // Allocate one extra spot in our list of exceptions. This | |
| 211 // last entry will be used to represent the possibility that | |
| 212 // an exception escapes the method. See ciExceptionHandlerStream | |
| 213 // for details. | |
| 214 _exception_handlers = | |
| 215 (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*) | |
| 216 * (_handler_count + 1)); | |
| 217 if (_handler_count > 0) { | |
| 218 for (int i=0; i<_handler_count; i++) { | |
| 219 _exception_handlers[i] = new (arena) ciExceptionHandler( | |
| 220 holder(), | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
221 /* start */ exc_table.start_pc(i), |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
222 /* limit */ exc_table.end_pc(i), |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
223 /* goto pc */ exc_table.handler_pc(i), |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
4001
diff
changeset
|
224 /* cp index */ exc_table.catch_type_index(i)); |
| 0 | 225 } |
| 226 } | |
| 227 | |
| 228 // Put an entry at the end of our list to represent the possibility | |
| 229 // of exceptional exit. | |
| 230 _exception_handlers[_handler_count] = | |
| 231 new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0); | |
| 232 | |
| 233 if (CIPrintMethodCodes) { | |
| 234 print_codes(); | |
| 235 } | |
| 236 } | |
| 237 | |
| 238 | |
| 239 // ------------------------------------------------------------------ | |
| 240 // ciMethod::has_linenumber_table | |
| 241 // | |
| 242 // length unknown until decompression | |
| 243 bool ciMethod::has_linenumber_table() const { | |
| 244 check_is_loaded(); | |
| 245 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
246 return get_Method()->has_linenumber_table(); |
| 0 | 247 } |
| 248 | |
| 249 | |
| 250 // ------------------------------------------------------------------ | |
| 251 // ciMethod::compressed_linenumber_table | |
| 252 u_char* ciMethod::compressed_linenumber_table() const { | |
| 253 check_is_loaded(); | |
| 254 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
255 return get_Method()->compressed_linenumber_table(); |
| 0 | 256 } |
| 257 | |
| 258 | |
| 259 // ------------------------------------------------------------------ | |
| 260 // ciMethod::line_number_from_bci | |
| 261 int ciMethod::line_number_from_bci(int bci) const { | |
| 262 check_is_loaded(); | |
| 263 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
264 return get_Method()->line_number_from_bci(bci); |
| 0 | 265 } |
| 266 | |
| 267 | |
| 268 // ------------------------------------------------------------------ | |
| 269 // ciMethod::vtable_index | |
| 270 // | |
| 271 // Get the position of this method's entry in the vtable, if any. | |
| 272 int ciMethod::vtable_index() { | |
| 273 check_is_loaded(); | |
| 274 assert(holder()->is_linked(), "must be linked"); | |
| 275 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
276 return get_Method()->vtable_index(); |
| 0 | 277 } |
| 278 | |
| 279 | |
| 1692 | 280 #ifdef SHARK |
| 281 // ------------------------------------------------------------------ | |
| 282 // ciMethod::itable_index | |
| 283 // | |
| 284 // Get the position of this method's entry in the itable, if any. | |
| 285 int ciMethod::itable_index() { | |
| 286 check_is_loaded(); | |
| 287 assert(holder()->is_linked(), "must be linked"); | |
| 288 VM_ENTRY_MARK; | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
289 Method* m = get_Method(); |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
290 if (!m->has_itable_index()) |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
291 return Method::nonvirtual_vtable_index; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
292 return m->itable_index(); |
| 1692 | 293 } |
| 294 #endif // SHARK | |
| 295 | |
| 296 | |
| 0 | 297 // ------------------------------------------------------------------ |
| 298 // ciMethod::native_entry | |
| 299 // | |
| 300 // Get the address of this method's native code, if any. | |
| 301 address ciMethod::native_entry() { | |
| 302 check_is_loaded(); | |
| 303 assert(flags().is_native(), "must be native method"); | |
| 304 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
305 Method* method = get_Method(); |
| 0 | 306 address entry = method->native_function(); |
| 307 assert(entry != NULL, "must be valid entry point"); | |
| 308 return entry; | |
| 309 } | |
| 310 | |
| 311 | |
| 312 // ------------------------------------------------------------------ | |
| 313 // ciMethod::interpreter_entry | |
| 314 // | |
| 315 // Get the entry point for running this method in the interpreter. | |
| 316 address ciMethod::interpreter_entry() { | |
| 317 check_is_loaded(); | |
| 318 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
319 methodHandle mh(THREAD, get_Method()); |
| 0 | 320 return Interpreter::entry_for_method(mh); |
| 321 } | |
| 322 | |
| 323 | |
| 324 // ------------------------------------------------------------------ | |
| 325 // ciMethod::uses_balanced_monitors | |
| 326 // | |
| 327 // Does this method use monitors in a strict stack-disciplined manner? | |
| 328 bool ciMethod::has_balanced_monitors() { | |
| 329 check_is_loaded(); | |
| 330 if (_balanced_monitors) return true; | |
| 331 | |
| 332 // Analyze the method to see if monitors are used properly. | |
| 333 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
334 methodHandle method(THREAD, get_Method()); |
| 0 | 335 assert(method->has_monitor_bytecodes(), "should have checked this"); |
| 336 | |
| 337 // Check to see if a previous compilation computed the | |
| 338 // monitor-matching analysis. | |
| 339 if (method->guaranteed_monitor_matching()) { | |
| 340 _balanced_monitors = true; | |
| 341 return true; | |
| 342 } | |
| 343 | |
| 344 { | |
| 345 EXCEPTION_MARK; | |
| 346 ResourceMark rm(THREAD); | |
| 347 GeneratePairingInfo gpi(method); | |
| 348 gpi.compute_map(CATCH); | |
| 349 if (!gpi.monitor_safe()) { | |
| 350 return false; | |
| 351 } | |
| 352 method->set_guaranteed_monitor_matching(); | |
| 353 _balanced_monitors = true; | |
| 354 } | |
| 355 return true; | |
| 356 } | |
| 357 | |
| 358 | |
| 359 // ------------------------------------------------------------------ | |
| 360 // ciMethod::get_flow_analysis | |
| 361 ciTypeFlow* ciMethod::get_flow_analysis() { | |
| 1692 | 362 #if defined(COMPILER2) || defined(SHARK) |
| 0 | 363 if (_flow == NULL) { |
| 364 ciEnv* env = CURRENT_ENV; | |
| 365 _flow = new (env->arena()) ciTypeFlow(env, this); | |
| 366 _flow->do_flow(); | |
| 367 } | |
| 368 return _flow; | |
| 1692 | 369 #else // COMPILER2 || SHARK |
| 0 | 370 ShouldNotReachHere(); |
| 371 return NULL; | |
| 1692 | 372 #endif // COMPILER2 || SHARK |
| 0 | 373 } |
| 374 | |
| 375 | |
| 376 // ------------------------------------------------------------------ | |
| 377 // ciMethod::get_osr_flow_analysis | |
| 378 ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) { | |
| 1692 | 379 #if defined(COMPILER2) || defined(SHARK) |
| 0 | 380 // OSR entry points are always place after a call bytecode of some sort |
| 381 assert(osr_bci >= 0, "must supply valid OSR entry point"); | |
| 382 ciEnv* env = CURRENT_ENV; | |
| 383 ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci); | |
| 384 flow->do_flow(); | |
| 385 return flow; | |
| 1692 | 386 #else // COMPILER2 || SHARK |
| 0 | 387 ShouldNotReachHere(); |
| 388 return NULL; | |
| 1692 | 389 #endif // COMPILER2 || SHARK |
| 0 | 390 } |
| 391 | |
| 392 // ------------------------------------------------------------------ | |
| 991 | 393 // ciMethod::raw_liveness_at_bci |
| 0 | 394 // |
| 395 // Which local variables are live at a specific bci? | |
| 991 | 396 MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) { |
| 0 | 397 check_is_loaded(); |
| 398 if (_liveness == NULL) { | |
| 399 // Create the liveness analyzer. | |
| 400 Arena* arena = CURRENT_ENV->arena(); | |
| 401 _liveness = new (arena) MethodLiveness(arena, this); | |
| 402 _liveness->compute_liveness(); | |
| 403 } | |
| 991 | 404 return _liveness->get_liveness_at(bci); |
| 405 } | |
| 406 | |
| 407 // ------------------------------------------------------------------ | |
| 408 // ciMethod::liveness_at_bci | |
| 409 // | |
| 410 // Which local variables are live at a specific bci? When debugging | |
| 411 // will return true for all locals in some cases to improve debug | |
| 412 // information. | |
| 413 MethodLivenessResult ciMethod::liveness_at_bci(int bci) { | |
| 414 MethodLivenessResult result = raw_liveness_at_bci(bci); | |
|
780
c96bf21b756f
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents:
710
diff
changeset
|
415 if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) { |
| 0 | 416 // Keep all locals live for the user's edification and amusement. |
| 417 result.at_put_range(0, result.size(), true); | |
| 418 } | |
| 419 return result; | |
| 420 } | |
| 421 | |
| 422 // ciMethod::live_local_oops_at_bci | |
| 423 // | |
| 424 // find all the live oops in the locals array for a particular bci | |
| 425 // Compute what the interpreter believes by using the interpreter | |
| 426 // oopmap generator. This is used as a double check during osr to | |
| 427 // guard against conservative result from MethodLiveness making us | |
| 428 // think a dead oop is live. MethodLiveness is conservative in the | |
| 429 // sense that it may consider locals to be live which cannot be live, | |
| 430 // like in the case where a local could contain an oop or a primitive | |
| 431 // along different paths. In that case the local must be dead when | |
| 432 // those paths merge. Since the interpreter's viewpoint is used when | |
| 433 // gc'ing an interpreter frame we need to use its viewpoint during | |
| 434 // OSR when loading the locals. | |
| 435 | |
| 436 BitMap ciMethod::live_local_oops_at_bci(int bci) { | |
| 437 VM_ENTRY_MARK; | |
| 438 InterpreterOopMap mask; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
439 OopMapCache::compute_one_oop_map(get_Method(), bci, &mask); |
| 0 | 440 int mask_size = max_locals(); |
| 441 BitMap result(mask_size); | |
| 442 result.clear(); | |
| 443 int i; | |
| 444 for (i = 0; i < mask_size ; i++ ) { | |
| 445 if (mask.is_oop(i)) result.set_bit(i); | |
| 446 } | |
| 447 return result; | |
| 448 } | |
| 449 | |
| 450 | |
| 451 #ifdef COMPILER1 | |
| 452 // ------------------------------------------------------------------ | |
| 453 // ciMethod::bci_block_start | |
| 454 // | |
| 455 // Marks all bcis where a new basic block starts | |
| 456 const BitMap ciMethod::bci_block_start() { | |
| 457 check_is_loaded(); | |
| 458 if (_liveness == NULL) { | |
| 459 // Create the liveness analyzer. | |
| 460 Arena* arena = CURRENT_ENV->arena(); | |
| 461 _liveness = new (arena) MethodLiveness(arena, this); | |
| 462 _liveness->compute_liveness(); | |
| 463 } | |
| 464 | |
| 465 return _liveness->get_bci_block_start(); | |
| 466 } | |
| 467 #endif // COMPILER1 | |
| 468 | |
| 469 | |
| 470 // ------------------------------------------------------------------ | |
| 471 // ciMethod::call_profile_at_bci | |
| 472 // | |
| 473 // Get the ciCallProfile for the invocation of this method. | |
| 474 // Also reports receiver types for non-call type checks (if TypeProfileCasts). | |
| 475 ciCallProfile ciMethod::call_profile_at_bci(int bci) { | |
| 476 ResourceMark rm; | |
| 477 ciCallProfile result; | |
| 478 if (method_data() != NULL && method_data()->is_mature()) { | |
| 479 ciProfileData* data = method_data()->bci_to_data(bci); | |
| 480 if (data != NULL && data->is_CounterData()) { | |
| 481 // Every profiled call site has a counter. | |
| 482 int count = data->as_CounterData()->count(); | |
| 483 | |
| 484 if (!data->is_ReceiverTypeData()) { | |
| 485 result._receiver_count[0] = 0; // that's a definite zero | |
| 486 } else { // ReceiverTypeData is a subclass of CounterData | |
| 487 ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData(); | |
| 488 // In addition, virtual call sites have receiver type information | |
| 489 int receivers_count_total = 0; | |
| 490 int morphism = 0; | |
| 1783 | 491 // Precompute morphism for the possible fixup |
| 0 | 492 for (uint i = 0; i < call->row_limit(); i++) { |
| 493 ciKlass* receiver = call->receiver(i); | |
| 494 if (receiver == NULL) continue; | |
| 1783 | 495 morphism++; |
| 496 } | |
| 497 int epsilon = 0; | |
| 498 if (TieredCompilation && ProfileInterpreter) { | |
| 499 // Interpreter and C1 treat final and special invokes differently. | |
| 500 // C1 will record a type, whereas the interpreter will just | |
| 501 // increment the count. Detect this case. | |
| 502 if (morphism == 1 && count > 0) { | |
| 503 epsilon = count; | |
| 504 count = 0; | |
| 505 } | |
| 506 } | |
| 507 for (uint i = 0; i < call->row_limit(); i++) { | |
| 508 ciKlass* receiver = call->receiver(i); | |
| 509 if (receiver == NULL) continue; | |
| 510 int rcount = call->receiver_count(i) + epsilon; | |
| 0 | 511 if (rcount == 0) rcount = 1; // Should be valid value |
| 512 receivers_count_total += rcount; | |
| 513 // Add the receiver to result data. | |
| 514 result.add_receiver(receiver, rcount); | |
| 515 // If we extend profiling to record methods, | |
| 516 // we will set result._method also. | |
| 517 } | |
| 518 // Determine call site's morphism. | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
519 // The call site count is 0 with known morphism (onlt 1 or 2 receivers) |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
520 // or < 0 in the case of a type check failured for checkcast, aastore, instanceof. |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
521 // The call site count is > 0 in the case of a polymorphic virtual call. |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
522 if (morphism > 0 && morphism == result._limit) { |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
523 // The morphism <= MorphismLimit. |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
524 if ((morphism < ciCallProfile::MorphismLimit) || |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
525 (morphism == ciCallProfile::MorphismLimit && count == 0)) { |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
526 #ifdef ASSERT |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
527 if (count > 0) { |
|
1251
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
528 this->print_short_name(tty); |
|
576e77447e3c
6923002: assert(false,"this call site should not be polymorphic")
kvn
parents:
1206
diff
changeset
|
529 tty->print_cr(" @ bci:%d", bci); |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
530 this->print_codes(); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
531 assert(false, "this call site should not be polymorphic"); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
532 } |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
533 #endif |
| 0 | 534 result._morphism = morphism; |
| 535 } | |
| 536 } | |
| 537 // Make the count consistent if this is a call profile. If count is | |
| 538 // zero or less, presume that this is a typecheck profile and | |
| 539 // do nothing. Otherwise, increase count to be the sum of all | |
| 540 // receiver's counts. | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
541 if (count >= 0) { |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1152
diff
changeset
|
542 count += receivers_count_total; |
| 0 | 543 } |
| 544 } | |
| 545 result._count = count; | |
| 546 } | |
| 547 } | |
| 548 return result; | |
| 549 } | |
| 550 | |
| 551 // ------------------------------------------------------------------ | |
| 552 // Add new receiver and sort data by receiver's profile count. | |
| 553 void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) { | |
| 554 // Add new receiver and sort data by receiver's counts when we have space | |
| 555 // for it otherwise replace the less called receiver (less called receiver | |
| 556 // is placed to the last array element which is not used). | |
| 557 // First array's element contains most called receiver. | |
| 558 int i = _limit; | |
| 559 for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) { | |
| 560 _receiver[i] = _receiver[i-1]; | |
| 561 _receiver_count[i] = _receiver_count[i-1]; | |
| 562 } | |
| 563 _receiver[i] = receiver; | |
| 564 _receiver_count[i] = receiver_count; | |
| 565 if (_limit < MorphismLimit) _limit++; | |
| 566 } | |
| 567 | |
| 12966 | 568 |
| 569 void ciMethod::assert_virtual_call_type_ok(int bci) { | |
| 570 assert(java_code_at_bci(bci) == Bytecodes::_invokevirtual || | |
| 571 java_code_at_bci(bci) == Bytecodes::_invokeinterface, err_msg("unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)))); | |
| 572 } | |
| 573 | |
| 574 void ciMethod::assert_call_type_ok(int bci) { | |
| 575 assert(java_code_at_bci(bci) == Bytecodes::_invokestatic || | |
| 576 java_code_at_bci(bci) == Bytecodes::_invokespecial || | |
| 577 java_code_at_bci(bci) == Bytecodes::_invokedynamic, err_msg("unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)))); | |
| 578 } | |
| 579 | |
| 580 /** | |
| 581 * Check whether profiling provides a type for the argument i to the | |
| 582 * call at bci bci | |
| 583 * | |
| 584 * @param bci bci of the call | |
| 585 * @param i argument number | |
| 586 * @return profiled type | |
| 587 * | |
| 588 * If the profile reports that the argument may be null, return false | |
| 589 * at least for now. | |
| 590 */ | |
| 591 ciKlass* ciMethod::argument_profiled_type(int bci, int i) { | |
| 592 if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) { | |
| 593 ciProfileData* data = method_data()->bci_to_data(bci); | |
| 594 if (data != NULL) { | |
| 595 if (data->is_VirtualCallTypeData()) { | |
| 596 assert_virtual_call_type_ok(bci); | |
| 597 ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData(); | |
| 598 if (i >= call->number_of_arguments()) { | |
| 599 return NULL; | |
| 600 } | |
| 601 ciKlass* type = call->valid_argument_type(i); | |
| 602 if (type != NULL && !call->argument_maybe_null(i)) { | |
| 603 return type; | |
| 604 } | |
| 605 } else if (data->is_CallTypeData()) { | |
| 606 assert_call_type_ok(bci); | |
| 607 ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData(); | |
| 608 if (i >= call->number_of_arguments()) { | |
| 609 return NULL; | |
| 610 } | |
| 611 ciKlass* type = call->valid_argument_type(i); | |
| 612 if (type != NULL && !call->argument_maybe_null(i)) { | |
| 613 return type; | |
| 614 } | |
| 615 } | |
| 616 } | |
| 617 } | |
| 618 return NULL; | |
| 619 } | |
| 620 | |
| 621 /** | |
| 622 * Check whether profiling provides a type for the return value from | |
| 623 * the call at bci bci | |
| 624 * | |
| 625 * @param bci bci of the call | |
| 626 * @return profiled type | |
| 627 * | |
| 628 * If the profile reports that the argument may be null, return false | |
| 629 * at least for now. | |
| 630 */ | |
| 631 ciKlass* ciMethod::return_profiled_type(int bci) { | |
| 632 if (MethodData::profile_return() && method_data() != NULL && method_data()->is_mature()) { | |
| 633 ciProfileData* data = method_data()->bci_to_data(bci); | |
| 634 if (data != NULL) { | |
| 635 if (data->is_VirtualCallTypeData()) { | |
| 636 assert_virtual_call_type_ok(bci); | |
| 637 ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData(); | |
| 638 ciKlass* type = call->valid_return_type(); | |
| 639 if (type != NULL && !call->return_maybe_null()) { | |
| 640 return type; | |
| 641 } | |
| 642 } else if (data->is_CallTypeData()) { | |
| 643 assert_call_type_ok(bci); | |
| 644 ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData(); | |
| 645 ciKlass* type = call->valid_return_type(); | |
| 646 if (type != NULL && !call->return_maybe_null()) { | |
| 647 return type; | |
| 648 } | |
| 649 } | |
| 650 } | |
| 651 } | |
| 652 return NULL; | |
| 653 } | |
| 654 | |
| 655 /** | |
| 656 * Check whether profiling provides a type for the parameter i | |
| 657 * | |
| 658 * @param i parameter number | |
| 659 * @return profiled type | |
| 660 * | |
| 661 * If the profile reports that the argument may be null, return false | |
| 662 * at least for now. | |
| 663 */ | |
| 664 ciKlass* ciMethod::parameter_profiled_type(int i) { | |
| 665 if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) { | |
| 666 ciParametersTypeData* parameters = method_data()->parameters_type_data(); | |
| 667 if (parameters != NULL && i < parameters->number_of_parameters()) { | |
| 668 ciKlass* type = parameters->valid_parameter_type(i); | |
| 669 if (type != NULL && !parameters->parameter_maybe_null(i)) { | |
| 670 return type; | |
| 671 } | |
| 672 } | |
| 673 } | |
| 674 return NULL; | |
| 675 } | |
| 676 | |
| 677 | |
| 0 | 678 // ------------------------------------------------------------------ |
| 679 // ciMethod::find_monomorphic_target | |
| 680 // | |
| 681 // Given a certain calling environment, find the monomorphic target | |
| 682 // for the call. Return NULL if the call is not monomorphic in | |
| 683 // its calling environment, or if there are only abstract methods. | |
| 684 // The returned method is never abstract. | |
| 685 // Note: If caller uses a non-null result, it must inform dependencies | |
| 686 // via assert_unique_concrete_method or assert_leaf_type. | |
| 687 ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller, | |
| 688 ciInstanceKlass* callee_holder, | |
| 689 ciInstanceKlass* actual_recv) { | |
| 690 check_is_loaded(); | |
| 691 | |
| 692 if (actual_recv->is_interface()) { | |
| 693 // %%% We cannot trust interface types, yet. See bug 6312651. | |
| 694 return NULL; | |
| 695 } | |
| 696 | |
| 697 ciMethod* root_m = resolve_invoke(caller, actual_recv); | |
| 698 if (root_m == NULL) { | |
| 699 // Something went wrong looking up the actual receiver method. | |
| 700 return NULL; | |
| 701 } | |
| 702 assert(!root_m->is_abstract(), "resolve_invoke promise"); | |
| 703 | |
| 704 // Make certain quick checks even if UseCHA is false. | |
| 705 | |
| 706 // Is it private or final? | |
| 707 if (root_m->can_be_statically_bound()) { | |
| 708 return root_m; | |
| 709 } | |
| 710 | |
| 711 if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) { | |
| 712 // Easy case. There is no other place to put a method, so don't bother | |
| 713 // to go through the VM_ENTRY_MARK and all the rest. | |
| 714 return root_m; | |
| 715 } | |
| 716 | |
| 717 // Array methods (clone, hashCode, etc.) are always statically bound. | |
| 718 // If we were to see an array type here, we'd return root_m. | |
| 719 // However, this method processes only ciInstanceKlasses. (See 4962591.) | |
| 720 // The inline_native_clone intrinsic narrows Object to T[] properly, | |
| 721 // so there is no need to do the same job here. | |
| 722 | |
| 723 if (!UseCHA) return NULL; | |
| 724 | |
| 725 VM_ENTRY_MARK; | |
| 726 | |
| 727 methodHandle target; | |
| 728 { | |
| 729 MutexLocker locker(Compile_lock); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
730 Klass* context = actual_recv->get_Klass(); |
| 0 | 731 target = Dependencies::find_unique_concrete_method(context, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
732 root_m->get_Method()); |
| 0 | 733 // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods. |
| 734 } | |
| 735 | |
| 736 #ifndef PRODUCT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
737 if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) { |
| 0 | 738 tty->print("found a non-root unique target method"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
739 tty->print_cr(" context = %s", InstanceKlass::cast(actual_recv->get_Klass())->external_name()); |
| 0 | 740 tty->print(" method = "); |
| 741 target->print_short_name(tty); | |
| 742 tty->cr(); | |
| 743 } | |
| 744 #endif //PRODUCT | |
| 745 | |
| 746 if (target() == NULL) { | |
| 747 return NULL; | |
| 748 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
749 if (target() == root_m->get_Method()) { |
| 0 | 750 return root_m; |
| 751 } | |
| 752 if (!root_m->is_public() && | |
| 753 !root_m->is_protected()) { | |
| 754 // If we are going to reason about inheritance, it's easiest | |
| 755 // if the method in question is public, protected, or private. | |
| 756 // If the answer is not root_m, it is conservatively correct | |
| 757 // to return NULL, even if the CHA encountered irrelevant | |
| 758 // methods in other packages. | |
| 759 // %%% TO DO: Work out logic for package-private methods | |
| 760 // with the same name but different vtable indexes. | |
| 761 return NULL; | |
| 762 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
763 return CURRENT_THREAD_ENV->get_method(target()); |
| 0 | 764 } |
| 765 | |
| 766 // ------------------------------------------------------------------ | |
| 767 // ciMethod::resolve_invoke | |
| 768 // | |
| 769 // Given a known receiver klass, find the target for the call. | |
| 770 // Return NULL if the call has no target or the target is abstract. | |
| 771 ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) { | |
| 772 check_is_loaded(); | |
| 773 VM_ENTRY_MARK; | |
| 774 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
775 KlassHandle caller_klass (THREAD, caller->get_Klass()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
776 KlassHandle h_recv (THREAD, exact_receiver->get_Klass()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
777 KlassHandle h_resolved (THREAD, holder()->get_Klass()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
778 Symbol* h_name = name()->get_symbol(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
779 Symbol* h_signature = signature()->get_symbol(); |
| 0 | 780 |
| 781 methodHandle m; | |
| 782 // Only do exact lookup if receiver klass has been linked. Otherwise, | |
| 783 // the vtable has not been setup, and the LinkResolver will fail. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
784 if (h_recv->oop_is_array() |
| 0 | 785 || |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
786 InstanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) { |
| 0 | 787 if (holder()->is_interface()) { |
| 788 m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass); | |
| 789 } else { | |
| 790 m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass); | |
| 791 } | |
| 792 } | |
| 793 | |
| 794 if (m.is_null()) { | |
| 795 // Return NULL only if there was a problem with lookup (uninitialized class, etc.) | |
| 796 return NULL; | |
| 797 } | |
| 798 | |
| 799 ciMethod* result = this; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
800 if (m() != get_Method()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
801 result = CURRENT_THREAD_ENV->get_method(m()); |
| 0 | 802 } |
| 803 | |
| 804 // Don't return abstract methods because they aren't | |
| 805 // optimizable or interesting. | |
| 806 if (result->is_abstract()) { | |
| 807 return NULL; | |
| 808 } else { | |
| 809 return result; | |
| 810 } | |
| 811 } | |
| 812 | |
| 813 // ------------------------------------------------------------------ | |
| 814 // ciMethod::resolve_vtable_index | |
| 815 // | |
| 816 // Given a known receiver klass, find the vtable index for the call. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
817 // Return Method::invalid_vtable_index if the vtable_index is unknown. |
| 0 | 818 int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) { |
| 819 check_is_loaded(); | |
| 820 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
821 int vtable_index = Method::invalid_vtable_index; |
| 0 | 822 // Only do lookup if receiver klass has been linked. Otherwise, |
| 823 // the vtable has not been setup, and the LinkResolver will fail. | |
| 824 if (!receiver->is_interface() | |
| 825 && (!receiver->is_instance_klass() || | |
| 826 receiver->as_instance_klass()->is_linked())) { | |
| 827 VM_ENTRY_MARK; | |
| 828 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
829 KlassHandle caller_klass (THREAD, caller->get_Klass()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
830 KlassHandle h_recv (THREAD, receiver->get_Klass()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
831 Symbol* h_name = name()->get_symbol(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2007
diff
changeset
|
832 Symbol* h_signature = signature()->get_symbol(); |
| 0 | 833 |
| 834 vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
835 if (vtable_index == Method::nonvirtual_vtable_index) { |
| 0 | 836 // A statically bound method. Return "no such index". |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
837 vtable_index = Method::invalid_vtable_index; |
| 0 | 838 } |
| 839 } | |
| 840 | |
| 841 return vtable_index; | |
| 842 } | |
| 843 | |
| 844 // ------------------------------------------------------------------ | |
| 845 // ciMethod::interpreter_call_site_count | |
| 846 int ciMethod::interpreter_call_site_count(int bci) { | |
| 847 if (method_data() != NULL) { | |
| 848 ResourceMark rm; | |
| 849 ciProfileData* data = method_data()->bci_to_data(bci); | |
| 850 if (data != NULL && data->is_CounterData()) { | |
| 851 return scale_count(data->as_CounterData()->count()); | |
| 852 } | |
| 853 } | |
| 854 return -1; // unknown | |
| 855 } | |
| 856 | |
| 857 // ------------------------------------------------------------------ | |
|
7194
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
858 // ciMethod::get_field_at_bci |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
859 ciField* ciMethod::get_field_at_bci(int bci, bool &will_link) { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
860 ciBytecodeStream iter(this); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
861 iter.reset_to_bci(bci); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
862 iter.next(); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
863 return iter.get_field(will_link); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
864 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
865 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
866 // ------------------------------------------------------------------ |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
867 // ciMethod::get_method_at_bci |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
868 ciMethod* ciMethod::get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature) { |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
869 ciBytecodeStream iter(this); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
870 iter.reset_to_bci(bci); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
871 iter.next(); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
872 return iter.get_method(will_link, declared_signature); |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
873 } |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
874 |
|
beebba0acc11
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
6973
diff
changeset
|
875 // ------------------------------------------------------------------ |
| 0 | 876 // Adjust a CounterData count to be commensurate with |
| 877 // interpreter_invocation_count. If the MDO exists for | |
| 878 // only 25% of the time the method exists, then the | |
| 879 // counts in the MDO should be scaled by 4X, so that | |
| 880 // they can be usefully and stably compared against the | |
| 881 // invocation counts in methods. | |
| 882 int ciMethod::scale_count(int count, float prof_factor) { | |
| 883 if (count > 0 && method_data() != NULL) { | |
| 1783 | 884 int counter_life; |
| 0 | 885 int method_life = interpreter_invocation_count(); |
| 1783 | 886 if (TieredCompilation) { |
| 887 // In tiered the MDO's life is measured directly, so just use the snapshotted counters | |
| 888 counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count()); | |
| 889 } else { | |
| 890 int current_mileage = method_data()->current_mileage(); | |
| 891 int creation_mileage = method_data()->creation_mileage(); | |
| 892 counter_life = current_mileage - creation_mileage; | |
| 893 } | |
| 894 | |
| 0 | 895 // counter_life due to backedge_counter could be > method_life |
| 896 if (counter_life > method_life) | |
| 897 counter_life = method_life; | |
| 898 if (0 < counter_life && counter_life <= method_life) { | |
| 899 count = (int)((double)count * prof_factor * method_life / counter_life + 0.5); | |
| 900 count = (count > 0) ? count : 1; | |
| 901 } | |
| 902 } | |
| 903 return count; | |
| 904 } | |
| 905 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
906 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
907 // ------------------------------------------------------------------ |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
908 // ciMethod::is_special_get_caller_class_method |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
909 // |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
910 bool ciMethod::is_ignored_by_security_stack_walk() const { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
911 check_is_loaded(); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
912 VM_ENTRY_MARK; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
913 return get_Method()->is_ignored_by_security_stack_walk(); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
914 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
915 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
7998
diff
changeset
|
916 |
| 0 | 917 // ------------------------------------------------------------------ |
| 710 | 918 // invokedynamic support |
| 1564 | 919 |
| 920 // ------------------------------------------------------------------ | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
921 // ciMethod::is_method_handle_intrinsic |
| 710 | 922 // |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
923 // Return true if the method is an instance of the JVM-generated |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
924 // signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
925 bool ciMethod::is_method_handle_intrinsic() const { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
926 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
927 return (MethodHandles::is_signature_polymorphic(iid) && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
928 MethodHandles::is_signature_polymorphic_intrinsic(iid)); |
| 710 | 929 } |
| 930 | |
| 1564 | 931 // ------------------------------------------------------------------ |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
932 // ciMethod::is_compiled_lambda_form |
| 1564 | 933 // |
| 934 // Return true if the method is a generated MethodHandle adapter. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
935 // These are built by Java code. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
936 bool ciMethod::is_compiled_lambda_form() const { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
937 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
938 return iid == vmIntrinsics::_compiledLambdaForm; |
|
1152
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1137
diff
changeset
|
939 } |
|
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1137
diff
changeset
|
940 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
941 // ------------------------------------------------------------------ |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
942 // ciMethod::has_member_arg |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
943 // |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
944 // Return true if the method is a linker intrinsic like _linkToVirtual. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
945 // These are built by the JVM. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
946 bool ciMethod::has_member_arg() const { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
947 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
948 return (MethodHandles::is_signature_polymorphic(iid) && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
949 MethodHandles::has_member_arg(iid)); |
| 710 | 950 } |
| 951 | |
| 952 // ------------------------------------------------------------------ | |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
953 // ciMethod::ensure_method_data |
| 0 | 954 // |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
955 // Generate new MethodData* objects at compile time. |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
956 // Return true if allocation was successful or no MDO is required. |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
957 bool ciMethod::ensure_method_data(methodHandle h_m) { |
| 0 | 958 EXCEPTION_CONTEXT; |
|
12868
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
959 if (is_native() || is_abstract() || h_m()->is_accessor()) { |
|
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
960 return true; |
|
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
961 } |
| 0 | 962 if (h_m()->method_data() == NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
963 Method::build_interpreter_method_data(h_m, THREAD); |
| 0 | 964 if (HAS_PENDING_EXCEPTION) { |
| 965 CLEAR_PENDING_EXCEPTION; | |
| 966 } | |
| 967 } | |
| 968 if (h_m()->method_data() != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
969 _method_data = CURRENT_ENV->get_method_data(h_m()->method_data()); |
| 0 | 970 _method_data->load_data(); |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
971 return true; |
| 0 | 972 } else { |
| 973 _method_data = CURRENT_ENV->get_empty_methodData(); | |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
974 return false; |
| 0 | 975 } |
| 976 } | |
| 977 | |
| 978 // public, retroactive version | |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
979 bool ciMethod::ensure_method_data() { |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
980 bool result = true; |
| 0 | 981 if (_method_data == NULL || _method_data->is_empty()) { |
| 982 GUARDED_VM_ENTRY({ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
983 result = ensure_method_data(get_Method()); |
| 0 | 984 }); |
| 985 } | |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
986 return result; |
| 0 | 987 } |
| 988 | |
| 989 | |
| 990 // ------------------------------------------------------------------ | |
| 991 // ciMethod::method_data | |
| 992 // | |
| 993 ciMethodData* ciMethod::method_data() { | |
| 994 if (_method_data != NULL) { | |
| 995 return _method_data; | |
| 996 } | |
| 997 VM_ENTRY_MARK; | |
| 998 ciEnv* env = CURRENT_ENV; | |
| 999 Thread* my_thread = JavaThread::current(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1000 methodHandle h_m(my_thread, get_Method()); |
| 0 | 1001 |
| 1002 if (h_m()->method_data() != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1003 _method_data = CURRENT_ENV->get_method_data(h_m()->method_data()); |
| 0 | 1004 _method_data->load_data(); |
| 1005 } else { | |
| 1006 _method_data = CURRENT_ENV->get_empty_methodData(); | |
| 1007 } | |
| 1008 return _method_data; | |
| 1009 | |
| 1010 } | |
| 1011 | |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1012 // ------------------------------------------------------------------ |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1013 // ciMethod::method_data_or_null |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1014 // Returns a pointer to ciMethodData if MDO exists on the VM side, |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1015 // NULL otherwise. |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1016 ciMethodData* ciMethod::method_data_or_null() { |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1017 ciMethodData *md = method_data(); |
|
12868
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1018 if (md->is_empty()) { |
|
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1019 return NULL; |
|
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1020 } |
|
2007
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1021 return md; |
|
5ddfcf4b079e
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
1972
diff
changeset
|
1022 } |
| 0 | 1023 |
| 1024 // ------------------------------------------------------------------ | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1025 // ciMethod::ensure_method_counters |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1026 // |
|
12868
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1027 MethodCounters* ciMethod::ensure_method_counters() { |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1028 check_is_loaded(); |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1029 VM_ENTRY_MARK; |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1030 methodHandle mh(THREAD, get_Method()); |
|
12868
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1031 MethodCounters* method_counters = mh->get_method_counters(CHECK_NULL); |
|
c775af091fe9
8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents:
12865
diff
changeset
|
1032 return method_counters; |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1033 } |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1034 |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1035 // ------------------------------------------------------------------ |
| 0 | 1036 // ciMethod::should_exclude |
| 1037 // | |
| 1038 // Should this method be excluded from compilation? | |
| 1039 bool ciMethod::should_exclude() { | |
| 1040 check_is_loaded(); | |
| 1041 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1042 methodHandle mh(THREAD, get_Method()); |
| 0 | 1043 bool ignore; |
| 1044 return CompilerOracle::should_exclude(mh, ignore); | |
| 1045 } | |
| 1046 | |
| 1047 // ------------------------------------------------------------------ | |
| 1048 // ciMethod::should_inline | |
| 1049 // | |
| 1050 // Should this method be inlined during compilation? | |
| 1051 bool ciMethod::should_inline() { | |
| 1052 check_is_loaded(); | |
| 1053 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1054 methodHandle mh(THREAD, get_Method()); |
| 0 | 1055 return CompilerOracle::should_inline(mh); |
| 1056 } | |
| 1057 | |
| 1058 // ------------------------------------------------------------------ | |
| 1059 // ciMethod::should_not_inline | |
| 1060 // | |
| 1061 // Should this method be disallowed from inlining during compilation? | |
| 1062 bool ciMethod::should_not_inline() { | |
| 1063 check_is_loaded(); | |
| 1064 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1065 methodHandle mh(THREAD, get_Method()); |
| 0 | 1066 return CompilerOracle::should_not_inline(mh); |
| 1067 } | |
| 1068 | |
| 1069 // ------------------------------------------------------------------ | |
| 1070 // ciMethod::should_print_assembly | |
| 1071 // | |
| 1072 // Should the compiler print the generated code for this method? | |
| 1073 bool ciMethod::should_print_assembly() { | |
| 1074 check_is_loaded(); | |
| 1075 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1076 methodHandle mh(THREAD, get_Method()); |
| 0 | 1077 return CompilerOracle::should_print(mh); |
| 1078 } | |
| 1079 | |
| 1080 // ------------------------------------------------------------------ | |
| 1081 // ciMethod::break_at_execute | |
| 1082 // | |
| 1083 // Should the compiler insert a breakpoint into the generated code | |
| 1084 // method? | |
| 1085 bool ciMethod::break_at_execute() { | |
| 1086 check_is_loaded(); | |
| 1087 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1088 methodHandle mh(THREAD, get_Method()); |
| 0 | 1089 return CompilerOracle::should_break_at(mh); |
| 1090 } | |
| 1091 | |
| 1092 // ------------------------------------------------------------------ | |
| 1093 // ciMethod::has_option | |
| 1094 // | |
| 1095 bool ciMethod::has_option(const char* option) { | |
| 1096 check_is_loaded(); | |
| 1097 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1098 methodHandle mh(THREAD, get_Method()); |
| 0 | 1099 return CompilerOracle::has_option_string(mh, option); |
| 1100 } | |
| 1101 | |
| 1102 // ------------------------------------------------------------------ | |
| 1103 // ciMethod::can_be_compiled | |
| 1104 // | |
| 1105 // Have previous compilations of this method succeeded? | |
| 1106 bool ciMethod::can_be_compiled() { | |
| 1107 check_is_loaded(); | |
| 1783 | 1108 ciEnv* env = CURRENT_ENV; |
| 1109 if (is_c1_compile(env->comp_level())) { | |
| 1110 return _is_c1_compilable; | |
| 1111 } | |
| 1112 return _is_c2_compilable; | |
| 0 | 1113 } |
| 1114 | |
| 1115 // ------------------------------------------------------------------ | |
| 1116 // ciMethod::set_not_compilable | |
| 1117 // | |
| 1118 // Tell the VM that this method cannot be compiled at all. | |
| 7998 | 1119 void ciMethod::set_not_compilable(const char* reason) { |
| 0 | 1120 check_is_loaded(); |
| 1121 VM_ENTRY_MARK; | |
| 1783 | 1122 ciEnv* env = CURRENT_ENV; |
| 1123 if (is_c1_compile(env->comp_level())) { | |
| 1124 _is_c1_compilable = false; | |
| 1125 } else { | |
| 1126 _is_c2_compilable = false; | |
| 1127 } | |
| 7998 | 1128 get_Method()->set_not_compilable(env->comp_level(), true, reason); |
| 0 | 1129 } |
| 1130 | |
| 1131 // ------------------------------------------------------------------ | |
| 1132 // ciMethod::can_be_osr_compiled | |
| 1133 // | |
| 1134 // Have previous compilations of this method succeeded? | |
| 1135 // | |
| 1136 // Implementation note: the VM does not currently keep track | |
| 1137 // of failed OSR compilations per bci. The entry_bci parameter | |
| 1138 // is currently unused. | |
| 1139 bool ciMethod::can_be_osr_compiled(int entry_bci) { | |
| 1140 check_is_loaded(); | |
| 1141 VM_ENTRY_MARK; | |
| 1783 | 1142 ciEnv* env = CURRENT_ENV; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1143 return !get_Method()->is_not_osr_compilable(env->comp_level()); |
| 0 | 1144 } |
| 1145 | |
| 1146 // ------------------------------------------------------------------ | |
| 1147 // ciMethod::has_compiled_code | |
| 1148 bool ciMethod::has_compiled_code() { | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1149 return instructions_size() > 0; |
| 0 | 1150 } |
| 1151 | |
| 1783 | 1152 int ciMethod::comp_level() { |
| 1153 check_is_loaded(); | |
| 1154 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1155 nmethod* nm = get_Method()->code(); |
| 1783 | 1156 if (nm != NULL) return nm->comp_level(); |
| 1157 return 0; | |
| 1158 } | |
| 1159 | |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3785
diff
changeset
|
1160 int ciMethod::highest_osr_comp_level() { |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3785
diff
changeset
|
1161 check_is_loaded(); |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3785
diff
changeset
|
1162 VM_ENTRY_MARK; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1163 return get_Method()->highest_osr_comp_level(); |
|
3791
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3785
diff
changeset
|
1164 } |
|
2c359f27615c
7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents:
3785
diff
changeset
|
1165 |
| 0 | 1166 // ------------------------------------------------------------------ |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1167 // ciMethod::code_size_for_inlining |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1168 // |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1169 // Code size for inlining decisions. This method returns a code |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1170 // size of 1 for methods which has the ForceInline annotation. |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1171 int ciMethod::code_size_for_inlining() { |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1172 check_is_loaded(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1173 if (get_Method()->force_inline()) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1174 return 1; |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1175 } |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1176 return code_size(); |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1177 } |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1178 |
|
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3791
diff
changeset
|
1179 // ------------------------------------------------------------------ |
| 0 | 1180 // ciMethod::instructions_size |
| 1748 | 1181 // |
| 1182 // This is a rough metric for "fat" methods, compared before inlining | |
| 1183 // with InlineSmallCode. The CodeBlob::code_size accessor includes | |
| 1184 // junk like exception handler, stubs, and constant table, which are | |
| 1185 // not highly relevant to an inlined method. So we use the more | |
| 1186 // specific accessor nmethod::insts_size. | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1187 int ciMethod::instructions_size() { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1188 if (_instructions_size == -1) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1189 GUARDED_VM_ENTRY( |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1190 nmethod* code = get_Method()->code(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1191 if (code != NULL && (code->comp_level() == CompLevel_full_optimization)) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1192 _instructions_size = code->insts_end() - code->verified_entry_point(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1193 } else { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1194 _instructions_size = 0; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1195 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1196 ); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1197 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1198 return _instructions_size; |
| 0 | 1199 } |
| 1200 | |
| 1201 // ------------------------------------------------------------------ | |
| 1202 // ciMethod::log_nmethod_identity | |
| 1203 void ciMethod::log_nmethod_identity(xmlStream* log) { | |
| 1204 GUARDED_VM_ENTRY( | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1205 nmethod* code = get_Method()->code(); |
| 0 | 1206 if (code != NULL) { |
| 1207 code->log_identity(log); | |
| 1208 } | |
| 1209 ) | |
| 1210 } | |
| 1211 | |
| 1212 // ------------------------------------------------------------------ | |
| 1213 // ciMethod::is_not_reached | |
| 1214 bool ciMethod::is_not_reached(int bci) { | |
| 1215 check_is_loaded(); | |
| 1216 VM_ENTRY_MARK; | |
| 1217 return Interpreter::is_not_reached( | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1218 methodHandle(THREAD, get_Method()), bci); |
| 0 | 1219 } |
| 1220 | |
| 1221 // ------------------------------------------------------------------ | |
| 1222 // ciMethod::was_never_executed | |
| 1223 bool ciMethod::was_executed_more_than(int times) { | |
| 1224 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1225 return get_Method()->was_executed_more_than(times); |
| 0 | 1226 } |
| 1227 | |
| 1228 // ------------------------------------------------------------------ | |
| 1229 // ciMethod::has_unloaded_classes_in_signature | |
| 1230 bool ciMethod::has_unloaded_classes_in_signature() { | |
| 1231 VM_ENTRY_MARK; | |
| 1232 { | |
| 1233 EXCEPTION_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1234 methodHandle m(THREAD, get_Method()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1235 bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD); |
| 0 | 1236 if( HAS_PENDING_EXCEPTION ) { |
| 1237 CLEAR_PENDING_EXCEPTION; | |
| 1238 return true; // Declare that we may have unloaded classes | |
| 1239 } | |
| 1240 return has_unloaded; | |
| 1241 } | |
| 1242 } | |
| 1243 | |
| 1244 // ------------------------------------------------------------------ | |
| 1245 // ciMethod::is_klass_loaded | |
| 1246 bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const { | |
| 1247 VM_ENTRY_MARK; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1248 return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved); |
| 0 | 1249 } |
| 1250 | |
| 1251 // ------------------------------------------------------------------ | |
| 1252 // ciMethod::check_call | |
| 1253 bool ciMethod::check_call(int refinfo_index, bool is_static) const { | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
1254 // This method is used only in C2 from InlineTree::ok_to_inline, |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
1255 // and is only used under -Xcomp or -XX:CompileTheWorld. |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
1256 // It appears to fail when applied to an invokeinterface call site. |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
10278
diff
changeset
|
1257 // FIXME: Remove this method and resolve_method_statically; refactor to use the other LinkResolver entry points. |
| 0 | 1258 VM_ENTRY_MARK; |
| 1259 { | |
| 1260 EXCEPTION_MARK; | |
| 1261 HandleMark hm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1262 constantPoolHandle pool (THREAD, get_Method()->constants()); |
| 0 | 1263 methodHandle spec_method; |
| 1264 KlassHandle spec_klass; | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1265 Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1266 LinkResolver::resolve_method_statically(spec_method, spec_klass, code, pool, refinfo_index, THREAD); |
| 0 | 1267 if (HAS_PENDING_EXCEPTION) { |
| 1268 CLEAR_PENDING_EXCEPTION; | |
| 1269 return false; | |
| 1270 } else { | |
| 1271 return (spec_method->is_static() == is_static); | |
| 1272 } | |
| 1273 } | |
| 1274 return false; | |
| 1275 } | |
| 1276 | |
| 1277 // ------------------------------------------------------------------ | |
| 1278 // ciMethod::print_codes | |
| 1279 // | |
| 1280 // Print the bytecodes for this method. | |
| 1281 void ciMethod::print_codes_on(outputStream* st) { | |
| 1282 check_is_loaded(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1283 GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);) |
| 0 | 1284 } |
| 1285 | |
| 1286 | |
| 1287 #define FETCH_FLAG_FROM_VM(flag_accessor) { \ | |
| 1288 check_is_loaded(); \ | |
| 1289 VM_ENTRY_MARK; \ | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1290 return get_Method()->flag_accessor(); \ |
| 0 | 1291 } |
| 1292 | |
| 1293 bool ciMethod::is_empty_method() const { FETCH_FLAG_FROM_VM(is_empty_method); } | |
| 1294 bool ciMethod::is_vanilla_constructor() const { FETCH_FLAG_FROM_VM(is_vanilla_constructor); } | |
| 1295 bool ciMethod::has_loops () const { FETCH_FLAG_FROM_VM(has_loops); } | |
| 1296 bool ciMethod::has_jsrs () const { FETCH_FLAG_FROM_VM(has_jsrs); } | |
| 1297 bool ciMethod::is_accessor () const { FETCH_FLAG_FROM_VM(is_accessor); } | |
| 1298 bool ciMethod::is_initializer () const { FETCH_FLAG_FROM_VM(is_initializer); } | |
| 1299 | |
| 10278 | 1300 bool ciMethod::is_boxing_method() const { |
| 1301 if (holder()->is_box_klass()) { | |
| 1302 switch (intrinsic_id()) { | |
| 1303 case vmIntrinsics::_Boolean_valueOf: | |
| 1304 case vmIntrinsics::_Byte_valueOf: | |
| 1305 case vmIntrinsics::_Character_valueOf: | |
| 1306 case vmIntrinsics::_Short_valueOf: | |
| 1307 case vmIntrinsics::_Integer_valueOf: | |
| 1308 case vmIntrinsics::_Long_valueOf: | |
| 1309 case vmIntrinsics::_Float_valueOf: | |
| 1310 case vmIntrinsics::_Double_valueOf: | |
| 1311 return true; | |
| 1312 default: | |
| 1313 return false; | |
| 1314 } | |
| 1315 } | |
| 1316 return false; | |
| 1317 } | |
| 1318 | |
| 1319 bool ciMethod::is_unboxing_method() const { | |
| 1320 if (holder()->is_box_klass()) { | |
| 1321 switch (intrinsic_id()) { | |
| 1322 case vmIntrinsics::_booleanValue: | |
| 1323 case vmIntrinsics::_byteValue: | |
| 1324 case vmIntrinsics::_charValue: | |
| 1325 case vmIntrinsics::_shortValue: | |
| 1326 case vmIntrinsics::_intValue: | |
| 1327 case vmIntrinsics::_longValue: | |
| 1328 case vmIntrinsics::_floatValue: | |
| 1329 case vmIntrinsics::_doubleValue: | |
| 1330 return true; | |
| 1331 default: | |
| 1332 return false; | |
| 1333 } | |
| 1334 } | |
| 1335 return false; | |
| 1336 } | |
| 1337 | |
| 0 | 1338 BCEscapeAnalyzer *ciMethod::get_bcea() { |
|
1648
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
1339 #ifdef COMPILER2 |
| 0 | 1340 if (_bcea == NULL) { |
| 1341 _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL); | |
| 1342 } | |
| 1343 return _bcea; | |
|
1648
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
1344 #else // COMPILER2 |
|
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
1345 ShouldNotReachHere(); |
|
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
1346 return NULL; |
|
8099e71601df
6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents:
1579
diff
changeset
|
1347 #endif // COMPILER2 |
| 0 | 1348 } |
| 1349 | |
| 1350 ciMethodBlocks *ciMethod::get_method_blocks() { | |
| 1351 Arena *arena = CURRENT_ENV->arena(); | |
| 1352 if (_method_blocks == NULL) { | |
| 1353 _method_blocks = new (arena) ciMethodBlocks(arena, this); | |
| 1354 } | |
| 1355 return _method_blocks; | |
| 1356 } | |
| 1357 | |
| 1358 #undef FETCH_FLAG_FROM_VM | |
| 1359 | |
| 17622 | 1360 void ciMethod::dump_name_as_ascii(outputStream* st) { |
| 1361 Method* method = get_Method(); | |
| 1362 st->print("%s %s %s", | |
| 1363 method->klass_name()->as_quoted_ascii(), | |
| 1364 method->name()->as_quoted_ascii(), | |
| 1365 method->signature()->as_quoted_ascii()); | |
| 1366 } | |
| 1367 | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1368 void ciMethod::dump_replay_data(outputStream* st) { |
|
7990
fcc9e7681d63
8006410: allocating without ResourceMark when CompileCommand was specified
vlivanov
parents:
7194
diff
changeset
|
1369 ResourceMark rm; |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1370 Method* method = get_Method(); |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1371 MethodCounters* mcs = method->method_counters(); |
| 17622 | 1372 st->print("ciMethod "); |
| 1373 dump_name_as_ascii(st); | |
| 1374 st->print_cr(" %d %d %d %d %d", | |
|
10105
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1375 mcs == NULL ? 0 : mcs->invocation_counter()->raw_counter(), |
|
aeaca88565e6
8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents:
8866
diff
changeset
|
1376 mcs == NULL ? 0 : mcs->backedge_counter()->raw_counter(), |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1377 interpreter_invocation_count(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1378 interpreter_throwout_count(), |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1379 _instructions_size); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
1380 } |
| 0 | 1381 |
| 1382 // ------------------------------------------------------------------ | |
| 1383 // ciMethod::print_codes | |
| 1384 // | |
| 1385 // Print a range of the bytecodes for this method. | |
| 1386 void ciMethod::print_codes_on(int from, int to, outputStream* st) { | |
| 1387 check_is_loaded(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1388 GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);) |
| 0 | 1389 } |
| 1390 | |
| 1391 // ------------------------------------------------------------------ | |
| 1392 // ciMethod::print_name | |
| 1393 // | |
| 1394 // Print the name of this method, including signature and some flags. | |
| 1395 void ciMethod::print_name(outputStream* st) { | |
| 1396 check_is_loaded(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1397 GUARDED_VM_ENTRY(get_Method()->print_name(st);) |
| 0 | 1398 } |
| 1399 | |
| 1400 // ------------------------------------------------------------------ | |
| 1401 // ciMethod::print_short_name | |
| 1402 // | |
| 1403 // Print the name of this method, without signature. | |
| 1404 void ciMethod::print_short_name(outputStream* st) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1405 if (is_loaded()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1406 GUARDED_VM_ENTRY(get_Method()->print_short_name(st);); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1407 } else { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1408 // Fall back if method is not loaded. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1409 holder()->print_name_on(st); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1410 st->print("::"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1411 name()->print_symbol_on(st); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1412 if (WizardMode) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1413 signature()->as_symbol()->print_symbol_on(st); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6213
diff
changeset
|
1414 } |
| 0 | 1415 } |
| 1416 | |
| 1417 // ------------------------------------------------------------------ | |
| 1418 // ciMethod::print_impl | |
| 1419 // | |
| 1420 // Implementation of the print method. | |
| 1421 void ciMethod::print_impl(outputStream* st) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6634
diff
changeset
|
1422 ciMetadata::print_impl(st); |
| 0 | 1423 st->print(" name="); |
| 1424 name()->print_symbol_on(st); | |
| 1425 st->print(" holder="); | |
| 1426 holder()->print_name_on(st); | |
| 1427 st->print(" signature="); | |
| 1428 signature()->as_symbol()->print_symbol_on(st); | |
| 1429 if (is_loaded()) { | |
|
6634
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
1430 st->print(" loaded=true"); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
1431 st->print(" arg_size=%d", arg_size()); |
|
7f813940ac35
7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents:
6266
diff
changeset
|
1432 st->print(" flags="); |
| 0 | 1433 flags().print_member_flags(st); |
| 1434 } else { | |
| 1435 st->print(" loaded=false"); | |
| 1436 } | |
| 1437 } |