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