Mercurial > hg > truffle
annotate src/share/vm/oops/method.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | c6a1ffc707ff |
| children | 836a62f43af9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7470
diff
changeset
|
2 * Copyright (c) 1997, 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:
1515
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1515
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:
1515
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
|
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7470
diff
changeset
|
26 #include "classfile/metadataOnStackMark.hpp" |
| 1972 | 27 #include "classfile/systemDictionary.hpp" |
| 28 #include "code/debugInfoRec.hpp" | |
| 29 #include "gc_interface/collectedHeap.inline.hpp" | |
| 30 #include "interpreter/bytecodeStream.hpp" | |
| 31 #include "interpreter/bytecodeTracer.hpp" | |
| 32 #include "interpreter/bytecodes.hpp" | |
| 33 #include "interpreter/interpreter.hpp" | |
| 34 #include "interpreter/oopMapCache.hpp" | |
| 35 #include "memory/gcLocker.hpp" | |
| 36 #include "memory/generation.hpp" | |
| 7956 | 37 #include "memory/heapInspection.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
38 #include "memory/metadataFactory.hpp" |
| 1972 | 39 #include "memory/oopFactory.hpp" |
| 6934 | 40 #include "oops/constMethod.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
41 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
42 #include "oops/method.hpp" |
| 1972 | 43 #include "oops/oop.inline.hpp" |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
44 #include "oops/symbol.hpp" |
| 1972 | 45 #include "prims/jvmtiExport.hpp" |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
46 #include "prims/methodHandles.hpp" |
| 1972 | 47 #include "prims/nativeLookup.hpp" |
| 48 #include "runtime/arguments.hpp" | |
| 49 #include "runtime/compilationPolicy.hpp" | |
| 50 #include "runtime/frame.inline.hpp" | |
| 51 #include "runtime/handles.inline.hpp" | |
| 52 #include "runtime/relocator.hpp" | |
| 53 #include "runtime/sharedRuntime.hpp" | |
| 54 #include "runtime/signature.hpp" | |
| 3779 | 55 #include "utilities/quickSort.hpp" |
| 1972 | 56 #include "utilities/xmlstream.hpp" |
| 0 | 57 |
| 58 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
59 // Implementation of Method |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
60 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
61 Method* Method::allocate(ClassLoaderData* loader_data, |
| 6934 | 62 int byte_code_size, |
| 63 AccessFlags access_flags, | |
| 8031 | 64 InlineTableSizes* sizes, |
| 6934 | 65 ConstMethod::MethodType method_type, |
| 66 TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
67 assert(!access_flags.is_native() || byte_code_size == 0, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
68 "native methods should not contain byte codes"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
69 ConstMethod* cm = ConstMethod::allocate(loader_data, |
| 6934 | 70 byte_code_size, |
| 8031 | 71 sizes, |
| 6934 | 72 method_type, |
| 73 CHECK_NULL); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
74 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
75 int size = Method::size(access_flags.is_native()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
76 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
77 return new (loader_data, size, false, THREAD) Method(cm, access_flags, size); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
78 } |
| 0 | 79 |
|
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
80 Method::Method(ConstMethod* xconst, AccessFlags access_flags, int size) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
81 No_Safepoint_Verifier no_safepoint; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
82 set_constMethod(xconst); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
83 set_access_flags(access_flags); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
84 set_method_size(size); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
85 #ifdef CC_INTERP |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
86 set_result_index(T_VOID); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
87 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
88 set_intrinsic_id(vmIntrinsics::_none); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
89 set_jfr_towrite(false); |
|
8715
5939f5953b45
8009836: nsk/regression/b4222717 fails with empty stack trace
coleenp
parents:
8712
diff
changeset
|
90 set_force_inline(false); |
|
5939f5953b45
8009836: nsk/regression/b4222717 fails with empty stack trace
coleenp
parents:
8712
diff
changeset
|
91 set_hidden(false); |
|
5939f5953b45
8009836: nsk/regression/b4222717 fails with empty stack trace
coleenp
parents:
8712
diff
changeset
|
92 set_dont_inline(false); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
93 set_method_data(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
94 set_interpreter_throwout_count(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
95 set_vtable_index(Method::garbage_vtable_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
96 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
97 // Fix and bury in Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
98 set_interpreter_entry(NULL); // sets i2i entry and from_int |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
99 set_adapter_entry(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
100 clear_code(); // from_c/from_i get set to c2i/i2i |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
101 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
102 if (access_flags.is_native()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
103 clear_native_function(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
104 set_signature_handler(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
105 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
106 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
107 NOT_PRODUCT(set_compiled_invocation_count(0);) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
108 set_interpreter_invocation_count(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
109 invocation_counter()->init(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
110 backedge_counter()->init(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
111 clear_number_of_breakpoints(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
112 |
|
7154
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6999
diff
changeset
|
113 #ifdef GRAAL |
|
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6999
diff
changeset
|
114 set_graal_invocation_time(0L); |
|
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6999
diff
changeset
|
115 set_graal_priority(0); |
|
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6999
diff
changeset
|
116 #endif |
|
5d0bb7d52783
changes to support Graal co-existing with the other HotSpot compiler(s) and being used for explicit compilation requests and code installation via the Graal API
Doug Simon <doug.simon@oracle.com>
parents:
6999
diff
changeset
|
117 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
118 #ifdef TIERED |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
119 set_rate(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
120 set_prev_event_count(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
121 set_prev_time(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
122 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
123 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
124 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
125 // Release Method*. The nmethod will be gone when we get here because |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
126 // we've walked the code cache. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
127 void Method::deallocate_contents(ClassLoaderData* loader_data) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
128 MetadataFactory::free_metadata(loader_data, constMethod()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
129 set_constMethod(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
130 MetadataFactory::free_metadata(loader_data, method_data()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
131 set_method_data(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
132 // The nmethod will be gone when we get here. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
133 if (code() != NULL) _code = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
134 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
135 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
136 address Method::get_i2c_entry() { |
| 0 | 137 assert(_adapter != NULL, "must have"); |
| 138 return _adapter->get_i2c_entry(); | |
| 139 } | |
| 140 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
141 address Method::get_c2i_entry() { |
| 0 | 142 assert(_adapter != NULL, "must have"); |
| 143 return _adapter->get_c2i_entry(); | |
| 144 } | |
| 145 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
146 address Method::get_c2i_unverified_entry() { |
| 0 | 147 assert(_adapter != NULL, "must have"); |
| 148 return _adapter->get_c2i_unverified_entry(); | |
| 149 } | |
| 150 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
151 char* Method::name_and_sig_as_C_string() const { |
| 6983 | 152 return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature()); |
| 0 | 153 } |
| 154 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
155 char* Method::name_and_sig_as_C_string(char* buf, int size) const { |
| 6983 | 156 return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature(), buf, size); |
| 0 | 157 } |
| 158 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
159 char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) { |
| 0 | 160 const char* klass_name = klass->external_name(); |
| 161 int klass_name_len = (int)strlen(klass_name); | |
| 162 int method_name_len = method_name->utf8_length(); | |
| 163 int len = klass_name_len + 1 + method_name_len + signature->utf8_length(); | |
| 164 char* dest = NEW_RESOURCE_ARRAY(char, len + 1); | |
| 165 strcpy(dest, klass_name); | |
| 166 dest[klass_name_len] = '.'; | |
| 167 strcpy(&dest[klass_name_len + 1], method_name->as_C_string()); | |
| 168 strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string()); | |
| 169 dest[len] = 0; | |
| 170 return dest; | |
| 171 } | |
| 172 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
173 char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
174 Symbol* klass_name = klass->name(); |
| 0 | 175 klass_name->as_klass_external_name(buf, size); |
| 176 int len = (int)strlen(buf); | |
| 177 | |
| 178 if (len < size - 1) { | |
| 179 buf[len++] = '.'; | |
| 180 | |
| 181 method_name->as_C_string(&(buf[len]), size - len); | |
| 182 len = (int)strlen(buf); | |
| 183 | |
| 184 signature->as_C_string(&(buf[len]), size - len); | |
| 185 } | |
| 186 | |
| 187 return buf; | |
| 188 } | |
| 189 | |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7184
diff
changeset
|
190 int Method::fast_exception_handler_bci_for(methodHandle mh, KlassHandle ex_klass, int throw_bci, TRAPS) { |
| 0 | 191 // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index) |
| 192 // access exception table | |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7184
diff
changeset
|
193 ExceptionTable table(mh()); |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
194 int length = table.length(); |
| 0 | 195 // iterate through all entries sequentially |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7184
diff
changeset
|
196 constantPoolHandle pool(THREAD, mh->constants()); |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
197 for (int i = 0; i < length; i ++) { |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
198 //reacquire the table in case a GC happened |
|
7469
0c8717a92b2d
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
7184
diff
changeset
|
199 ExceptionTable table(mh()); |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
200 int beg_bci = table.start_pc(i); |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
201 int end_bci = table.end_pc(i); |
| 0 | 202 assert(beg_bci <= end_bci, "inconsistent exception table"); |
| 203 if (beg_bci <= throw_bci && throw_bci < end_bci) { | |
| 204 // exception handler bci range covers throw_bci => investigate further | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
205 int handler_bci = table.handler_pc(i); |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
206 int klass_index = table.catch_type_index(i); |
| 0 | 207 if (klass_index == 0) { |
| 208 return handler_bci; | |
| 209 } else if (ex_klass.is_null()) { | |
| 210 return handler_bci; | |
| 211 } else { | |
| 212 // we know the exception class => get the constraint class | |
| 213 // this may require loading of the constraint class; if verification | |
| 214 // fails or some other exception occurs, return handler_bci | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
215 Klass* k = pool->klass_at(klass_index, CHECK_(handler_bci)); |
| 0 | 216 KlassHandle klass = KlassHandle(THREAD, k); |
| 217 assert(klass.not_null(), "klass not loaded"); | |
| 218 if (ex_klass->is_subtype_of(klass())) { | |
| 219 return handler_bci; | |
| 220 } | |
| 221 } | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 return -1; | |
| 226 } | |
| 227 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
228 void Method::mask_for(int bci, InterpreterOopMap* mask) { |
| 0 | 229 |
| 230 Thread* myThread = Thread::current(); | |
| 231 methodHandle h_this(myThread, this); | |
| 232 #ifdef ASSERT | |
| 233 bool has_capability = myThread->is_VM_thread() || | |
| 234 myThread->is_ConcurrentGC_thread() || | |
| 235 myThread->is_GC_task_thread(); | |
| 236 | |
| 237 if (!has_capability) { | |
| 238 if (!VerifyStack && !VerifyLastFrame) { | |
| 239 // verify stack calls this outside VM thread | |
| 240 warning("oopmap should only be accessed by the " | |
| 241 "VM, GC task or CMS threads (or during debugging)"); | |
| 242 InterpreterOopMap local_mask; | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
243 method_holder()->mask_for(h_this, bci, &local_mask); |
| 0 | 244 local_mask.print(); |
| 245 } | |
| 246 } | |
| 247 #endif | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
248 method_holder()->mask_for(h_this, bci, mask); |
| 0 | 249 return; |
| 250 } | |
| 251 | |
| 252 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
253 int Method::bci_from(address bcp) const { |
|
6791
8d3cc6612bd1
7197033: missing ResourceMark for assert in Method::bci_from()
kvn
parents:
6735
diff
changeset
|
254 #ifdef ASSERT |
|
8d3cc6612bd1
7197033: missing ResourceMark for assert in Method::bci_from()
kvn
parents:
6735
diff
changeset
|
255 { ResourceMark rm; |
|
6145
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4873
diff
changeset
|
256 assert(is_native() && bcp == code_base() || contains(bcp) || is_error_reported(), |
|
e2fe93124108
7174928: JSR 292: unresolved invokedynamic call sites deopt and osr infinitely
twisti
parents:
4873
diff
changeset
|
257 err_msg("bcp doesn't belong to this method: bcp: " INTPTR_FORMAT ", method: %s", bcp, name_and_sig_as_C_string())); |
|
6791
8d3cc6612bd1
7197033: missing ResourceMark for assert in Method::bci_from()
kvn
parents:
6735
diff
changeset
|
258 } |
|
8d3cc6612bd1
7197033: missing ResourceMark for assert in Method::bci_from()
kvn
parents:
6735
diff
changeset
|
259 #endif |
| 0 | 260 return bcp - code_base(); |
| 261 } | |
| 262 | |
| 263 | |
| 264 // Return (int)bcx if it appears to be a valid BCI. | |
| 265 // Return bci_from((address)bcx) if it appears to be a valid BCP. | |
| 266 // Return -1 otherwise. | |
| 267 // Used by profiling code, when invalid data is a possibility. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
268 // The caller is responsible for validating the Method* itself. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
269 int Method::validate_bci_from_bcx(intptr_t bcx) const { |
| 0 | 270 // keep bci as -1 if not a valid bci |
| 271 int bci = -1; | |
| 272 if (bcx == 0 || (address)bcx == code_base()) { | |
| 273 // code_size() may return 0 and we allow 0 here | |
| 274 // the method may be native | |
| 275 bci = 0; | |
| 276 } else if (frame::is_bci(bcx)) { | |
| 277 if (bcx < code_size()) { | |
| 278 bci = (int)bcx; | |
| 279 } | |
| 280 } else if (contains((address)bcx)) { | |
| 281 bci = (address)bcx - code_base(); | |
| 282 } | |
| 283 // Assert that if we have dodged any asserts, bci is negative. | |
| 284 assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0"); | |
| 285 return bci; | |
| 286 } | |
| 287 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
288 address Method::bcp_from(int bci) const { |
| 0 | 289 assert((is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size()), "illegal bci"); |
| 290 address bcp = code_base() + bci; | |
| 291 assert(is_native() && bcp == code_base() || contains(bcp), "bcp doesn't belong to this method"); | |
| 292 return bcp; | |
| 293 } | |
| 294 | |
| 295 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
296 int Method::size(bool is_native) { |
| 0 | 297 // If native, then include pointers for native_function and signature_handler |
| 298 int extra_bytes = (is_native) ? 2*sizeof(address*) : 0; | |
| 299 int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord; | |
| 300 return align_object_size(header_size() + extra_words); | |
| 301 } | |
| 302 | |
| 303 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
304 Symbol* Method::klass_name() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
305 Klass* k = method_holder(); |
| 0 | 306 assert(k->is_klass(), "must be klass"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
307 InstanceKlass* ik = (InstanceKlass*) k; |
| 0 | 308 return ik->name(); |
| 309 } | |
| 310 | |
| 311 | |
| 312 // Attempt to return method oop to original state. Clear any pointers | |
| 313 // (to objects outside the shared spaces). We won't be able to predict | |
| 314 // where they should point in a new JVM. Further initialize some | |
| 315 // entries now in order allow them to be write protected later. | |
| 316 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
317 void Method::remove_unshareable_info() { |
| 0 | 318 unlink_method(); |
| 319 } | |
| 320 | |
| 321 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
322 bool Method::was_executed_more_than(int n) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
323 // Invocation counter is reset when the Method* is compiled. |
| 0 | 324 // If the method has compiled code we therefore assume it has |
| 325 // be excuted more than n times. | |
| 326 if (is_accessor() || is_empty_method() || (code() != NULL)) { | |
| 327 // interpreter doesn't bump invocation counter of trivial methods | |
| 328 // compiler does not bump invocation counter of compiled methods | |
| 329 return true; | |
| 1783 | 330 } |
| 331 else if (_invocation_counter.carry() || (method_data() != NULL && method_data()->invocation_counter()->carry())) { | |
| 0 | 332 // The carry bit is set when the counter overflows and causes |
| 333 // a compilation to occur. We don't know how many times | |
| 334 // the counter has been reset, so we simply assume it has | |
| 335 // been executed more than n times. | |
| 336 return true; | |
| 337 } else { | |
| 338 return invocation_count() > n; | |
| 339 } | |
| 340 } | |
| 341 | |
| 342 #ifndef PRODUCT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
343 void Method::print_invocation_count() { |
| 0 | 344 if (is_static()) tty->print("static "); |
| 345 if (is_final()) tty->print("final "); | |
| 346 if (is_synchronized()) tty->print("synchronized "); | |
| 347 if (is_native()) tty->print("native "); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
348 method_holder()->name()->print_symbol_on(tty); |
| 0 | 349 tty->print("."); |
| 350 name()->print_symbol_on(tty); | |
| 351 signature()->print_symbol_on(tty); | |
| 352 | |
| 353 if (WizardMode) { | |
| 354 // dump the size of the byte codes | |
| 355 tty->print(" {%d}", code_size()); | |
| 356 } | |
| 357 tty->cr(); | |
| 358 | |
| 359 tty->print_cr (" interpreter_invocation_count: %8d ", interpreter_invocation_count()); | |
| 360 tty->print_cr (" invocation_counter: %8d ", invocation_count()); | |
| 361 tty->print_cr (" backedge_counter: %8d ", backedge_count()); | |
| 362 if (CountCompiledCalls) { | |
| 363 tty->print_cr (" compiled_invocation_count: %8d ", compiled_invocation_count()); | |
| 364 } | |
| 365 | |
| 366 } | |
| 367 #endif | |
| 368 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
369 // Build a MethodData* object to hold information about this method |
| 0 | 370 // collected in the interpreter. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
371 void Method::build_interpreter_method_data(methodHandle method, TRAPS) { |
|
2021
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
372 // Do not profile method if current thread holds the pending list lock, |
|
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
373 // which avoids deadlock for acquiring the MethodData_lock. |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
374 if (InstanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) { |
|
2021
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
375 return; |
|
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
376 } |
|
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
377 |
| 0 | 378 // Grab a lock here to prevent multiple |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
379 // MethodData*s from being created. |
| 0 | 380 MutexLocker ml(MethodData_lock, THREAD); |
| 381 if (method->method_data() == NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
382 ClassLoaderData* loader_data = method->method_holder()->class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
383 MethodData* method_data = MethodData::allocate(loader_data, method, CHECK); |
| 0 | 384 method->set_method_data(method_data); |
| 385 if (PrintMethodData && (Verbose || WizardMode)) { | |
| 386 ResourceMark rm(THREAD); | |
| 387 tty->print("build_interpreter_method_data for "); | |
| 388 method->print_name(tty); | |
| 389 tty->cr(); | |
| 390 // At the end of the run, the MDO, full of data, will be dumped. | |
| 391 } | |
| 392 } | |
| 393 } | |
| 394 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
395 void Method::cleanup_inline_caches() { |
| 0 | 396 // The current system doesn't use inline caches in the interpreter |
| 397 // => nothing to do (keep this method around for future use) | |
| 398 } | |
| 399 | |
| 400 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
401 int Method::extra_stack_words() { |
| 710 | 402 // not an inline function, to avoid a header dependency on Interpreter |
| 1506 | 403 return extra_stack_entries() * Interpreter::stackElementSize; |
| 710 | 404 } |
| 405 | |
| 406 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
407 void Method::compute_size_of_parameters(Thread *thread) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
408 ArgumentSizeComputer asc(signature()); |
| 0 | 409 set_size_of_parameters(asc.size() + (is_static() ? 0 : 1)); |
| 410 } | |
| 411 | |
| 412 #ifdef CC_INTERP | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
413 void Method::set_result_index(BasicType type) { |
| 0 | 414 _result_index = Interpreter::BasicType_as_index(type); |
| 415 } | |
| 416 #endif | |
| 417 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
418 BasicType Method::result_type() const { |
| 0 | 419 ResultTypeFinder rtf(signature()); |
| 420 return rtf.type(); | |
| 421 } | |
| 422 | |
| 423 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
424 bool Method::is_empty_method() const { |
| 0 | 425 return code_size() == 1 |
| 426 && *code_base() == Bytecodes::_return; | |
| 427 } | |
| 428 | |
| 429 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
430 bool Method::is_vanilla_constructor() const { |
| 0 | 431 // Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method |
| 432 // which only calls the superclass vanilla constructor and possibly does stores of | |
| 433 // zero constants to local fields: | |
| 434 // | |
| 435 // aload_0 | |
| 436 // invokespecial | |
| 437 // indexbyte1 | |
| 438 // indexbyte2 | |
| 439 // | |
| 440 // followed by an (optional) sequence of: | |
| 441 // | |
| 442 // aload_0 | |
| 443 // aconst_null / iconst_0 / fconst_0 / dconst_0 | |
| 444 // putfield | |
| 445 // indexbyte1 | |
| 446 // indexbyte2 | |
| 447 // | |
| 448 // followed by: | |
| 449 // | |
| 450 // return | |
| 451 | |
| 452 assert(name() == vmSymbols::object_initializer_name(), "Should only be called for default constructors"); | |
| 453 assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors"); | |
| 454 int size = code_size(); | |
| 455 // Check if size match | |
| 456 if (size == 0 || size % 5 != 0) return false; | |
| 457 address cb = code_base(); | |
| 458 int last = size - 1; | |
| 459 if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) { | |
| 460 // Does not call superclass default constructor | |
| 461 return false; | |
| 462 } | |
| 463 // Check optional sequence | |
| 464 for (int i = 4; i < last; i += 5) { | |
| 465 if (cb[i] != Bytecodes::_aload_0) return false; | |
| 466 if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false; | |
| 467 if (cb[i+2] != Bytecodes::_putfield) return false; | |
| 468 } | |
| 469 return true; | |
| 470 } | |
| 471 | |
| 472 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
473 bool Method::compute_has_loops_flag() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
474 BytecodeStream bcs(this); |
| 0 | 475 Bytecodes::Code bc; |
| 476 | |
| 477 while ((bc = bcs.next()) >= 0) { | |
| 478 switch( bc ) { | |
| 479 case Bytecodes::_ifeq: | |
| 480 case Bytecodes::_ifnull: | |
| 481 case Bytecodes::_iflt: | |
| 482 case Bytecodes::_ifle: | |
| 483 case Bytecodes::_ifne: | |
| 484 case Bytecodes::_ifnonnull: | |
| 485 case Bytecodes::_ifgt: | |
| 486 case Bytecodes::_ifge: | |
| 487 case Bytecodes::_if_icmpeq: | |
| 488 case Bytecodes::_if_icmpne: | |
| 489 case Bytecodes::_if_icmplt: | |
| 490 case Bytecodes::_if_icmpgt: | |
| 491 case Bytecodes::_if_icmple: | |
| 492 case Bytecodes::_if_icmpge: | |
| 493 case Bytecodes::_if_acmpeq: | |
| 494 case Bytecodes::_if_acmpne: | |
| 495 case Bytecodes::_goto: | |
| 496 case Bytecodes::_jsr: | |
| 497 if( bcs.dest() < bcs.next_bci() ) _access_flags.set_has_loops(); | |
| 498 break; | |
| 499 | |
| 500 case Bytecodes::_goto_w: | |
| 501 case Bytecodes::_jsr_w: | |
| 502 if( bcs.dest_w() < bcs.next_bci() ) _access_flags.set_has_loops(); | |
| 503 break; | |
| 504 } | |
| 505 } | |
| 506 _access_flags.set_loops_flag_init(); | |
| 507 return _access_flags.has_loops(); | |
| 508 } | |
| 509 | |
| 510 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
511 bool Method::is_final_method() const { |
| 0 | 512 // %%% Should return true for private methods also, |
| 513 // since there is no way to override them. | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
514 return is_final() || method_holder()->is_final(); |
| 0 | 515 } |
| 516 | |
| 517 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
518 bool Method::is_strict_method() const { |
| 0 | 519 return is_strict(); |
| 520 } | |
| 521 | |
| 522 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
523 bool Method::can_be_statically_bound() const { |
| 0 | 524 if (is_final_method()) return true; |
| 525 return vtable_index() == nonvirtual_vtable_index; | |
| 526 } | |
| 527 | |
| 528 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
529 bool Method::is_accessor() const { |
| 0 | 530 if (code_size() != 5) return false; |
| 531 if (size_of_parameters() != 1) return false; | |
| 2142 | 532 if (java_code_at(0) != Bytecodes::_aload_0 ) return false; |
| 533 if (java_code_at(1) != Bytecodes::_getfield) return false; | |
| 534 if (java_code_at(4) != Bytecodes::_areturn && | |
| 535 java_code_at(4) != Bytecodes::_ireturn ) return false; | |
| 0 | 536 return true; |
| 537 } | |
| 538 | |
| 539 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
540 bool Method::is_initializer() const { |
|
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
541 return name() == vmSymbols::object_initializer_name() || is_static_initializer(); |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
542 } |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
543 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
544 bool Method::has_valid_initializer_flags() const { |
|
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
545 return (is_static() || |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
546 method_holder()->major_version() < 51); |
|
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
547 } |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
548 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
549 bool Method::is_static_initializer() const { |
|
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
550 // For classfiles version 51 or greater, ensure that the clinit method is |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
551 // static. Non-static methods with the name "<clinit>" are not static |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
552 // initializers. (older classfiles exempted for backward compatibility) |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
553 return name() == vmSymbols::class_initializer_name() && |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
554 has_valid_initializer_flags(); |
| 0 | 555 } |
| 556 | |
| 557 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
558 objArrayHandle Method::resolved_checked_exceptions_impl(Method* this_oop, TRAPS) { |
| 0 | 559 int length = this_oop->checked_exceptions_length(); |
| 560 if (length == 0) { // common case | |
| 561 return objArrayHandle(THREAD, Universe::the_empty_class_klass_array()); | |
| 562 } else { | |
| 563 methodHandle h_this(THREAD, this_oop); | |
| 1142 | 564 objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::Class_klass(), length, CHECK_(objArrayHandle())); |
| 0 | 565 objArrayHandle mirrors (THREAD, m_oop); |
| 566 for (int i = 0; i < length; i++) { | |
| 567 CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
568 Klass* k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle())); |
| 6983 | 569 assert(k->is_subclass_of(SystemDictionary::Throwable_klass()), "invalid exception class"); |
| 570 mirrors->obj_at_put(i, k->java_mirror()); | |
| 0 | 571 } |
| 572 return mirrors; | |
| 573 } | |
| 574 }; | |
| 575 | |
| 576 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
577 int Method::line_number_from_bci(int bci) const { |
| 0 | 578 if (bci == SynchronizationEntryBCI) bci = 0; |
| 579 assert(bci == 0 || 0 <= bci && bci < code_size(), "illegal bci"); | |
| 580 int best_bci = 0; | |
| 581 int best_line = -1; | |
| 582 | |
| 583 if (has_linenumber_table()) { | |
| 584 // The line numbers are a short array of 2-tuples [start_pc, line_number]. | |
| 585 // Not necessarily sorted and not necessarily one-to-one. | |
| 586 CompressedLineNumberReadStream stream(compressed_linenumber_table()); | |
| 587 while (stream.read_pair()) { | |
| 588 if (stream.bci() == bci) { | |
| 589 // perfect match | |
| 590 return stream.line(); | |
| 591 } else { | |
| 592 // update best_bci/line | |
| 593 if (stream.bci() < bci && stream.bci() >= best_bci) { | |
| 594 best_bci = stream.bci(); | |
| 595 best_line = stream.line(); | |
| 596 } | |
| 597 } | |
| 598 } | |
| 599 } | |
| 600 return best_line; | |
| 601 } | |
| 602 | |
| 603 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
604 bool Method::is_klass_loaded_by_klass_index(int klass_index) const { |
|
6123
2fe087c3e814
7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents:
4873
diff
changeset
|
605 if( constants()->tag_at(klass_index).is_unresolved_klass() ) { |
| 0 | 606 Thread *thread = Thread::current(); |
|
6123
2fe087c3e814
7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents:
4873
diff
changeset
|
607 Symbol* klass_name = constants()->klass_name_at(klass_index); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
608 Handle loader(thread, method_holder()->class_loader()); |
| 6983 | 609 Handle prot (thread, method_holder()->protection_domain()); |
| 0 | 610 return SystemDictionary::find(klass_name, loader, prot, thread) != NULL; |
| 611 } else { | |
| 612 return true; | |
| 613 } | |
| 614 } | |
| 615 | |
| 616 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
617 bool Method::is_klass_loaded(int refinfo_index, bool must_be_resolved) const { |
|
6123
2fe087c3e814
7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents:
4873
diff
changeset
|
618 int klass_index = constants()->klass_ref_index_at(refinfo_index); |
| 0 | 619 if (must_be_resolved) { |
| 620 // Make sure klass is resolved in constantpool. | |
| 621 if (constants()->tag_at(klass_index).is_unresolved_klass()) return false; | |
| 622 } | |
| 623 return is_klass_loaded_by_klass_index(klass_index); | |
| 624 } | |
| 625 | |
| 626 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
627 void Method::set_native_function(address function, bool post_event_flag) { |
| 0 | 628 assert(function != NULL, "use clear_native_function to unregister natives"); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
629 assert(!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), ""); |
| 0 | 630 address* native_function = native_function_addr(); |
| 631 | |
| 632 // We can see racers trying to place the same native function into place. Once | |
| 633 // is plenty. | |
| 634 address current = *native_function; | |
| 635 if (current == function) return; | |
| 636 if (post_event_flag && JvmtiExport::should_post_native_method_bind() && | |
| 637 function != NULL) { | |
| 638 // native_method_throw_unsatisfied_link_error_entry() should only | |
| 639 // be passed when post_event_flag is false. | |
| 640 assert(function != | |
| 641 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 642 "post_event_flag mis-match"); | |
| 643 | |
| 644 // post the bind event, and possible change the bind function | |
| 645 JvmtiExport::post_native_method_bind(this, &function); | |
| 646 } | |
| 647 *native_function = function; | |
| 648 // This function can be called more than once. We must make sure that we always | |
| 649 // use the latest registered method -> check if a stub already has been generated. | |
| 650 // If so, we have to make it not_entrant. | |
| 651 nmethod* nm = code(); // Put it into local variable to guard against concurrent updates | |
| 652 if (nm != NULL) { | |
| 653 nm->make_not_entrant(); | |
| 654 } | |
| 655 } | |
| 656 | |
| 657 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
658 bool Method::has_native_function() const { |
|
6267
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
659 if (is_method_handle_intrinsic()) |
|
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
660 return false; // special-cased in SharedRuntime::generate_native_wrapper |
| 0 | 661 address func = native_function(); |
| 662 return (func != NULL && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry()); | |
| 663 } | |
| 664 | |
| 665 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
666 void Method::clear_native_function() { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
667 // Note: is_method_handle_intrinsic() is allowed here. |
| 0 | 668 set_native_function( |
| 669 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 670 !native_bind_event_is_interesting); | |
| 671 clear_code(); | |
| 672 } | |
| 673 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
674 address Method::critical_native_function() { |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
675 methodHandle mh(this); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
676 return NativeLookup::lookup_critical_entry(mh); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
677 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
678 |
| 0 | 679 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
680 void Method::set_signature_handler(address handler) { |
| 0 | 681 address* signature_handler = signature_handler_addr(); |
| 682 *signature_handler = handler; | |
| 683 } | |
| 684 | |
| 685 | |
| 7998 | 686 void Method::print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason) { |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1206
diff
changeset
|
687 if (PrintCompilation && report) { |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
688 ttyLocker ttyl; |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
689 tty->print("made not %scompilable on ", is_osr ? "OSR " : ""); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
690 if (comp_level == CompLevel_all) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
691 tty->print("all levels "); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
692 } else { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
693 tty->print("levels "); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
694 for (int i = (int)CompLevel_none; i <= comp_level; i++) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
695 tty->print("%d ", i); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
696 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
697 } |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
698 this->print_short_name(tty); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
699 int size = this->code_size(); |
| 7998 | 700 if (size > 0) { |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
701 tty->print(" (%d bytes)", size); |
| 7998 | 702 } |
| 703 if (reason != NULL) { | |
| 704 tty->print(" %s", reason); | |
| 705 } | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
706 tty->cr(); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
707 } |
| 0 | 708 if ((TraceDeoptimization || LogCompilation) && (xtty != NULL)) { |
| 709 ttyLocker ttyl; | |
| 6843 | 710 xtty->begin_elem("make_not_%scompilable thread='" UINTX_FORMAT "'", |
| 711 is_osr ? "osr_" : "", os::current_thread_id()); | |
| 7998 | 712 if (reason != NULL) { |
| 713 xtty->print(" reason=\'%s\'", reason); | |
| 714 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
715 xtty->method(this); |
| 0 | 716 xtty->stamp(); |
| 717 xtty->end_elem(); | |
| 718 } | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
719 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
720 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
721 bool Method::is_not_compilable(int comp_level) const { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
722 if (number_of_breakpoints() > 0) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
723 return true; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
724 if (is_method_handle_intrinsic()) |
|
9026
22851e342f0e
Make calling the installed code from compiled code possible.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9025
diff
changeset
|
725 return !is_synthetic() && intrinsic_id() != vmIntrinsics::_CompilerToVMImpl_executeCompiledMethod; // the generated adapters must be compiled |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
726 if (comp_level == CompLevel_any) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
727 return is_not_c1_compilable() || is_not_c2_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
728 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
729 return is_not_c1_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
730 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
731 return is_not_c2_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
732 return false; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
733 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
734 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
735 // call this when compiler finds that this method is not compilable |
| 7998 | 736 void Method::set_not_compilable(int comp_level, bool report, const char* reason) { |
| 737 print_made_not_compilable(comp_level, /*is_osr*/ false, report, reason); | |
| 1783 | 738 if (comp_level == CompLevel_all) { |
| 739 set_not_c1_compilable(); | |
| 740 set_not_c2_compilable(); | |
| 741 } else { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
742 if (is_c1_compile(comp_level)) |
| 1783 | 743 set_not_c1_compilable(); |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
744 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
745 set_not_c2_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
746 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
747 CompilationPolicy::policy()->disable_compilation(this); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
748 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
749 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
750 bool Method::is_not_osr_compilable(int comp_level) const { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
751 if (is_not_compilable(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
752 return true; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
753 if (comp_level == CompLevel_any) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
754 return is_not_c1_osr_compilable() || is_not_c2_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
755 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
756 return is_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
757 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
758 return is_not_c2_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
759 return false; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
760 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
761 |
| 7998 | 762 void Method::set_not_osr_compilable(int comp_level, bool report, const char* reason) { |
| 763 print_made_not_compilable(comp_level, /*is_osr*/ true, report, reason); | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
764 if (comp_level == CompLevel_all) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
765 set_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
766 set_not_c2_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
767 } else { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
768 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
769 set_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
770 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
771 set_not_c2_osr_compilable(); |
| 0 | 772 } |
| 1783 | 773 CompilationPolicy::policy()->disable_compilation(this); |
| 0 | 774 } |
| 775 | |
| 776 // Revert to using the interpreter and clear out the nmethod | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
777 void Method::clear_code() { |
| 0 | 778 |
| 779 // this may be NULL if c2i adapters have not been made yet | |
| 780 // Only should happen at allocate time. | |
| 781 if (_adapter == NULL) { | |
| 782 _from_compiled_entry = NULL; | |
| 783 } else { | |
| 784 _from_compiled_entry = _adapter->get_c2i_entry(); | |
| 785 } | |
| 786 OrderAccess::storestore(); | |
| 787 _from_interpreted_entry = _i2i_entry; | |
| 788 OrderAccess::storestore(); | |
| 789 _code = NULL; | |
| 790 } | |
| 791 | |
| 792 // Called by class data sharing to remove any entry points (which are not shared) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
793 void Method::unlink_method() { |
| 0 | 794 _code = NULL; |
| 795 _i2i_entry = NULL; | |
| 796 _from_interpreted_entry = NULL; | |
| 797 if (is_native()) { | |
| 798 *native_function_addr() = NULL; | |
| 799 set_signature_handler(NULL); | |
| 800 } | |
| 801 NOT_PRODUCT(set_compiled_invocation_count(0);) | |
| 802 invocation_counter()->reset(); | |
| 803 backedge_counter()->reset(); | |
| 804 _adapter = NULL; | |
| 805 _from_compiled_entry = NULL; | |
|
8751
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
806 |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
807 // In case of DumpSharedSpaces, _method_data should always be NULL. |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
808 // |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
809 // During runtime (!DumpSharedSpaces), when we are cleaning a |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
810 // shared class that failed to load, this->link_method() may |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
811 // have already been called (before an exception happened), so |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
812 // this->_method_data may not be NULL. |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
813 assert(!DumpSharedSpaces || _method_data == NULL, "unexpected method data?"); |
|
1fc4d4768b90
8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL)
coleenp
parents:
8715
diff
changeset
|
814 |
| 0 | 815 set_method_data(NULL); |
| 816 set_interpreter_throwout_count(0); | |
| 817 set_interpreter_invocation_count(0); | |
| 818 } | |
| 819 | |
| 820 // Called when the method_holder is getting linked. Setup entrypoints so the method | |
| 821 // is ready to be called from interpreter, compiler, and vtables. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
822 void Method::link_method(methodHandle h_method, TRAPS) { |
| 3404 | 823 // If the code cache is full, we may reenter this function for the |
| 824 // leftover methods that weren't linked. | |
| 825 if (_i2i_entry != NULL) return; | |
| 826 | |
| 0 | 827 assert(_adapter == NULL, "init'd to NULL" ); |
| 828 assert( _code == NULL, "nothing compiled yet" ); | |
| 829 | |
| 830 // Setup interpreter entrypoint | |
| 831 assert(this == h_method(), "wrong h_method()" ); | |
| 832 address entry = Interpreter::entry_for_method(h_method); | |
| 833 assert(entry != NULL, "interpreter entry must be non-null"); | |
| 834 // Sets both _i2i_entry and _from_interpreted_entry | |
| 835 set_interpreter_entry(entry); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
836 if (is_native() && !is_method_handle_intrinsic()) { |
| 0 | 837 set_native_function( |
| 838 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 839 !native_bind_event_is_interesting); | |
| 840 } | |
| 841 | |
| 842 // Setup compiler entrypoint. This is made eagerly, so we do not need | |
| 843 // special handling of vtables. An alternative is to make adapters more | |
| 844 // lazily by calling make_adapter() from from_compiled_entry() for the | |
| 845 // normal calls. For vtable calls life gets more complicated. When a | |
| 846 // call-site goes mega-morphic we need adapters in all methods which can be | |
| 847 // called from the vtable. We need adapters on such methods that get loaded | |
| 848 // later. Ditto for mega-morphic itable calls. If this proves to be a | |
| 849 // problem we'll make these lazily later. | |
|
3419
deaa3ce90583
7049928: VM crashes with "assert(_adapter != NULL) failed: must have" at methodOop.cpp:63
coleenp
parents:
3404
diff
changeset
|
850 (void) make_adapters(h_method, CHECK); |
| 0 | 851 |
| 852 // ONLY USE the h_method now as make_adapter may have blocked | |
|
9046
c6a1ffc707ff
Comments and #ifdef GRAAL for recent changes to C++ code for calling nmethods directly.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9026
diff
changeset
|
853 |
|
c6a1ffc707ff
Comments and #ifdef GRAAL for recent changes to C++ code for calling nmethods directly.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9026
diff
changeset
|
854 #ifdef GRAAL |
|
c6a1ffc707ff
Comments and #ifdef GRAAL for recent changes to C++ code for calling nmethods directly.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9026
diff
changeset
|
855 // Check for special intrinsic that executes a compiled method. |
|
9026
22851e342f0e
Make calling the installed code from compiled code possible.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9025
diff
changeset
|
856 if (h_method->intrinsic_id() == vmIntrinsics::_CompilerToVMImpl_executeCompiledMethod) { |
|
9046
c6a1ffc707ff
Comments and #ifdef GRAAL for recent changes to C++ code for calling nmethods directly.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9026
diff
changeset
|
857 // Actively install the stub for calling the intrinsic from compiled code. |
|
9026
22851e342f0e
Make calling the installed code from compiled code possible.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9025
diff
changeset
|
858 CompileBroker::compile_method(h_method, InvocationEntryBci, CompLevel_highest_tier, |
|
22851e342f0e
Make calling the installed code from compiled code possible.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9025
diff
changeset
|
859 methodHandle(), CompileThreshold, "executeCompiledMethod", CHECK); |
|
22851e342f0e
Make calling the installed code from compiled code possible.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9025
diff
changeset
|
860 } |
|
9046
c6a1ffc707ff
Comments and #ifdef GRAAL for recent changes to C++ code for calling nmethods directly.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9026
diff
changeset
|
861 #endif |
| 0 | 862 } |
| 863 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
864 address Method::make_adapters(methodHandle mh, TRAPS) { |
| 0 | 865 // Adapters for compiled code are made eagerly here. They are fairly |
| 866 // small (generally < 100 bytes) and quick to make (and cached and shared) | |
| 867 // so making them eagerly shouldn't be too expensive. | |
| 868 AdapterHandlerEntry* adapter = AdapterHandlerLibrary::get_adapter(mh); | |
| 869 if (adapter == NULL ) { | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1152
diff
changeset
|
870 THROW_MSG_NULL(vmSymbols::java_lang_VirtualMachineError(), "out of space in CodeCache for adapters"); |
| 0 | 871 } |
| 872 | |
| 873 mh->set_adapter_entry(adapter); | |
| 874 mh->_from_compiled_entry = adapter->get_c2i_entry(); | |
| 875 return adapter->get_c2i_entry(); | |
| 876 } | |
| 877 | |
| 878 // The verified_code_entry() must be called when a invoke is resolved | |
| 879 // on this method. | |
| 880 | |
| 881 // It returns the compiled code entry point, after asserting not null. | |
| 882 // This function is called after potential safepoints so that nmethod | |
| 883 // or adapter that it points to is still live and valid. | |
| 884 // This function must not hit a safepoint! | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
885 address Method::verified_code_entry() { |
| 0 | 886 debug_only(No_Safepoint_Verifier nsv;) |
| 1202 | 887 nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code); |
| 888 if (code == NULL && UseCodeCacheFlushing) { | |
| 889 nmethod *saved_code = CodeCache::find_and_remove_saved_code(this); | |
| 890 if (saved_code != NULL) { | |
| 891 methodHandle method(this); | |
| 892 assert( ! saved_code->is_osr_method(), "should not get here for osr" ); | |
| 893 set_code( method, saved_code ); | |
| 894 } | |
| 895 } | |
| 896 | |
| 0 | 897 assert(_from_compiled_entry != NULL, "must be set"); |
| 898 return _from_compiled_entry; | |
| 899 } | |
| 900 | |
| 901 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all | |
| 902 // (could be racing a deopt). | |
| 903 // Not inline to avoid circular ref. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
904 bool Method::check_code() const { |
| 0 | 905 // cached in a register or local. There's a race on the value of the field. |
| 906 nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
907 return code == NULL || (code->method() == NULL) || (code->method() == (Method*)this && !code->is_osr_method()); |
| 0 | 908 } |
| 909 | |
| 910 // Install compiled code. Instantly it can execute. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
911 void Method::set_code(methodHandle mh, nmethod *code) { |
| 0 | 912 assert( code, "use clear_code to remove code" ); |
| 913 assert( mh->check_code(), "" ); | |
| 914 | |
| 915 guarantee(mh->adapter() != NULL, "Adapter blob must already exist!"); | |
| 916 | |
| 917 // These writes must happen in this order, because the interpreter will | |
| 918 // directly jump to from_interpreted_entry which jumps to an i2c adapter | |
| 919 // which jumps to _from_compiled_entry. | |
| 920 mh->_code = code; // Assign before allowing compiled code to exec | |
| 921 | |
| 922 int comp_level = code->comp_level(); | |
| 923 // In theory there could be a race here. In practice it is unlikely | |
| 924 // and not worth worrying about. | |
| 1783 | 925 if (comp_level > mh->highest_comp_level()) { |
| 926 mh->set_highest_comp_level(comp_level); | |
| 0 | 927 } |
| 928 | |
| 929 OrderAccess::storestore(); | |
| 1692 | 930 #ifdef SHARK |
|
1845
a222fcfba398
6990549: Zero and Shark fixes after 6978355 and 6953144
twisti
parents:
1793
diff
changeset
|
931 mh->_from_interpreted_entry = code->insts_begin(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
932 #else //!SHARK |
| 0 | 933 mh->_from_compiled_entry = code->verified_entry_point(); |
| 934 OrderAccess::storestore(); | |
| 935 // Instantly compiled code can execute. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
936 if (!mh->is_method_handle_intrinsic()) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
937 mh->_from_interpreted_entry = mh->get_i2c_entry(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
938 #endif //!SHARK |
| 0 | 939 } |
| 940 | |
| 941 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
942 bool Method::is_overridden_in(Klass* k) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
943 InstanceKlass* ik = InstanceKlass::cast(k); |
| 0 | 944 |
| 945 if (ik->is_interface()) return false; | |
| 946 | |
| 947 // If method is an interface, we skip it - except if it | |
| 948 // is a miranda method | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
949 if (method_holder()->is_interface()) { |
| 0 | 950 // Check that method is not a miranda method |
| 951 if (ik->lookup_method(name(), signature()) == NULL) { | |
| 952 // No implementation exist - so miranda method | |
| 953 return false; | |
| 954 } | |
| 955 return true; | |
| 956 } | |
| 957 | |
| 958 assert(ik->is_subclass_of(method_holder()), "should be subklass"); | |
| 959 assert(ik->vtable() != NULL, "vtable should exist"); | |
| 960 if (vtable_index() == nonvirtual_vtable_index) { | |
| 961 return false; | |
| 962 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
963 Method* vt_m = ik->method_at_vtable(vtable_index()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
964 return vt_m != this; |
| 0 | 965 } |
| 966 } | |
| 967 | |
| 968 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
969 // give advice about whether this Method* should be cached or not |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
970 bool Method::should_not_be_cached() const { |
|
48
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
971 if (is_old()) { |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
972 // This method has been redefined. It is either EMCP or obsolete |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
973 // and we don't want to cache it because that would pin the method |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
974 // down and prevent it from being collectible if and when it |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
975 // finishes executing. |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
976 return true; |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
977 } |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
978 |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
979 // caching this method should be just fine |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
980 return false; |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
981 } |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
982 |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
983 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
984 /** |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
985 * Returns true if this is one of the specially treated methods for |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
986 * security related stack walks (like Reflection.getCallerClass). |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
987 */ |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
988 bool Method::is_ignored_by_security_stack_walk() const { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
989 const bool use_new_reflection = JDK_Version::is_gte_jdk14x_version() && UseNewReflection; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
990 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
991 assert(intrinsic_id() != vmIntrinsics::_invoke || Universe::reflect_invoke_cache()->is_same_method((Method*)this), "sanity"); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
992 if (intrinsic_id() == vmIntrinsics::_invoke) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
993 // This is Method.invoke() -- ignore it |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
994 return true; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
995 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
996 if (use_new_reflection && |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
997 method_holder()->is_subclass_of(SystemDictionary::reflect_MethodAccessorImpl_klass())) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
998 // This is an auxilary frame -- ignore it |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
999 return true; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1000 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1001 if (is_method_handle_intrinsic() || is_compiled_lambda_form()) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1002 // This is an internal adapter frame for method handles -- ignore it |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1003 return true; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1004 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1005 return false; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1006 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1007 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1008 |
| 710 | 1009 // Constant pool structure for invoke methods: |
| 1010 enum { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1011 _imcp_invoke_name = 1, // utf8: 'invokeExact', etc. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1012 _imcp_invoke_signature, // utf8: (variable Symbol*) |
| 710 | 1013 _imcp_limit |
| 1014 }; | |
| 1015 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1016 // Test if this method is an MH adapter frame generated by Java code. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1017 // Cf. java/lang/invoke/InvokerBytecodeGenerator |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1018 bool Method::is_compiled_lambda_form() const { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1019 return intrinsic_id() == vmIntrinsics::_compiledLambdaForm; |
| 710 | 1020 } |
| 1021 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1022 // Test if this method is an internal MH primitive method. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1023 bool Method::is_method_handle_intrinsic() const { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1024 vmIntrinsics::ID iid = intrinsic_id(); |
|
9025
ff5a32117e02
Implement fast invocation of installed code (direct tail call to the target machine code address).
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8883
diff
changeset
|
1025 return ((MethodHandles::is_signature_polymorphic(iid) && |
|
ff5a32117e02
Implement fast invocation of installed code (direct tail call to the target machine code address).
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
8883
diff
changeset
|
1026 MethodHandles::is_signature_polymorphic_intrinsic(iid))) || iid == vmIntrinsics::_CompilerToVMImpl_executeCompiledMethod; |
|
1152
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1142
diff
changeset
|
1027 } |
|
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1142
diff
changeset
|
1028 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1029 bool Method::has_member_arg() const { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1030 vmIntrinsics::ID iid = intrinsic_id(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1031 return (MethodHandles::is_signature_polymorphic(iid) && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1032 MethodHandles::has_member_arg(iid)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1033 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1034 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1035 // Make an instance of a signature-polymorphic internal MH primitive. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1036 methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid, |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1037 Symbol* signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1038 TRAPS) { |
|
3891
ac8738449b6f
7082949: JSR 292: missing ResourceMark in methodOopDesc::make_invoke_method
never
parents:
3795
diff
changeset
|
1039 ResourceMark rm; |
| 710 | 1040 methodHandle empty; |
| 1041 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1042 KlassHandle holder = SystemDictionary::MethodHandle_klass(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1043 Symbol* name = MethodHandles::signature_polymorphic_intrinsic_name(iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1044 assert(iid == MethodHandles::signature_polymorphic_name_id(name), ""); |
| 710 | 1045 if (TraceMethodHandles) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1046 tty->print_cr("make_method_handle_intrinsic MH.%s%s", name->as_C_string(), signature->as_C_string()); |
| 710 | 1047 } |
| 1048 | |
|
2478
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1049 // invariant: cp->symbol_at_put is preceded by a refcount increment (more usually a lookup) |
|
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1050 name->increment_refcount(); |
|
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1051 signature->increment_refcount(); |
|
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1052 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1053 int cp_length = _imcp_limit; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1054 ClassLoaderData* loader_data = holder->class_loader_data(); |
| 710 | 1055 constantPoolHandle cp; |
| 1056 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1057 ConstantPool* cp_oop = ConstantPool::allocate(loader_data, cp_length, CHECK_(empty)); |
| 710 | 1058 cp = constantPoolHandle(THREAD, cp_oop); |
| 1059 } | |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1060 cp->set_pool_holder(InstanceKlass::cast(holder())); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1061 cp->symbol_at_put(_imcp_invoke_name, name); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1062 cp->symbol_at_put(_imcp_invoke_signature, signature); |
|
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7470
diff
changeset
|
1063 cp->set_has_preresolution(); |
| 710 | 1064 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1065 // decide on access bits: public or not? |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1066 int flags_bits = (JVM_ACC_NATIVE | JVM_ACC_SYNTHETIC | JVM_ACC_FINAL); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1067 bool must_be_static = MethodHandles::is_signature_polymorphic_static(iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1068 if (must_be_static) flags_bits |= JVM_ACC_STATIC; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1069 assert((flags_bits & JVM_ACC_PUBLIC) == 0, "do not expose these methods"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1070 |
| 710 | 1071 methodHandle m; |
| 1072 { | |
| 8031 | 1073 InlineTableSizes sizes; |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1074 Method* m_oop = Method::allocate(loader_data, 0, |
| 8031 | 1075 accessFlags_from(flags_bits), &sizes, |
|
7462
ade95d680b42
8004728: Add hotspot support for parameter reflection
coleenp
parents:
7457
diff
changeset
|
1076 ConstMethod::NORMAL, CHECK_(empty)); |
| 710 | 1077 m = methodHandle(THREAD, m_oop); |
| 1078 } | |
| 1079 m->set_constants(cp()); | |
| 1080 m->set_name_index(_imcp_invoke_name); | |
| 1081 m->set_signature_index(_imcp_invoke_signature); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1082 assert(MethodHandles::is_signature_polymorphic_name(m->name()), ""); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1083 assert(m->signature() == signature, ""); |
| 710 | 1084 #ifdef CC_INTERP |
|
2256
173926398291
7018673: Zero: 6953144, 6990754 and 7009756 made some changes which broke Zero
twisti
parents:
2177
diff
changeset
|
1085 ResultTypeFinder rtf(signature); |
| 710 | 1086 m->set_result_index(rtf.type()); |
| 1087 #endif | |
| 1088 m->compute_size_of_parameters(THREAD); | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
1089 m->init_intrinsic_id(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1090 assert(m->is_method_handle_intrinsic(), ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1091 #ifdef ASSERT |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1092 if (!MethodHandles::is_signature_polymorphic(m->intrinsic_id())) m->print(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1093 assert(MethodHandles::is_signature_polymorphic(m->intrinsic_id()), "must be an invoker"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1094 assert(m->intrinsic_id() == iid, "correctly predicted iid"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1095 #endif //ASSERT |
| 710 | 1096 |
| 1097 // Finally, set up its entry points. | |
| 1098 assert(m->can_be_statically_bound(), ""); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1099 m->set_vtable_index(Method::nonvirtual_vtable_index); |
| 710 | 1100 m->link_method(m, CHECK_(empty)); |
| 1101 | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
856
diff
changeset
|
1102 if (TraceMethodHandles && (Verbose || WizardMode)) |
| 710 | 1103 m->print_on(tty); |
| 1104 | |
| 1105 return m; | |
| 1106 } | |
| 1107 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1108 Klass* Method::check_non_bcp_klass(Klass* klass) { |
| 6983 | 1109 if (klass != NULL && klass->class_loader() != NULL) { |
| 1110 if (klass->oop_is_objArray()) | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6800
diff
changeset
|
1111 klass = ObjArrayKlass::cast(klass)->bottom_klass(); |
|
3461
81d815b05abb
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3419
diff
changeset
|
1112 return klass; |
|
81d815b05abb
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3419
diff
changeset
|
1113 } |
|
81d815b05abb
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3419
diff
changeset
|
1114 return NULL; |
|
81d815b05abb
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3419
diff
changeset
|
1115 } |
| 710 | 1116 |
|
48
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
1117 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1118 methodHandle Method::clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length, |
| 0 | 1119 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS) { |
| 1120 // Code below does not work for native methods - they should never get rewritten anyway | |
| 1121 assert(!m->is_native(), "cannot rewrite native methods"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1122 // Allocate new Method* |
| 0 | 1123 AccessFlags flags = m->access_flags(); |
| 8031 | 1124 |
| 1125 ConstMethod* cm = m->constMethod(); | |
| 1126 int checked_exceptions_len = cm->checked_exceptions_length(); | |
| 1127 int localvariable_len = cm->localvariable_table_length(); | |
| 1128 int exception_table_len = cm->exception_table_length(); | |
| 1129 int method_parameters_len = cm->method_parameters_length(); | |
| 1130 int method_annotations_len = cm->method_annotations_length(); | |
| 1131 int parameter_annotations_len = cm->parameter_annotations_length(); | |
| 1132 int type_annotations_len = cm->type_annotations_length(); | |
| 1133 int default_annotations_len = cm->default_annotations_length(); | |
| 1134 | |
| 1135 InlineTableSizes sizes( | |
| 1136 localvariable_len, | |
| 1137 new_compressed_linenumber_size, | |
| 1138 exception_table_len, | |
| 1139 checked_exceptions_len, | |
| 1140 method_parameters_len, | |
| 1141 cm->generic_signature_index(), | |
| 1142 method_annotations_len, | |
| 1143 parameter_annotations_len, | |
| 1144 type_annotations_len, | |
| 1145 default_annotations_len, | |
| 1146 0); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1147 |
| 6934 | 1148 ClassLoaderData* loader_data = m->method_holder()->class_loader_data(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1149 Method* newm_oop = Method::allocate(loader_data, |
| 6934 | 1150 new_code_length, |
| 1151 flags, | |
| 8031 | 1152 &sizes, |
| 6934 | 1153 m->method_type(), |
| 1154 CHECK_(methodHandle())); | |
| 0 | 1155 methodHandle newm (THREAD, newm_oop); |
| 1156 int new_method_size = newm->method_size(); | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1157 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1158 // Create a shallow copy of Method part, but be careful to preserve the new ConstMethod* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1159 ConstMethod* newcm = newm->constMethod(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1160 int new_const_method_size = newm->constMethod()->size(); |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
1161 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1162 memcpy(newm(), m(), sizeof(Method)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1163 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1164 // Create shallow copy of ConstMethod. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1165 memcpy(newcm, m->constMethod(), sizeof(ConstMethod)); |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
1166 |
| 0 | 1167 // Reset correct method/const method, method size, and parameter info |
| 1168 newm->set_constMethod(newcm); | |
| 1169 newm->constMethod()->set_code_size(new_code_length); | |
| 1170 newm->constMethod()->set_constMethod_size(new_const_method_size); | |
| 1171 newm->set_method_size(new_method_size); | |
| 1172 assert(newm->code_size() == new_code_length, "check"); | |
| 1173 assert(newm->checked_exceptions_length() == checked_exceptions_len, "check"); | |
|
6216
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1174 assert(newm->exception_table_length() == exception_table_len, "check"); |
| 0 | 1175 assert(newm->localvariable_table_length() == localvariable_len, "check"); |
| 1176 // Copy new byte codes | |
| 1177 memcpy(newm->code_base(), new_code, new_code_length); | |
| 1178 // Copy line number table | |
| 1179 if (new_compressed_linenumber_size > 0) { | |
| 1180 memcpy(newm->compressed_linenumber_table(), | |
| 1181 new_compressed_linenumber_table, | |
| 1182 new_compressed_linenumber_size); | |
| 1183 } | |
| 1184 // Copy checked_exceptions | |
| 1185 if (checked_exceptions_len > 0) { | |
| 1186 memcpy(newm->checked_exceptions_start(), | |
| 1187 m->checked_exceptions_start(), | |
| 1188 checked_exceptions_len * sizeof(CheckedExceptionElement)); | |
| 1189 } | |
|
6216
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1190 // Copy exception table |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1191 if (exception_table_len > 0) { |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1192 memcpy(newm->exception_table_start(), |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1193 m->exception_table_start(), |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1194 exception_table_len * sizeof(ExceptionTableElement)); |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1195 } |
| 0 | 1196 // Copy local variable number table |
| 1197 if (localvariable_len > 0) { | |
| 1198 memcpy(newm->localvariable_table_start(), | |
| 1199 m->localvariable_table_start(), | |
| 1200 localvariable_len * sizeof(LocalVariableTableElement)); | |
| 1201 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1202 // Copy stackmap table |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1203 if (m->has_stackmap_table()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1204 int code_attribute_length = m->stackmap_data()->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1205 Array<u1>* stackmap_data = |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1206 MetadataFactory::new_array<u1>(loader_data, code_attribute_length, 0, CHECK_NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1207 memcpy((void*)stackmap_data->adr_at(0), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1208 (void*)m->stackmap_data()->adr_at(0), code_attribute_length); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1209 newm->set_stackmap_data(stackmap_data); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1210 } |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1211 |
|
8837
0c3ee6f1fa23
8009531: Crash when redefining class with annotated method
coleenp
parents:
8751
diff
changeset
|
1212 // copy annotations over to new method |
|
0c3ee6f1fa23
8009531: Crash when redefining class with annotated method
coleenp
parents:
8751
diff
changeset
|
1213 newcm->copy_annotations_from(cm); |
| 0 | 1214 return newm; |
| 1215 } | |
| 1216 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1217 vmSymbols::SID Method::klass_id_for_intrinsics(Klass* holder) { |
| 0 | 1218 // if loader is not the default loader (i.e., != NULL), we can't know the intrinsics |
| 1219 // because we are not loading from core libraries | |
| 6894 | 1220 // exception: the AES intrinsics come from lib/ext/sunjce_provider.jar |
| 1221 // which does not use the class default class loader so we check for its loader here | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1222 InstanceKlass* ik = InstanceKlass::cast(holder); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1223 if ((ik->class_loader() != NULL) && !SystemDictionary::is_ext_class_loader(ik->class_loader())) { |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1224 return vmSymbols::NO_SID; // regardless of name, no intrinsics here |
| 6894 | 1225 } |
| 0 | 1226 |
| 1227 // see if the klass name is well-known: | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8751
diff
changeset
|
1228 Symbol* klass_name = ik->name(); |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1229 return vmSymbols::find_sid(klass_name); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1230 } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1231 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1232 void Method::init_intrinsic_id() { |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1233 assert(_intrinsic_id == vmIntrinsics::_none, "do this just once"); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1234 const uintptr_t max_id_uint = right_n_bits((int)(sizeof(_intrinsic_id) * BitsPerByte)); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1235 assert((uintptr_t)vmIntrinsics::ID_LIMIT <= max_id_uint, "else fix size"); |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
1236 assert(intrinsic_id_size_in_bytes() == sizeof(_intrinsic_id), ""); |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1237 |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1238 // the klass name is well-known: |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1239 vmSymbols::SID klass_id = klass_id_for_intrinsics(method_holder()); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1240 assert(klass_id != vmSymbols::NO_SID, "caller responsibility"); |
| 0 | 1241 |
| 1242 // ditto for method and signature: | |
| 1243 vmSymbols::SID name_id = vmSymbols::find_sid(name()); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1244 if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1245 && name_id == vmSymbols::NO_SID) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1246 return; |
| 0 | 1247 vmSymbols::SID sig_id = vmSymbols::find_sid(signature()); |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
1248 if (klass_id != vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle) |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
1249 && sig_id == vmSymbols::NO_SID) return; |
| 0 | 1250 jshort flags = access_flags().as_short(); |
| 1251 | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1252 vmIntrinsics::ID id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1253 if (id != vmIntrinsics::_none) { |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1254 set_intrinsic_id(id); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1255 return; |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1256 } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1257 |
| 0 | 1258 // A few slightly irregular cases: |
| 1259 switch (klass_id) { | |
| 1260 case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_StrictMath): | |
| 1261 // Second chance: check in regular Math. | |
| 1262 switch (name_id) { | |
| 1263 case vmSymbols::VM_SYMBOL_ENUM_NAME(min_name): | |
| 1264 case vmSymbols::VM_SYMBOL_ENUM_NAME(max_name): | |
| 1265 case vmSymbols::VM_SYMBOL_ENUM_NAME(sqrt_name): | |
| 1266 // pretend it is the corresponding method in the non-strict class: | |
| 1267 klass_id = vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_Math); | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1268 id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags); |
| 0 | 1269 break; |
| 1270 } | |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1271 break; |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1272 |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1273 // Signature-polymorphic methods: MethodHandle.invoke*, InvokeDynamic.*. |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
1274 case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle): |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1275 if (!is_native()) break; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1276 id = MethodHandles::signature_polymorphic_name_id(method_holder(), name()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1277 if (is_static() != MethodHandles::is_signature_polymorphic_static(id)) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1278 id = vmIntrinsics::_none; |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1279 break; |
| 0 | 1280 } |
| 1281 | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1282 if (id != vmIntrinsics::_none) { |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1283 // Set up its iid. It is an alias method. |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1284 set_intrinsic_id(id); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1285 return; |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1286 } |
| 0 | 1287 } |
| 1288 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1289 // These two methods are static since a GC may move the Method |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1290 bool Method::load_signature_classes(methodHandle m, TRAPS) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1291 if (THREAD->is_Compiler_thread()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1292 // There is nothing useful this routine can do from within the Compile thread. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1293 // Hopefully, the signature contains only well-known classes. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1294 // We could scan for this and return true/false, but the caller won't care. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1295 return false; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1296 } |
| 0 | 1297 bool sig_is_loaded = true; |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1298 Handle class_loader(THREAD, m->method_holder()->class_loader()); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1299 Handle protection_domain(THREAD, m->method_holder()->protection_domain()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1300 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1301 Symbol* signature = m->signature(); |
| 0 | 1302 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
| 1303 if (ss.is_object()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1304 Symbol* sym = ss.as_symbol(CHECK_(false)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1305 Symbol* name = sym; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1306 Klass* klass = SystemDictionary::resolve_or_null(name, class_loader, |
| 0 | 1307 protection_domain, THREAD); |
|
104
541929da62d2
6624474: Server compiler generates unexpected LinkageError
rasbold
parents:
48
diff
changeset
|
1308 // We are loading classes eagerly. If a ClassNotFoundException or |
|
541929da62d2
6624474: Server compiler generates unexpected LinkageError
rasbold
parents:
48
diff
changeset
|
1309 // a LinkageError was generated, be sure to ignore it. |
| 0 | 1310 if (HAS_PENDING_EXCEPTION) { |
| 1142 | 1311 if (PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass()) || |
| 1312 PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { | |
| 0 | 1313 CLEAR_PENDING_EXCEPTION; |
| 1314 } else { | |
| 1315 return false; | |
| 1316 } | |
| 1317 } | |
| 1318 if( klass == NULL) { sig_is_loaded = false; } | |
| 1319 } | |
| 1320 } | |
| 1321 return sig_is_loaded; | |
| 1322 } | |
| 1323 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1324 bool Method::has_unloaded_classes_in_signature(methodHandle m, TRAPS) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1325 Handle class_loader(THREAD, m->method_holder()->class_loader()); |
|
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1326 Handle protection_domain(THREAD, m->method_holder()->protection_domain()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1327 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1328 Symbol* signature = m->signature(); |
| 0 | 1329 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
| 1330 if (ss.type() == T_OBJECT) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1331 Symbol* name = ss.as_symbol_or_null(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1332 if (name == NULL) return true; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1333 Klass* klass = SystemDictionary::find(name, class_loader, protection_domain, THREAD); |
| 0 | 1334 if (klass == NULL) return true; |
| 1335 } | |
| 1336 } | |
| 1337 return false; | |
| 1338 } | |
| 1339 | |
| 1340 // Exposed so field engineers can debug VM | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1341 void Method::print_short_name(outputStream* st) { |
| 0 | 1342 ResourceMark rm; |
| 1343 #ifdef PRODUCT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1344 st->print(" %s::", method_holder()->external_name()); |
| 0 | 1345 #else |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1346 st->print(" %s::", method_holder()->internal_name()); |
| 0 | 1347 #endif |
| 1348 name()->print_symbol_on(st); | |
| 1349 if (WizardMode) signature()->print_symbol_on(st); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1350 else if (MethodHandles::is_signature_polymorphic(intrinsic_id())) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1351 MethodHandles::print_as_basic_type_signature_on(st, signature(), true); |
| 0 | 1352 } |
| 1353 | |
| 3779 | 1354 // Comparer for sorting an object array containing |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1355 // Method*s. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1356 static int method_comparator(Method* a, Method* b) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1357 return a->name()->fast_compare(b->name()); |
|
3929
f94227b6117b
7090259: Fix hotspot sources to build with old compilers
kvn
parents:
3891
diff
changeset
|
1358 } |
| 0 | 1359 |
| 1360 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array | |
| 8031 | 1361 void Method::sort_methods(Array<Method*>* methods, bool idempotent) { |
| 0 | 1362 int length = methods->length(); |
| 1363 if (length > 1) { | |
| 3779 | 1364 { |
| 1365 No_Safepoint_Verifier nsv; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1366 QuickSort::sort<Method*>(methods->data(), length, method_comparator, idempotent); |
| 0 | 1367 } |
| 1368 // Reset method ordering | |
| 1369 for (int i = 0; i < length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1370 Method* m = methods->at(i); |
| 0 | 1371 m->set_method_idnum(i); |
| 1372 } | |
| 1373 } | |
| 1374 } | |
| 1375 | |
| 1376 | |
| 1377 //----------------------------------------------------------------------------------- | |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1378 // Non-product code unless JVM/TI needs it |
| 0 | 1379 |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1380 #if !defined(PRODUCT) || INCLUDE_JVMTI |
| 0 | 1381 class SignatureTypePrinter : public SignatureTypeNames { |
| 1382 private: | |
| 1383 outputStream* _st; | |
| 1384 bool _use_separator; | |
| 1385 | |
| 1386 void type_name(const char* name) { | |
| 1387 if (_use_separator) _st->print(", "); | |
| 1388 _st->print(name); | |
| 1389 _use_separator = true; | |
| 1390 } | |
| 1391 | |
| 1392 public: | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1393 SignatureTypePrinter(Symbol* signature, outputStream* st) : SignatureTypeNames(signature) { |
| 0 | 1394 _st = st; |
| 1395 _use_separator = false; | |
| 1396 } | |
| 1397 | |
| 1398 void print_parameters() { _use_separator = false; iterate_parameters(); } | |
| 1399 void print_returntype() { _use_separator = false; iterate_returntype(); } | |
| 1400 }; | |
| 1401 | |
| 1402 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1403 void Method::print_name(outputStream* st) { |
| 0 | 1404 Thread *thread = Thread::current(); |
| 1405 ResourceMark rm(thread); | |
| 1406 SignatureTypePrinter sig(signature(), st); | |
| 1407 st->print("%s ", is_static() ? "static" : "virtual"); | |
| 1408 sig.print_returntype(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1409 st->print(" %s.", method_holder()->internal_name()); |
| 0 | 1410 name()->print_symbol_on(st); |
| 1411 st->print("("); | |
| 1412 sig.print_parameters(); | |
| 1413 st->print(")"); | |
| 1414 } | |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1415 #endif // !PRODUCT || INCLUDE_JVMTI |
| 0 | 1416 |
| 1417 | |
|
8021
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1418 //----------------------------------------------------------------------------------- |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1419 // Non-product code |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1420 |
|
8d9fc28831cc
7182152: Instrumentation hot swap test incorrect monitor count
dcubed
parents:
7956
diff
changeset
|
1421 #ifndef PRODUCT |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1422 void Method::print_codes_on(outputStream* st) const { |
| 0 | 1423 print_codes_on(0, code_size(), st); |
| 1424 } | |
| 1425 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1426 void Method::print_codes_on(int from, int to, outputStream* st) const { |
| 0 | 1427 Thread *thread = Thread::current(); |
| 1428 ResourceMark rm(thread); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1429 methodHandle mh (thread, (Method*)this); |
| 0 | 1430 BytecodeStream s(mh); |
| 1431 s.set_interval(from, to); | |
| 1432 BytecodeTracer::set_closure(BytecodeTracer::std_closure()); | |
| 1433 while (s.next() >= 0) BytecodeTracer::trace(mh, s.bcp(), st); | |
| 1434 } | |
| 1435 #endif // not PRODUCT | |
| 1436 | |
| 1437 | |
| 1438 // Simple compression of line number tables. We use a regular compressed stream, except that we compress deltas | |
| 1439 // between (bci,line) pairs since they are smaller. If (bci delta, line delta) fits in (5-bit unsigned, 3-bit unsigned) | |
| 1440 // we save it as one byte, otherwise we write a 0xFF escape character and use regular compression. 0x0 is used | |
| 1441 // as end-of-stream terminator. | |
| 1442 | |
| 1443 void CompressedLineNumberWriteStream::write_pair_regular(int bci_delta, int line_delta) { | |
| 1444 // bci and line number does not compress into single byte. | |
| 1445 // Write out escape character and use regular compression for bci and line number. | |
| 1446 write_byte((jubyte)0xFF); | |
| 1447 write_signed_int(bci_delta); | |
| 1448 write_signed_int(line_delta); | |
| 1449 } | |
| 1450 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1451 // See comment in method.hpp which explains why this exists. |
|
2233
15d6977f04b0
7017824: Add support for creating 64-bit Visual Studio projects
sla
parents:
2177
diff
changeset
|
1452 #if defined(_M_AMD64) && _MSC_VER >= 1400 |
| 0 | 1453 #pragma optimize("", off) |
| 1454 void CompressedLineNumberWriteStream::write_pair(int bci, int line) { | |
| 1455 write_pair_inline(bci, line); | |
| 1456 } | |
| 1457 #pragma optimize("", on) | |
| 1458 #endif | |
| 1459 | |
| 1460 CompressedLineNumberReadStream::CompressedLineNumberReadStream(u_char* buffer) : CompressedReadStream(buffer) { | |
| 1461 _bci = 0; | |
| 1462 _line = 0; | |
| 1463 }; | |
| 1464 | |
| 1465 | |
| 1466 bool CompressedLineNumberReadStream::read_pair() { | |
| 1467 jubyte next = read_byte(); | |
| 1468 // Check for terminator | |
| 1469 if (next == 0) return false; | |
| 1470 if (next == 0xFF) { | |
| 1471 // Escape character, regular compression used | |
| 1472 _bci += read_signed_int(); | |
| 1473 _line += read_signed_int(); | |
| 1474 } else { | |
| 1475 // Single byte compression used | |
| 1476 _bci += next >> 3; | |
| 1477 _line += next & 0x7; | |
| 1478 } | |
| 1479 return true; | |
| 1480 } | |
| 1481 | |
| 1482 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1483 Bytecodes::Code Method::orig_bytecode_at(int bci) const { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1484 BreakpointInfo* bp = method_holder()->breakpoints(); |
| 0 | 1485 for (; bp != NULL; bp = bp->next()) { |
| 1486 if (bp->match(this, bci)) { | |
| 1487 return bp->orig_bytecode(); | |
| 1488 } | |
| 1489 } | |
| 1490 ShouldNotReachHere(); | |
| 1491 return Bytecodes::_shouldnotreachhere; | |
| 1492 } | |
| 1493 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1494 void Method::set_orig_bytecode_at(int bci, Bytecodes::Code code) { |
| 0 | 1495 assert(code != Bytecodes::_breakpoint, "cannot patch breakpoints this way"); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1496 BreakpointInfo* bp = method_holder()->breakpoints(); |
| 0 | 1497 for (; bp != NULL; bp = bp->next()) { |
| 1498 if (bp->match(this, bci)) { | |
| 1499 bp->set_orig_bytecode(code); | |
| 1500 // and continue, in case there is more than one | |
| 1501 } | |
| 1502 } | |
| 1503 } | |
| 1504 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1505 void Method::set_breakpoint(int bci) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1506 InstanceKlass* ik = method_holder(); |
| 0 | 1507 BreakpointInfo *bp = new BreakpointInfo(this, bci); |
| 1508 bp->set_next(ik->breakpoints()); | |
| 1509 ik->set_breakpoints(bp); | |
| 1510 // do this last: | |
| 1511 bp->set(this); | |
| 1512 } | |
| 1513 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1514 static void clear_matches(Method* m, int bci) { |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1515 InstanceKlass* ik = m->method_holder(); |
| 0 | 1516 BreakpointInfo* prev_bp = NULL; |
| 1517 BreakpointInfo* next_bp; | |
| 1518 for (BreakpointInfo* bp = ik->breakpoints(); bp != NULL; bp = next_bp) { | |
| 1519 next_bp = bp->next(); | |
| 1520 // bci value of -1 is used to delete all breakpoints in method m (ex: clear_all_breakpoint). | |
| 1521 if (bci >= 0 ? bp->match(m, bci) : bp->match(m)) { | |
| 1522 // do this first: | |
| 1523 bp->clear(m); | |
| 1524 // unhook it | |
| 1525 if (prev_bp != NULL) | |
| 1526 prev_bp->set_next(next_bp); | |
| 1527 else | |
| 1528 ik->set_breakpoints(next_bp); | |
| 1529 delete bp; | |
| 1530 // When class is redefined JVMTI sets breakpoint in all versions of EMCP methods | |
| 1531 // at same location. So we have multiple matching (method_index and bci) | |
| 1532 // BreakpointInfo nodes in BreakpointInfo list. We should just delete one | |
| 1533 // breakpoint for clear_breakpoint request and keep all other method versions | |
| 1534 // BreakpointInfo for future clear_breakpoint request. | |
| 1535 // bcivalue of -1 is used to clear all breakpoints (see clear_all_breakpoints) | |
| 1536 // which is being called when class is unloaded. We delete all the Breakpoint | |
| 1537 // information for all versions of method. We may not correctly restore the original | |
| 1538 // bytecode in all method versions, but that is ok. Because the class is being unloaded | |
| 1539 // so these methods won't be used anymore. | |
| 1540 if (bci >= 0) { | |
| 1541 break; | |
| 1542 } | |
| 1543 } else { | |
| 1544 // This one is a keeper. | |
| 1545 prev_bp = bp; | |
| 1546 } | |
| 1547 } | |
| 1548 } | |
| 1549 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1550 void Method::clear_breakpoint(int bci) { |
| 0 | 1551 assert(bci >= 0, ""); |
| 1552 clear_matches(this, bci); | |
| 1553 } | |
| 1554 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1555 void Method::clear_all_breakpoints() { |
| 0 | 1556 clear_matches(this, -1); |
| 1557 } | |
| 1558 | |
| 1559 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1560 int Method::invocation_count() { |
| 1783 | 1561 if (TieredCompilation) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1562 MethodData* const mdo = method_data(); |
| 1783 | 1563 if (invocation_counter()->carry() || ((mdo != NULL) ? mdo->invocation_counter()->carry() : false)) { |
| 1564 return InvocationCounter::count_limit; | |
| 1565 } else { | |
| 1566 return invocation_counter()->count() + ((mdo != NULL) ? mdo->invocation_counter()->count() : 0); | |
| 1567 } | |
| 1568 } else { | |
| 1569 return invocation_counter()->count(); | |
| 1570 } | |
| 1571 } | |
| 1572 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1573 int Method::backedge_count() { |
| 1783 | 1574 if (TieredCompilation) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1575 MethodData* const mdo = method_data(); |
| 1783 | 1576 if (backedge_counter()->carry() || ((mdo != NULL) ? mdo->backedge_counter()->carry() : false)) { |
| 1577 return InvocationCounter::count_limit; | |
| 1578 } else { | |
| 1579 return backedge_counter()->count() + ((mdo != NULL) ? mdo->backedge_counter()->count() : 0); | |
| 1580 } | |
| 1581 } else { | |
| 1582 return backedge_counter()->count(); | |
| 1583 } | |
| 1584 } | |
| 1585 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1586 int Method::highest_comp_level() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1587 MethodData* mdo = method_data(); |
| 1783 | 1588 if (mdo != NULL) { |
| 1589 return mdo->highest_comp_level(); | |
| 1590 } else { | |
| 1591 return CompLevel_none; | |
| 1592 } | |
| 1593 } | |
| 1594 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1595 int Method::highest_osr_comp_level() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1596 MethodData* mdo = method_data(); |
| 1783 | 1597 if (mdo != NULL) { |
| 1598 return mdo->highest_osr_comp_level(); | |
| 1599 } else { | |
| 1600 return CompLevel_none; | |
| 1601 } | |
| 1602 } | |
| 1603 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1604 void Method::set_highest_comp_level(int level) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1605 MethodData* mdo = method_data(); |
| 1783 | 1606 if (mdo != NULL) { |
| 1607 mdo->set_highest_comp_level(level); | |
| 1608 } | |
| 1609 } | |
| 1610 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1611 void Method::set_highest_osr_comp_level(int level) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1612 MethodData* mdo = method_data(); |
| 1783 | 1613 if (mdo != NULL) { |
| 1614 mdo->set_highest_osr_comp_level(level); | |
| 1615 } | |
| 1616 } | |
| 1617 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1618 BreakpointInfo::BreakpointInfo(Method* m, int bci) { |
| 0 | 1619 _bci = bci; |
| 1620 _name_index = m->name_index(); | |
| 1621 _signature_index = m->signature_index(); | |
| 1622 _orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci); | |
| 1623 if (_orig_bytecode == Bytecodes::_breakpoint) | |
| 1624 _orig_bytecode = m->orig_bytecode_at(_bci); | |
| 1625 _next = NULL; | |
| 1626 } | |
| 1627 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1628 void BreakpointInfo::set(Method* method) { |
| 0 | 1629 #ifdef ASSERT |
| 1630 { | |
| 1631 Bytecodes::Code code = (Bytecodes::Code) *method->bcp_from(_bci); | |
| 1632 if (code == Bytecodes::_breakpoint) | |
| 1633 code = method->orig_bytecode_at(_bci); | |
| 1634 assert(orig_bytecode() == code, "original bytecode must be the same"); | |
| 1635 } | |
| 1636 #endif | |
| 1637 *method->bcp_from(_bci) = Bytecodes::_breakpoint; | |
| 1638 method->incr_number_of_breakpoints(); | |
| 1639 SystemDictionary::notice_modification(); | |
| 1640 { | |
| 1641 // Deoptimize all dependents on this method | |
| 1642 Thread *thread = Thread::current(); | |
| 1643 HandleMark hm(thread); | |
| 1644 methodHandle mh(thread, method); | |
| 1645 Universe::flush_dependents_on_method(mh); | |
| 1646 } | |
| 1647 } | |
| 1648 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1649 void BreakpointInfo::clear(Method* method) { |
| 0 | 1650 *method->bcp_from(_bci) = orig_bytecode(); |
| 1651 assert(method->number_of_breakpoints() > 0, "must not go negative"); | |
| 1652 method->decr_number_of_breakpoints(); | |
| 1653 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1654 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1655 // jmethodID handling |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1656 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1657 // This is a block allocating object, sort of like JNIHandleBlock, only a |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1658 // lot simpler. There aren't many of these, they aren't long, they are rarely |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1659 // deleted and so we can do some suboptimal things. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1660 // It's allocated on the CHeap because once we allocate a jmethodID, we can |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1661 // never get rid of it. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1662 // It would be nice to be able to parameterize the number of methods for |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1663 // the null_class_loader but then we'd have to turn this and ClassLoaderData |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1664 // into templates. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1665 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1666 // I feel like this brain dead class should exist somewhere in the STL |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1667 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1668 class JNIMethodBlock : public CHeapObj<mtClass> { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1669 enum { number_of_methods = 8 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1670 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1671 Method* _methods[number_of_methods]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1672 int _top; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1673 JNIMethodBlock* _next; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1674 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1675 static Method* const _free_method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1676 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1677 JNIMethodBlock() : _next(NULL), _top(0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1678 for (int i = 0; i< number_of_methods; i++) _methods[i] = _free_method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1679 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1680 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1681 Method** add_method(Method* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1682 if (_top < number_of_methods) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1683 // top points to the next free entry. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1684 int i = _top; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1685 _methods[i] = m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1686 _top++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1687 return &_methods[i]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1688 } else if (_top == number_of_methods) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1689 // if the next free entry ran off the block see if there's a free entry |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1690 for (int i = 0; i< number_of_methods; i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1691 if (_methods[i] == _free_method) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1692 _methods[i] = m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1693 return &_methods[i]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1694 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1695 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1696 // Only check each block once for frees. They're very unlikely. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1697 // Increment top past the end of the block. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1698 _top++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1699 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1700 // need to allocate a next block. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1701 if (_next == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1702 _next = new JNIMethodBlock(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1703 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1704 return _next->add_method(m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1705 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1706 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1707 bool contains(Method** m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1708 for (JNIMethodBlock* b = this; b != NULL; b = b->_next) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1709 for (int i = 0; i< number_of_methods; i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1710 if (&(b->_methods[i]) == m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1711 return true; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1712 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1713 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1714 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1715 return false; // not found |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1716 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1717 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1718 // Doesn't really destroy it, just marks it as free so it can be reused. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1719 void destroy_method(Method** m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1720 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1721 assert(contains(m), "should be a methodID"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1722 #endif // ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1723 *m = _free_method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1724 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1725 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1726 // During class unloading the methods are cleared, which is different |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1727 // than freed. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1728 void clear_all_methods() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1729 for (JNIMethodBlock* b = this; b != NULL; b = b->_next) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1730 for (int i = 0; i< number_of_methods; i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1731 _methods[i] = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1732 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1733 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1734 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1735 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1736 int count_methods() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1737 // count all allocated methods |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1738 int count = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1739 for (JNIMethodBlock* b = this; b != NULL; b = b->_next) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1740 for (int i = 0; i< number_of_methods; i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1741 if (_methods[i] != _free_method) count++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1742 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1743 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1744 return count; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1745 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1746 #endif // PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1747 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1748 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1749 // Something that can't be mistaken for an address or a markOop |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1750 Method* const JNIMethodBlock::_free_method = (Method*)55; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1751 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1752 // Add a method id to the jmethod_ids |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1753 jmethodID Method::make_jmethod_id(ClassLoaderData* loader_data, Method* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1754 ClassLoaderData* cld = loader_data; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1755 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1756 if (!SafepointSynchronize::is_at_safepoint()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1757 // Have to add jmethod_ids() to class loader data thread-safely. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1758 // Also have to add the method to the list safely, which the cld lock |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1759 // protects as well. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1760 MutexLockerEx ml(cld->metaspace_lock(), Mutex::_no_safepoint_check_flag); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1761 if (cld->jmethod_ids() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1762 cld->set_jmethod_ids(new JNIMethodBlock()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1763 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1764 // jmethodID is a pointer to Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1765 return (jmethodID)cld->jmethod_ids()->add_method(m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1766 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1767 // At safepoint, we are single threaded and can set this. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1768 if (cld->jmethod_ids() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1769 cld->set_jmethod_ids(new JNIMethodBlock()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1770 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1771 // jmethodID is a pointer to Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1772 return (jmethodID)cld->jmethod_ids()->add_method(m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1773 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1774 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1775 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1776 // Mark a jmethodID as free. This is called when there is a data race in |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1777 // InstanceKlass while creating the jmethodID cache. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1778 void Method::destroy_jmethod_id(ClassLoaderData* loader_data, jmethodID m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1779 ClassLoaderData* cld = loader_data; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1780 Method** ptr = (Method**)m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1781 assert(cld->jmethod_ids() != NULL, "should have method handles"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1782 cld->jmethod_ids()->destroy_method(ptr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1783 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1784 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1785 void Method::change_method_associated_with_jmethod_id(jmethodID jmid, Method* new_method) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1786 // Can't assert the method_holder is the same because the new method has the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1787 // scratch method holder. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1788 assert(resolve_jmethod_id(jmid)->method_holder()->class_loader() |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1789 == new_method->method_holder()->class_loader(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1790 "changing to a different class loader"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1791 // Just change the method in place, jmethodID pointer doesn't change. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1792 *((Method**)jmid) = new_method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1793 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1794 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1795 bool Method::is_method_id(jmethodID mid) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1796 Method* m = resolve_jmethod_id(mid); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1797 assert(m != NULL, "should be called with non-null method"); |
|
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6935
diff
changeset
|
1798 InstanceKlass* ik = m->method_holder(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1799 ClassLoaderData* cld = ik->class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1800 if (cld->jmethod_ids() == NULL) return false; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1801 return (cld->jmethod_ids()->contains((Method**)mid)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1802 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1803 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1804 Method* Method::checked_resolve_jmethod_id(jmethodID mid) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1805 if (mid == NULL) return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1806 Method* o = resolve_jmethod_id(mid); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1807 if (o == NULL || o == JNIMethodBlock::_free_method || !((Metadata*)o)->is_method()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1808 return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1809 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1810 return o; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1811 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1812 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1813 void Method::set_on_stack(const bool value) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1814 // Set both the method itself and its constant pool. The constant pool |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1815 // on stack means some method referring to it is also on the stack. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1816 _access_flags.set_on_stack(value); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1817 constants()->set_on_stack(value); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1818 if (value) MetadataOnStackMark::record(this); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1819 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1820 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1821 // Called when the class loader is unloaded to make all methods weak. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1822 void Method::clear_jmethod_ids(ClassLoaderData* loader_data) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1823 loader_data->jmethod_ids()->clear_all_methods(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1824 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1825 |
|
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1826 |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1827 // Check that this pointer is valid by checking that the vtbl pointer matches |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1828 bool Method::is_valid_method() const { |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1829 if (this == NULL) { |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1830 return false; |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1831 } else if (!is_metaspace_object()) { |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1832 return false; |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1833 } else { |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1834 Method m; |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1835 // This assumes that the vtbl pointer is the first word of a C++ object. |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1836 // This assumption is also in universe.cpp patch_klass_vtble |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1837 void* vtbl2 = dereference_vptr((void*)&m); |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1838 void* this_vtbl = dereference_vptr((void*)this); |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1839 return vtbl2 == this_vtbl; |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1840 } |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1841 } |
|
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1842 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1843 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1844 void Method::print_jmethod_ids(ClassLoaderData* loader_data, outputStream* out) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1845 out->print_cr("jni_method_id count = %d", loader_data->jmethod_ids()->count_methods()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1846 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1847 #endif // PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1848 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1849 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1850 // Printing |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1851 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1852 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1853 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1854 void Method::print_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1855 ResourceMark rm; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1856 assert(is_method(), "must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1857 st->print_cr(internal_name()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1858 // get the effect of PrintOopAddress, always, for methods: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1859 st->print_cr(" - this oop: "INTPTR_FORMAT, (intptr_t)this); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1860 st->print (" - method holder: "); method_holder()->print_value_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1861 st->print (" - constants: "INTPTR_FORMAT" ", (address)constants()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1862 constants()->print_value_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1863 st->print (" - access: 0x%x ", access_flags().as_int()); access_flags().print_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1864 st->print (" - name: "); name()->print_value_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1865 st->print (" - signature: "); signature()->print_value_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1866 st->print_cr(" - max stack: %d", max_stack()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1867 st->print_cr(" - max locals: %d", max_locals()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1868 st->print_cr(" - size of params: %d", size_of_parameters()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1869 st->print_cr(" - method size: %d", method_size()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1870 if (intrinsic_id() != vmIntrinsics::_none) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1871 st->print_cr(" - intrinsic id: %d %s", intrinsic_id(), vmIntrinsics::name_at(intrinsic_id())); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1872 if (highest_comp_level() != CompLevel_none) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1873 st->print_cr(" - highest level: %d", highest_comp_level()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1874 st->print_cr(" - vtable index: %d", _vtable_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1875 st->print_cr(" - i2i entry: " INTPTR_FORMAT, interpreter_entry()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1876 st->print( " - adapters: "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1877 AdapterHandlerEntry* a = ((Method*)this)->adapter(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1878 if (a == NULL) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1879 st->print_cr(INTPTR_FORMAT, a); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1880 else |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1881 a->print_adapter_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1882 st->print_cr(" - compiled entry " INTPTR_FORMAT, from_compiled_entry()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1883 st->print_cr(" - code size: %d", code_size()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1884 if (code_size() != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1885 st->print_cr(" - code start: " INTPTR_FORMAT, code_base()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1886 st->print_cr(" - code end (excl): " INTPTR_FORMAT, code_base() + code_size()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1887 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1888 if (method_data() != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1889 st->print_cr(" - method data: " INTPTR_FORMAT, (address)method_data()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1890 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1891 st->print_cr(" - checked ex length: %d", checked_exceptions_length()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1892 if (checked_exceptions_length() > 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1893 CheckedExceptionElement* table = checked_exceptions_start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1894 st->print_cr(" - checked ex start: " INTPTR_FORMAT, table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1895 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1896 for (int i = 0; i < checked_exceptions_length(); i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1897 st->print_cr(" - throws %s", constants()->printable_name_at(table[i].class_cp_index)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1898 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1899 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1900 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1901 if (has_linenumber_table()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1902 u_char* table = compressed_linenumber_table(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1903 st->print_cr(" - linenumber start: " INTPTR_FORMAT, table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1904 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1905 CompressedLineNumberReadStream stream(table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1906 while (stream.read_pair()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1907 st->print_cr(" - line %d: %d", stream.line(), stream.bci()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1908 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1909 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1910 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1911 st->print_cr(" - localvar length: %d", localvariable_table_length()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1912 if (localvariable_table_length() > 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1913 LocalVariableTableElement* table = localvariable_table_start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1914 st->print_cr(" - localvar start: " INTPTR_FORMAT, table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1915 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1916 for (int i = 0; i < localvariable_table_length(); i++) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1917 int bci = table[i].start_bci; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1918 int len = table[i].length; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1919 const char* name = constants()->printable_name_at(table[i].name_cp_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1920 const char* desc = constants()->printable_name_at(table[i].descriptor_cp_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1921 int slot = table[i].slot; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1922 st->print_cr(" - %s %s bci=%d len=%d slot=%d", desc, name, bci, len, slot); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1923 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1924 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1925 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1926 if (code() != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1927 st->print (" - compiled code: "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1928 code()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1929 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1930 if (is_native()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1931 st->print_cr(" - native function: " INTPTR_FORMAT, native_function()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1932 st->print_cr(" - signature handler: " INTPTR_FORMAT, signature_handler()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1933 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1934 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1935 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1936 #endif //PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1937 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1938 void Method::print_value_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1939 assert(is_method(), "must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1940 st->print_cr(internal_name()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1941 print_address_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1942 st->print(" "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1943 name()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1944 st->print(" "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1945 signature()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1946 st->print(" in "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1947 method_holder()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1948 if (WizardMode) st->print("[%d,%d]", size_of_parameters(), max_locals()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1949 if (WizardMode && code() != NULL) st->print(" ((nmethod*)%p)", code()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1950 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1951 |
| 7956 | 1952 #if INCLUDE_SERVICES |
| 1953 // Size Statistics | |
| 1954 void Method::collect_statistics(KlassSizeStats *sz) const { | |
| 1955 int mysize = sz->count(this); | |
| 1956 sz->_method_bytes += mysize; | |
| 1957 sz->_method_all_bytes += mysize; | |
| 1958 sz->_rw_bytes += mysize; | |
| 1959 | |
| 1960 if (constMethod()) { | |
| 1961 constMethod()->collect_statistics(sz); | |
| 1962 } | |
| 1963 if (method_data()) { | |
| 1964 method_data()->collect_statistics(sz); | |
| 1965 } | |
| 1966 } | |
| 1967 #endif // INCLUDE_SERVICES | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1968 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1969 // Verification |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1970 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1971 void Method::verify_on(outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1972 guarantee(is_method(), "object must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1973 guarantee(is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1974 guarantee(constants()->is_constantPool(), "should be constant pool"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1975 guarantee(constants()->is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1976 guarantee(constMethod()->is_constMethod(), "should be ConstMethod*"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1977 guarantee(constMethod()->is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1978 MethodData* md = method_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1979 guarantee(md == NULL || |
|
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6983
diff
changeset
|
1980 md->is_metadata(), "should be metadata"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1981 guarantee(md == NULL || |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1982 md->is_methodData(), "should be method data"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1983 } |
|
8611
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1984 |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1985 #ifdef GRAAL |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1986 void Method::reset_counters() { |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1987 invocation_counter()->reset(); |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1988 backedge_counter()->reset(); |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1989 _interpreter_invocation_count = 0; |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1990 _interpreter_throwout_count = 0; |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1991 #ifndef PRODUCT |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1992 _compiled_invocation_count = 0; |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1993 #endif |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1994 } |
|
6c4db417385a
added API to reset the profiling information for a method
Christian Haeubl <haeubl@ssw.jku.at>
parents:
8151
diff
changeset
|
1995 #endif |