Mercurial > hg > truffle
annotate src/share/vm/oops/method.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | 9191895df19d |
| children | d8ce2825b193 c3e799c37717 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "code/debugInfoRec.hpp" | |
| 28 #include "gc_interface/collectedHeap.inline.hpp" | |
| 29 #include "interpreter/bytecodeStream.hpp" | |
| 30 #include "interpreter/bytecodeTracer.hpp" | |
| 31 #include "interpreter/bytecodes.hpp" | |
| 32 #include "interpreter/interpreter.hpp" | |
| 33 #include "interpreter/oopMapCache.hpp" | |
| 34 #include "memory/gcLocker.hpp" | |
| 35 #include "memory/generation.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
36 #include "memory/metadataFactory.hpp" |
| 1972 | 37 #include "memory/oopFactory.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
38 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
39 #include "oops/method.hpp" |
| 1972 | 40 #include "oops/oop.inline.hpp" |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
41 #include "oops/symbol.hpp" |
| 1972 | 42 #include "prims/jvmtiExport.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
43 #include "prims/jvmtiRedefineClasses.hpp" |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
44 #include "prims/methodHandles.hpp" |
| 1972 | 45 #include "prims/nativeLookup.hpp" |
| 46 #include "runtime/arguments.hpp" | |
| 47 #include "runtime/compilationPolicy.hpp" | |
| 48 #include "runtime/frame.inline.hpp" | |
| 49 #include "runtime/handles.inline.hpp" | |
| 50 #include "runtime/relocator.hpp" | |
| 51 #include "runtime/sharedRuntime.hpp" | |
| 52 #include "runtime/signature.hpp" | |
| 3779 | 53 #include "utilities/quickSort.hpp" |
| 1972 | 54 #include "utilities/xmlstream.hpp" |
| 0 | 55 |
| 56 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
57 // Implementation of Method |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
58 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
59 Method* Method::allocate(ClassLoaderData* loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
60 int byte_code_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
61 AccessFlags access_flags, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
62 int compressed_line_number_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
63 int localvariable_table_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
64 int exception_table_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
65 int checked_exceptions_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
66 TRAPS) { |
|
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, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
70 byte_code_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
71 compressed_line_number_size, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
72 localvariable_table_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
73 exception_table_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
74 checked_exceptions_length, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
75 CHECK_NULL); |
|
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 int size = Method::size(access_flags.is_native()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
78 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
79 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
|
80 } |
| 0 | 81 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
82 Method::Method(ConstMethod* xconst, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
83 AccessFlags access_flags, int size) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
84 No_Safepoint_Verifier no_safepoint; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
85 set_constMethod(xconst); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
86 set_access_flags(access_flags); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
87 set_method_size(size); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
88 set_name_index(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
89 set_signature_index(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
90 #ifdef CC_INTERP |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
91 set_result_index(T_VOID); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
92 #endif |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
93 set_constants(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
94 set_max_stack(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
95 set_max_locals(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
96 set_intrinsic_id(vmIntrinsics::_none); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
97 set_jfr_towrite(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
98 set_method_data(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
99 set_interpreter_throwout_count(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
100 set_vtable_index(Method::garbage_vtable_index); |
|
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 // Fix and bury in Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
103 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
|
104 set_adapter_entry(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
105 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
|
106 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
107 if (access_flags.is_native()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
108 clear_native_function(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
109 set_signature_handler(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
110 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
111 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
112 NOT_PRODUCT(set_compiled_invocation_count(0);) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
113 set_interpreter_invocation_count(0); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
114 invocation_counter()->init(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
115 backedge_counter()->init(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
116 clear_number_of_breakpoints(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
117 |
|
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 { |
| 0 | 152 return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature()); |
| 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 { |
| 0 | 156 return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature(), buf, size); |
| 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 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
190 int Method::fast_exception_handler_bci_for(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 | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
193 ExceptionTable table(this); |
|
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 |
| 196 constantPoolHandle pool(THREAD, 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 |
|
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
199 ExceptionTable table(this); |
|
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; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
243 InstanceKlass::cast(method_holder())->mask_for(h_this, bci, &local_mask); |
| 0 | 244 local_mask.print(); |
| 245 } | |
| 246 } | |
| 247 #endif | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
248 InstanceKlass::cast(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 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
312 void Method::set_interpreter_kind() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
313 int kind = Interpreter::method_kind(this); |
| 0 | 314 assert(kind != Interpreter::invalid, |
| 315 "interpreter entry must be valid"); | |
| 316 set_interpreter_kind(kind); | |
| 317 } | |
| 318 | |
| 319 | |
| 320 // Attempt to return method oop to original state. Clear any pointers | |
| 321 // (to objects outside the shared spaces). We won't be able to predict | |
| 322 // where they should point in a new JVM. Further initialize some | |
| 323 // entries now in order allow them to be write protected later. | |
| 324 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
325 void Method::remove_unshareable_info() { |
| 0 | 326 unlink_method(); |
| 327 set_interpreter_kind(); | |
| 328 } | |
| 329 | |
| 330 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
331 bool Method::was_executed_more_than(int n) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
332 // Invocation counter is reset when the Method* is compiled. |
| 0 | 333 // If the method has compiled code we therefore assume it has |
| 334 // be excuted more than n times. | |
| 335 if (is_accessor() || is_empty_method() || (code() != NULL)) { | |
| 336 // interpreter doesn't bump invocation counter of trivial methods | |
| 337 // compiler does not bump invocation counter of compiled methods | |
| 338 return true; | |
| 1783 | 339 } |
| 340 else if (_invocation_counter.carry() || (method_data() != NULL && method_data()->invocation_counter()->carry())) { | |
| 0 | 341 // The carry bit is set when the counter overflows and causes |
| 342 // a compilation to occur. We don't know how many times | |
| 343 // the counter has been reset, so we simply assume it has | |
| 344 // been executed more than n times. | |
| 345 return true; | |
| 346 } else { | |
| 347 return invocation_count() > n; | |
| 348 } | |
| 349 } | |
| 350 | |
| 351 #ifndef PRODUCT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
352 void Method::print_invocation_count() { |
| 0 | 353 if (is_static()) tty->print("static "); |
| 354 if (is_final()) tty->print("final "); | |
| 355 if (is_synchronized()) tty->print("synchronized "); | |
| 356 if (is_native()) tty->print("native "); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
357 method_holder()->name()->print_symbol_on(tty); |
| 0 | 358 tty->print("."); |
| 359 name()->print_symbol_on(tty); | |
| 360 signature()->print_symbol_on(tty); | |
| 361 | |
| 362 if (WizardMode) { | |
| 363 // dump the size of the byte codes | |
| 364 tty->print(" {%d}", code_size()); | |
| 365 } | |
| 366 tty->cr(); | |
| 367 | |
| 368 tty->print_cr (" interpreter_invocation_count: %8d ", interpreter_invocation_count()); | |
| 369 tty->print_cr (" invocation_counter: %8d ", invocation_count()); | |
| 370 tty->print_cr (" backedge_counter: %8d ", backedge_count()); | |
| 371 if (CountCompiledCalls) { | |
| 372 tty->print_cr (" compiled_invocation_count: %8d ", compiled_invocation_count()); | |
| 373 } | |
| 374 | |
| 375 } | |
| 376 #endif | |
| 377 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
378 // Build a MethodData* object to hold information about this method |
| 0 | 379 // collected in the interpreter. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
380 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
|
381 // 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
|
382 // which avoids deadlock for acquiring the MethodData_lock. |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
383 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
|
384 return; |
|
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
385 } |
|
7cf1a74771e8
6988439: Parallel Class Loading test deadlock involving MethodData_lock and Pending List Lock
coleenp
parents:
1972
diff
changeset
|
386 |
| 0 | 387 // Grab a lock here to prevent multiple |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
388 // MethodData*s from being created. |
| 0 | 389 MutexLocker ml(MethodData_lock, THREAD); |
| 390 if (method->method_data() == NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
391 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
|
392 MethodData* method_data = MethodData::allocate(loader_data, method, CHECK); |
| 0 | 393 method->set_method_data(method_data); |
| 394 if (PrintMethodData && (Verbose || WizardMode)) { | |
| 395 ResourceMark rm(THREAD); | |
| 396 tty->print("build_interpreter_method_data for "); | |
| 397 method->print_name(tty); | |
| 398 tty->cr(); | |
| 399 // At the end of the run, the MDO, full of data, will be dumped. | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
404 void Method::cleanup_inline_caches() { |
| 0 | 405 // The current system doesn't use inline caches in the interpreter |
| 406 // => nothing to do (keep this method around for future use) | |
| 407 } | |
| 408 | |
| 409 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
410 int Method::extra_stack_words() { |
| 710 | 411 // not an inline function, to avoid a header dependency on Interpreter |
| 1506 | 412 return extra_stack_entries() * Interpreter::stackElementSize; |
| 710 | 413 } |
| 414 | |
| 415 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
416 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
|
417 ArgumentSizeComputer asc(signature()); |
| 0 | 418 set_size_of_parameters(asc.size() + (is_static() ? 0 : 1)); |
| 419 } | |
| 420 | |
| 421 #ifdef CC_INTERP | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
422 void Method::set_result_index(BasicType type) { |
| 0 | 423 _result_index = Interpreter::BasicType_as_index(type); |
| 424 } | |
| 425 #endif | |
| 426 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
427 BasicType Method::result_type() const { |
| 0 | 428 ResultTypeFinder rtf(signature()); |
| 429 return rtf.type(); | |
| 430 } | |
| 431 | |
| 432 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
433 bool Method::is_empty_method() const { |
| 0 | 434 return code_size() == 1 |
| 435 && *code_base() == Bytecodes::_return; | |
| 436 } | |
| 437 | |
| 438 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
439 bool Method::is_vanilla_constructor() const { |
| 0 | 440 // Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method |
| 441 // which only calls the superclass vanilla constructor and possibly does stores of | |
| 442 // zero constants to local fields: | |
| 443 // | |
| 444 // aload_0 | |
| 445 // invokespecial | |
| 446 // indexbyte1 | |
| 447 // indexbyte2 | |
| 448 // | |
| 449 // followed by an (optional) sequence of: | |
| 450 // | |
| 451 // aload_0 | |
| 452 // aconst_null / iconst_0 / fconst_0 / dconst_0 | |
| 453 // putfield | |
| 454 // indexbyte1 | |
| 455 // indexbyte2 | |
| 456 // | |
| 457 // followed by: | |
| 458 // | |
| 459 // return | |
| 460 | |
| 461 assert(name() == vmSymbols::object_initializer_name(), "Should only be called for default constructors"); | |
| 462 assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors"); | |
| 463 int size = code_size(); | |
| 464 // Check if size match | |
| 465 if (size == 0 || size % 5 != 0) return false; | |
| 466 address cb = code_base(); | |
| 467 int last = size - 1; | |
| 468 if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) { | |
| 469 // Does not call superclass default constructor | |
| 470 return false; | |
| 471 } | |
| 472 // Check optional sequence | |
| 473 for (int i = 4; i < last; i += 5) { | |
| 474 if (cb[i] != Bytecodes::_aload_0) return false; | |
| 475 if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false; | |
| 476 if (cb[i+2] != Bytecodes::_putfield) return false; | |
| 477 } | |
| 478 return true; | |
| 479 } | |
| 480 | |
| 481 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
482 bool Method::compute_has_loops_flag() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
483 BytecodeStream bcs(this); |
| 0 | 484 Bytecodes::Code bc; |
| 485 | |
| 486 while ((bc = bcs.next()) >= 0) { | |
| 487 switch( bc ) { | |
| 488 case Bytecodes::_ifeq: | |
| 489 case Bytecodes::_ifnull: | |
| 490 case Bytecodes::_iflt: | |
| 491 case Bytecodes::_ifle: | |
| 492 case Bytecodes::_ifne: | |
| 493 case Bytecodes::_ifnonnull: | |
| 494 case Bytecodes::_ifgt: | |
| 495 case Bytecodes::_ifge: | |
| 496 case Bytecodes::_if_icmpeq: | |
| 497 case Bytecodes::_if_icmpne: | |
| 498 case Bytecodes::_if_icmplt: | |
| 499 case Bytecodes::_if_icmpgt: | |
| 500 case Bytecodes::_if_icmple: | |
| 501 case Bytecodes::_if_icmpge: | |
| 502 case Bytecodes::_if_acmpeq: | |
| 503 case Bytecodes::_if_acmpne: | |
| 504 case Bytecodes::_goto: | |
| 505 case Bytecodes::_jsr: | |
| 506 if( bcs.dest() < bcs.next_bci() ) _access_flags.set_has_loops(); | |
| 507 break; | |
| 508 | |
| 509 case Bytecodes::_goto_w: | |
| 510 case Bytecodes::_jsr_w: | |
| 511 if( bcs.dest_w() < bcs.next_bci() ) _access_flags.set_has_loops(); | |
| 512 break; | |
| 513 } | |
| 514 } | |
| 515 _access_flags.set_loops_flag_init(); | |
| 516 return _access_flags.has_loops(); | |
| 517 } | |
| 518 | |
| 519 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
520 bool Method::is_final_method() const { |
| 0 | 521 // %%% Should return true for private methods also, |
| 522 // since there is no way to override them. | |
| 523 return is_final() || Klass::cast(method_holder())->is_final(); | |
| 524 } | |
| 525 | |
| 526 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
527 bool Method::is_strict_method() const { |
| 0 | 528 return is_strict(); |
| 529 } | |
| 530 | |
| 531 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
532 bool Method::can_be_statically_bound() const { |
| 0 | 533 if (is_final_method()) return true; |
| 534 return vtable_index() == nonvirtual_vtable_index; | |
| 535 } | |
| 536 | |
| 537 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
538 bool Method::is_accessor() const { |
| 0 | 539 if (code_size() != 5) return false; |
| 540 if (size_of_parameters() != 1) return false; | |
| 2142 | 541 if (java_code_at(0) != Bytecodes::_aload_0 ) return false; |
| 542 if (java_code_at(1) != Bytecodes::_getfield) return false; | |
| 543 if (java_code_at(4) != Bytecodes::_areturn && | |
| 544 java_code_at(4) != Bytecodes::_ireturn ) return false; | |
| 0 | 545 return true; |
| 546 } | |
| 547 | |
| 548 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
549 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
|
550 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
|
551 } |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
552 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
553 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
|
554 return (is_static() || |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
555 InstanceKlass::cast(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
|
556 } |
|
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2264
diff
changeset
|
557 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
558 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
|
559 // 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
|
560 // 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
|
561 // 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
|
562 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
|
563 has_valid_initializer_flags(); |
| 0 | 564 } |
| 565 | |
| 566 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
567 objArrayHandle Method::resolved_checked_exceptions_impl(Method* this_oop, TRAPS) { |
| 0 | 568 int length = this_oop->checked_exceptions_length(); |
| 569 if (length == 0) { // common case | |
| 570 return objArrayHandle(THREAD, Universe::the_empty_class_klass_array()); | |
| 571 } else { | |
| 572 methodHandle h_this(THREAD, this_oop); | |
| 1142 | 573 objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::Class_klass(), length, CHECK_(objArrayHandle())); |
| 0 | 574 objArrayHandle mirrors (THREAD, m_oop); |
| 575 for (int i = 0; i < length; i++) { | |
| 576 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
|
577 Klass* k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle())); |
| 1142 | 578 assert(Klass::cast(k)->is_subclass_of(SystemDictionary::Throwable_klass()), "invalid exception class"); |
| 0 | 579 mirrors->obj_at_put(i, Klass::cast(k)->java_mirror()); |
| 580 } | |
| 581 return mirrors; | |
| 582 } | |
| 583 }; | |
| 584 | |
| 585 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
586 int Method::line_number_from_bci(int bci) const { |
| 0 | 587 if (bci == SynchronizationEntryBCI) bci = 0; |
| 588 assert(bci == 0 || 0 <= bci && bci < code_size(), "illegal bci"); | |
| 589 int best_bci = 0; | |
| 590 int best_line = -1; | |
| 591 | |
| 592 if (has_linenumber_table()) { | |
| 593 // The line numbers are a short array of 2-tuples [start_pc, line_number]. | |
| 594 // Not necessarily sorted and not necessarily one-to-one. | |
| 595 CompressedLineNumberReadStream stream(compressed_linenumber_table()); | |
| 596 while (stream.read_pair()) { | |
| 597 if (stream.bci() == bci) { | |
| 598 // perfect match | |
| 599 return stream.line(); | |
| 600 } else { | |
| 601 // update best_bci/line | |
| 602 if (stream.bci() < bci && stream.bci() >= best_bci) { | |
| 603 best_bci = stream.bci(); | |
| 604 best_line = stream.line(); | |
| 605 } | |
| 606 } | |
| 607 } | |
| 608 } | |
| 609 return best_line; | |
| 610 } | |
| 611 | |
| 612 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
613 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
|
614 if( constants()->tag_at(klass_index).is_unresolved_klass() ) { |
| 0 | 615 Thread *thread = Thread::current(); |
|
6123
2fe087c3e814
7172967: Eliminate constMethod's _method backpointer to methodOop.
jiangli
parents:
4873
diff
changeset
|
616 Symbol* klass_name = constants()->klass_name_at(klass_index); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
617 Handle loader(thread, InstanceKlass::cast(method_holder())->class_loader()); |
| 0 | 618 Handle prot (thread, Klass::cast(method_holder())->protection_domain()); |
| 619 return SystemDictionary::find(klass_name, loader, prot, thread) != NULL; | |
| 620 } else { | |
| 621 return true; | |
| 622 } | |
| 623 } | |
| 624 | |
| 625 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
626 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
|
627 int klass_index = constants()->klass_ref_index_at(refinfo_index); |
| 0 | 628 if (must_be_resolved) { |
| 629 // Make sure klass is resolved in constantpool. | |
| 630 if (constants()->tag_at(klass_index).is_unresolved_klass()) return false; | |
| 631 } | |
| 632 return is_klass_loaded_by_klass_index(klass_index); | |
| 633 } | |
| 634 | |
| 635 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
636 void Method::set_native_function(address function, bool post_event_flag) { |
| 0 | 637 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
|
638 assert(!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), ""); |
| 0 | 639 address* native_function = native_function_addr(); |
| 640 | |
| 641 // We can see racers trying to place the same native function into place. Once | |
| 642 // is plenty. | |
| 643 address current = *native_function; | |
| 644 if (current == function) return; | |
| 645 if (post_event_flag && JvmtiExport::should_post_native_method_bind() && | |
| 646 function != NULL) { | |
| 647 // native_method_throw_unsatisfied_link_error_entry() should only | |
| 648 // be passed when post_event_flag is false. | |
| 649 assert(function != | |
| 650 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 651 "post_event_flag mis-match"); | |
| 652 | |
| 653 // post the bind event, and possible change the bind function | |
| 654 JvmtiExport::post_native_method_bind(this, &function); | |
| 655 } | |
| 656 *native_function = function; | |
| 657 // This function can be called more than once. We must make sure that we always | |
| 658 // use the latest registered method -> check if a stub already has been generated. | |
| 659 // If so, we have to make it not_entrant. | |
| 660 nmethod* nm = code(); // Put it into local variable to guard against concurrent updates | |
| 661 if (nm != NULL) { | |
| 662 nm->make_not_entrant(); | |
| 663 } | |
| 664 } | |
| 665 | |
| 666 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
667 bool Method::has_native_function() const { |
|
6267
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
668 if (is_method_handle_intrinsic()) |
|
977007096840
7187290: nightly failures after JSR 292 lazy method handle update
twisti
parents:
6266
diff
changeset
|
669 return false; // special-cased in SharedRuntime::generate_native_wrapper |
| 0 | 670 address func = native_function(); |
| 671 return (func != NULL && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry()); | |
| 672 } | |
| 673 | |
| 674 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
675 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
|
676 // Note: is_method_handle_intrinsic() is allowed here. |
| 0 | 677 set_native_function( |
| 678 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 679 !native_bind_event_is_interesting); | |
| 680 clear_code(); | |
| 681 } | |
| 682 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
683 address Method::critical_native_function() { |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
684 methodHandle mh(this); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
685 return NativeLookup::lookup_critical_entry(mh); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
686 } |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3929
diff
changeset
|
687 |
| 0 | 688 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
689 void Method::set_signature_handler(address handler) { |
| 0 | 690 address* signature_handler = signature_handler_addr(); |
| 691 *signature_handler = handler; | |
| 692 } | |
| 693 | |
| 694 | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
695 void Method::print_made_not_compilable(int comp_level, bool is_osr, bool report) { |
|
1208
cef333a48af6
6923043: failed nightly tests which use -XX:+PrintCompilation -Xcomp -XX:CompileOnly
kvn
parents:
1206
diff
changeset
|
696 if (PrintCompilation && report) { |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
697 ttyLocker ttyl; |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
698 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
|
699 if (comp_level == CompLevel_all) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
700 tty->print("all levels "); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
701 } else { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
702 tty->print("levels "); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
703 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
|
704 tty->print("%d ", i); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
705 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
706 } |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
707 this->print_short_name(tty); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
708 int size = this->code_size(); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
709 if (size > 0) |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
710 tty->print(" (%d bytes)", size); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
711 tty->cr(); |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1202
diff
changeset
|
712 } |
| 0 | 713 if ((TraceDeoptimization || LogCompilation) && (xtty != NULL)) { |
| 714 ttyLocker ttyl; | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
715 xtty->begin_elem("make_not_%scompilable thread='%d'", is_osr ? "osr_" : "", (int) os::current_thread_id()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
716 xtty->method(this); |
| 0 | 717 xtty->stamp(); |
| 718 xtty->end_elem(); | |
| 719 } | |
|
6800
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 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
722 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
|
723 if (number_of_breakpoints() > 0) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
724 return true; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
725 if (is_method_handle_intrinsic()) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
726 return !is_synthetic(); // the generated adapters must be compiled |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
727 if (comp_level == CompLevel_any) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
728 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
|
729 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
730 return is_not_c1_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
731 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
732 return is_not_c2_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
733 return false; |
|
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 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
736 // call this when compiler finds that this method is not compilable |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
737 void Method::set_not_compilable(int comp_level, bool report) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
738 print_made_not_compilable(comp_level, /*is_osr*/ false, report); |
| 1783 | 739 if (comp_level == CompLevel_all) { |
| 740 set_not_c1_compilable(); | |
| 741 set_not_c2_compilable(); | |
| 742 } else { | |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
743 if (is_c1_compile(comp_level)) |
| 1783 | 744 set_not_c1_compilable(); |
|
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
745 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
746 set_not_c2_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
747 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
748 CompilationPolicy::policy()->disable_compilation(this); |
|
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 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
751 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
|
752 if (is_not_compilable(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
753 return true; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
754 if (comp_level == CompLevel_any) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
755 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
|
756 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
757 return is_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
758 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
759 return is_not_c2_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
760 return false; |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
761 } |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
762 |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
763 void Method::set_not_osr_compilable(int comp_level, bool report) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
764 print_made_not_compilable(comp_level, /*is_osr*/ true, report); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
765 if (comp_level == CompLevel_all) { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
766 set_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
767 set_not_c2_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
768 } else { |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
769 if (is_c1_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
770 set_not_c1_osr_compilable(); |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
771 if (is_c2_compile(comp_level)) |
|
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6791
diff
changeset
|
772 set_not_c2_osr_compilable(); |
| 0 | 773 } |
| 1783 | 774 CompilationPolicy::policy()->disable_compilation(this); |
| 0 | 775 } |
| 776 | |
| 777 // 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
|
778 void Method::clear_code() { |
| 0 | 779 |
| 780 // this may be NULL if c2i adapters have not been made yet | |
| 781 // Only should happen at allocate time. | |
| 782 if (_adapter == NULL) { | |
| 783 _from_compiled_entry = NULL; | |
| 784 } else { | |
| 785 _from_compiled_entry = _adapter->get_c2i_entry(); | |
| 786 } | |
| 787 OrderAccess::storestore(); | |
| 788 _from_interpreted_entry = _i2i_entry; | |
| 789 OrderAccess::storestore(); | |
| 790 _code = NULL; | |
| 791 } | |
| 792 | |
| 793 // 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
|
794 void Method::unlink_method() { |
| 0 | 795 _code = NULL; |
| 796 _i2i_entry = NULL; | |
| 797 _from_interpreted_entry = NULL; | |
| 798 if (is_native()) { | |
| 799 *native_function_addr() = NULL; | |
| 800 set_signature_handler(NULL); | |
| 801 } | |
| 802 NOT_PRODUCT(set_compiled_invocation_count(0);) | |
| 803 invocation_counter()->reset(); | |
| 804 backedge_counter()->reset(); | |
| 805 _adapter = NULL; | |
| 806 _from_compiled_entry = NULL; | |
| 807 assert(_method_data == NULL, "unexpected method data?"); | |
| 808 set_method_data(NULL); | |
| 809 set_interpreter_throwout_count(0); | |
| 810 set_interpreter_invocation_count(0); | |
| 811 } | |
| 812 | |
| 813 // Called when the method_holder is getting linked. Setup entrypoints so the method | |
| 814 // 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
|
815 void Method::link_method(methodHandle h_method, TRAPS) { |
| 3748 | 816 // If the code cache is full, we may reenter this function for the |
| 817 // leftover methods that weren't linked. | |
| 818 if (_i2i_entry != NULL) return; | |
| 819 | |
| 0 | 820 assert(_adapter == NULL, "init'd to NULL" ); |
| 821 assert( _code == NULL, "nothing compiled yet" ); | |
| 822 | |
| 823 // Setup interpreter entrypoint | |
| 824 assert(this == h_method(), "wrong h_method()" ); | |
| 825 address entry = Interpreter::entry_for_method(h_method); | |
| 826 assert(entry != NULL, "interpreter entry must be non-null"); | |
| 827 // Sets both _i2i_entry and _from_interpreted_entry | |
| 828 set_interpreter_entry(entry); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
829 if (is_native() && !is_method_handle_intrinsic()) { |
| 0 | 830 set_native_function( |
| 831 SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), | |
| 832 !native_bind_event_is_interesting); | |
| 833 } | |
| 834 | |
| 835 // Setup compiler entrypoint. This is made eagerly, so we do not need | |
| 836 // special handling of vtables. An alternative is to make adapters more | |
| 837 // lazily by calling make_adapter() from from_compiled_entry() for the | |
| 838 // normal calls. For vtable calls life gets more complicated. When a | |
| 839 // call-site goes mega-morphic we need adapters in all methods which can be | |
| 840 // called from the vtable. We need adapters on such methods that get loaded | |
| 841 // later. Ditto for mega-morphic itable calls. If this proves to be a | |
| 842 // problem we'll make these lazily later. | |
|
3749
9dd6c4ba364f
7049928: VM crashes with "assert(_adapter != NULL) failed: must have" at methodOop.cpp:63
coleenp
parents:
3748
diff
changeset
|
843 (void) make_adapters(h_method, CHECK); |
| 0 | 844 |
| 845 // ONLY USE the h_method now as make_adapter may have blocked | |
| 846 | |
| 847 } | |
| 848 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
849 address Method::make_adapters(methodHandle mh, TRAPS) { |
| 0 | 850 // Adapters for compiled code are made eagerly here. They are fairly |
| 851 // small (generally < 100 bytes) and quick to make (and cached and shared) | |
| 852 // so making them eagerly shouldn't be too expensive. | |
| 853 AdapterHandlerEntry* adapter = AdapterHandlerLibrary::get_adapter(mh); | |
| 854 if (adapter == NULL ) { | |
|
1187
cf0685d550f1
6911204: generated adapters with large signatures can fill up the code cache
never
parents:
1152
diff
changeset
|
855 THROW_MSG_NULL(vmSymbols::java_lang_VirtualMachineError(), "out of space in CodeCache for adapters"); |
| 0 | 856 } |
| 857 | |
| 858 mh->set_adapter_entry(adapter); | |
| 859 mh->_from_compiled_entry = adapter->get_c2i_entry(); | |
| 860 return adapter->get_c2i_entry(); | |
| 861 } | |
| 862 | |
| 863 // The verified_code_entry() must be called when a invoke is resolved | |
| 864 // on this method. | |
| 865 | |
| 866 // It returns the compiled code entry point, after asserting not null. | |
| 867 // This function is called after potential safepoints so that nmethod | |
| 868 // or adapter that it points to is still live and valid. | |
| 869 // This function must not hit a safepoint! | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
870 address Method::verified_code_entry() { |
| 0 | 871 debug_only(No_Safepoint_Verifier nsv;) |
| 1202 | 872 nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code); |
| 873 if (code == NULL && UseCodeCacheFlushing) { | |
| 874 nmethod *saved_code = CodeCache::find_and_remove_saved_code(this); | |
| 875 if (saved_code != NULL) { | |
| 876 methodHandle method(this); | |
| 877 assert( ! saved_code->is_osr_method(), "should not get here for osr" ); | |
| 878 set_code( method, saved_code ); | |
| 879 } | |
| 880 } | |
| 881 | |
| 0 | 882 assert(_from_compiled_entry != NULL, "must be set"); |
| 883 return _from_compiled_entry; | |
| 884 } | |
| 885 | |
| 886 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all | |
| 887 // (could be racing a deopt). | |
| 888 // Not inline to avoid circular ref. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
889 bool Method::check_code() const { |
| 0 | 890 // cached in a register or local. There's a race on the value of the field. |
| 891 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
|
892 return code == NULL || (code->method() == NULL) || (code->method() == (Method*)this && !code->is_osr_method()); |
| 0 | 893 } |
| 894 | |
| 895 // Install compiled code. Instantly it can execute. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
896 void Method::set_code(methodHandle mh, nmethod *code) { |
| 0 | 897 assert( code, "use clear_code to remove code" ); |
| 898 assert( mh->check_code(), "" ); | |
| 899 | |
| 900 guarantee(mh->adapter() != NULL, "Adapter blob must already exist!"); | |
| 901 | |
| 902 // These writes must happen in this order, because the interpreter will | |
| 903 // directly jump to from_interpreted_entry which jumps to an i2c adapter | |
| 904 // which jumps to _from_compiled_entry. | |
| 905 mh->_code = code; // Assign before allowing compiled code to exec | |
| 906 | |
| 907 int comp_level = code->comp_level(); | |
| 908 // In theory there could be a race here. In practice it is unlikely | |
| 909 // and not worth worrying about. | |
| 1783 | 910 if (comp_level > mh->highest_comp_level()) { |
| 911 mh->set_highest_comp_level(comp_level); | |
| 0 | 912 } |
| 913 | |
| 914 OrderAccess::storestore(); | |
| 1692 | 915 #ifdef SHARK |
|
1845
a222fcfba398
6990549: Zero and Shark fixes after 6978355 and 6953144
twisti
parents:
1793
diff
changeset
|
916 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
|
917 #else //!SHARK |
| 0 | 918 mh->_from_compiled_entry = code->verified_entry_point(); |
| 919 OrderAccess::storestore(); | |
| 920 // 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
|
921 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
|
922 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
|
923 #endif //!SHARK |
| 0 | 924 } |
| 925 | |
| 926 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
927 bool Method::is_overridden_in(Klass* k) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
928 InstanceKlass* ik = InstanceKlass::cast(k); |
| 0 | 929 |
| 930 if (ik->is_interface()) return false; | |
| 931 | |
| 932 // If method is an interface, we skip it - except if it | |
| 933 // is a miranda method | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
934 if (InstanceKlass::cast(method_holder())->is_interface()) { |
| 0 | 935 // Check that method is not a miranda method |
| 936 if (ik->lookup_method(name(), signature()) == NULL) { | |
| 937 // No implementation exist - so miranda method | |
| 938 return false; | |
| 939 } | |
| 940 return true; | |
| 941 } | |
| 942 | |
| 943 assert(ik->is_subclass_of(method_holder()), "should be subklass"); | |
| 944 assert(ik->vtable() != NULL, "vtable should exist"); | |
| 945 if (vtable_index() == nonvirtual_vtable_index) { | |
| 946 return false; | |
| 947 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
948 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
|
949 return vt_m != this; |
| 0 | 950 } |
| 951 } | |
| 952 | |
| 953 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
954 // 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
|
955 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
|
956 if (is_old()) { |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
957 // 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
|
958 // 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
|
959 // 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
|
960 // finishes executing. |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
961 return true; |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
962 } |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
963 |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
964 // 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
|
965 return false; |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
966 } |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
967 |
| 710 | 968 // Constant pool structure for invoke methods: |
| 969 enum { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
970 _imcp_invoke_name = 1, // utf8: 'invokeExact', etc. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
971 _imcp_invoke_signature, // utf8: (variable Symbol*) |
| 710 | 972 _imcp_limit |
| 973 }; | |
| 974 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
975 // 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
|
976 // Cf. java/lang/invoke/InvokerBytecodeGenerator |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
977 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
|
978 return intrinsic_id() == vmIntrinsics::_compiledLambdaForm; |
| 710 | 979 } |
| 980 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
981 // 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
|
982 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
|
983 vmIntrinsics::ID iid = intrinsic_id(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
984 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
|
985 MethodHandles::is_signature_polymorphic_intrinsic(iid)); |
|
1152
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1142
diff
changeset
|
986 } |
|
cd37471eaecc
6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents:
1142
diff
changeset
|
987 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
988 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
|
989 vmIntrinsics::ID iid = intrinsic_id(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
990 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
|
991 MethodHandles::has_member_arg(iid)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
992 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
993 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
994 // 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
|
995 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
|
996 Symbol* signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
997 TRAPS) { |
|
3891
ac8738449b6f
7082949: JSR 292: missing ResourceMark in methodOopDesc::make_invoke_method
never
parents:
3795
diff
changeset
|
998 ResourceMark rm; |
| 710 | 999 methodHandle empty; |
| 1000 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1001 KlassHandle holder = SystemDictionary::MethodHandle_klass(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1002 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
|
1003 assert(iid == MethodHandles::signature_polymorphic_name_id(name), ""); |
| 710 | 1004 if (TraceMethodHandles) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1005 tty->print_cr("make_method_handle_intrinsic MH.%s%s", name->as_C_string(), signature->as_C_string()); |
| 710 | 1006 } |
| 1007 | |
|
2478
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1008 // 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
|
1009 name->increment_refcount(); |
|
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1010 signature->increment_refcount(); |
|
328926869b15
6987991: JSR 292 phpreboot test/testtracefun2.phpr segfaults
jrose
parents:
2460
diff
changeset
|
1011 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1012 int cp_length = _imcp_limit; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1013 ClassLoaderData* loader_data = holder->class_loader_data(); |
| 710 | 1014 constantPoolHandle cp; |
| 1015 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1016 ConstantPool* cp_oop = ConstantPool::allocate(loader_data, cp_length, CHECK_(empty)); |
| 710 | 1017 cp = constantPoolHandle(THREAD, cp_oop); |
| 1018 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1019 cp->set_pool_holder(holder()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1020 cp->symbol_at_put(_imcp_invoke_name, name); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1021 cp->symbol_at_put(_imcp_invoke_signature, signature); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1022 cp->set_preresolution(); |
| 710 | 1023 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1024 // 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
|
1025 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
|
1026 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
|
1027 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
|
1028 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
|
1029 |
| 710 | 1030 methodHandle m; |
| 1031 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1032 Method* m_oop = Method::allocate(loader_data, 0, accessFlags_from(flags_bits), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1033 0, 0, 0, 0, CHECK_(empty)); |
| 710 | 1034 m = methodHandle(THREAD, m_oop); |
| 1035 } | |
| 1036 m->set_constants(cp()); | |
| 1037 m->set_name_index(_imcp_invoke_name); | |
| 1038 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
|
1039 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
|
1040 assert(m->signature() == signature, ""); |
| 710 | 1041 #ifdef CC_INTERP |
|
2256
173926398291
7018673: Zero: 6953144, 6990754 and 7009756 made some changes which broke Zero
twisti
parents:
2177
diff
changeset
|
1042 ResultTypeFinder rtf(signature); |
| 710 | 1043 m->set_result_index(rtf.type()); |
| 1044 #endif | |
| 1045 m->compute_size_of_parameters(THREAD); | |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1783
diff
changeset
|
1046 m->init_intrinsic_id(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1047 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
|
1048 #ifdef ASSERT |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1049 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
|
1050 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
|
1051 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
|
1052 #endif //ASSERT |
| 710 | 1053 |
| 1054 // Finally, set up its entry points. | |
| 1055 assert(m->can_be_statically_bound(), ""); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1056 m->set_vtable_index(Method::nonvirtual_vtable_index); |
| 710 | 1057 m->link_method(m, CHECK_(empty)); |
| 1058 | |
|
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
856
diff
changeset
|
1059 if (TraceMethodHandles && (Verbose || WizardMode)) |
| 710 | 1060 m->print_on(tty); |
| 1061 | |
| 1062 return m; | |
| 1063 } | |
| 1064 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1065 Klass* Method::check_non_bcp_klass(Klass* klass) { |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1066 if (klass != NULL && Klass::cast(klass)->class_loader() != NULL) { |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1067 if (Klass::cast(klass)->oop_is_objArray()) |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1068 klass = objArrayKlass::cast(klass)->bottom_klass(); |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1069 return klass; |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1070 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1071 return NULL; |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3749
diff
changeset
|
1072 } |
| 710 | 1073 |
|
48
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
1074 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1075 methodHandle Method::clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length, |
| 0 | 1076 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS) { |
| 1077 // Code below does not work for native methods - they should never get rewritten anyway | |
| 1078 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
|
1079 // Allocate new Method* |
| 0 | 1080 AccessFlags flags = m->access_flags(); |
| 1081 int checked_exceptions_len = m->checked_exceptions_length(); | |
| 1082 int localvariable_len = m->localvariable_table_length(); | |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
1083 int exception_table_len = m->exception_table_length(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1084 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1085 ClassLoaderData* loader_data = m()->method_holder()->class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1086 Method* newm_oop = Method::allocate(loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1087 new_code_length, |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1088 flags, |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1089 new_compressed_linenumber_size, |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1090 localvariable_len, |
|
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
1091 exception_table_len, |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1092 checked_exceptions_len, |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1093 CHECK_(methodHandle())); |
| 0 | 1094 methodHandle newm (THREAD, newm_oop); |
| 1095 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
|
1096 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1097 // 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
|
1098 ConstMethod* newcm = newm->constMethod(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1099 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
|
1100 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1101 memcpy(newm(), m(), sizeof(Method)); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1102 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1103 // Create shallow copy of ConstMethod. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1104 memcpy(newcm, m->constMethod(), sizeof(ConstMethod)); |
|
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
2177
diff
changeset
|
1105 |
| 0 | 1106 // Reset correct method/const method, method size, and parameter info |
| 1107 newm->set_constMethod(newcm); | |
| 1108 newm->constMethod()->set_code_size(new_code_length); | |
| 1109 newm->constMethod()->set_constMethod_size(new_const_method_size); | |
| 1110 newm->set_method_size(new_method_size); | |
| 1111 assert(newm->code_size() == new_code_length, "check"); | |
| 1112 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
|
1113 assert(newm->exception_table_length() == exception_table_len, "check"); |
| 0 | 1114 assert(newm->localvariable_table_length() == localvariable_len, "check"); |
| 1115 // Copy new byte codes | |
| 1116 memcpy(newm->code_base(), new_code, new_code_length); | |
| 1117 // Copy line number table | |
| 1118 if (new_compressed_linenumber_size > 0) { | |
| 1119 memcpy(newm->compressed_linenumber_table(), | |
| 1120 new_compressed_linenumber_table, | |
| 1121 new_compressed_linenumber_size); | |
| 1122 } | |
| 1123 // Copy checked_exceptions | |
| 1124 if (checked_exceptions_len > 0) { | |
| 1125 memcpy(newm->checked_exceptions_start(), | |
| 1126 m->checked_exceptions_start(), | |
| 1127 checked_exceptions_len * sizeof(CheckedExceptionElement)); | |
| 1128 } | |
|
6216
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1129 // Copy exception table |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1130 if (exception_table_len > 0) { |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1131 memcpy(newm->exception_table_start(), |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1132 m->exception_table_start(), |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1133 exception_table_len * sizeof(ExceptionTableElement)); |
|
161ae369407d
7181632: nsk classLoad001_14 failure and CompileTheWorld crash after 7178145.
jiangli
parents:
6213
diff
changeset
|
1134 } |
| 0 | 1135 // Copy local variable number table |
| 1136 if (localvariable_len > 0) { | |
| 1137 memcpy(newm->localvariable_table_start(), | |
| 1138 m->localvariable_table_start(), | |
| 1139 localvariable_len * sizeof(LocalVariableTableElement)); | |
| 1140 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1141 // Copy stackmap table |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1142 if (m->has_stackmap_table()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1143 int code_attribute_length = m->stackmap_data()->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1144 Array<u1>* stackmap_data = |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1145 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
|
1146 memcpy((void*)stackmap_data->adr_at(0), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1147 (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
|
1148 newm->set_stackmap_data(stackmap_data); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1149 } |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
196
diff
changeset
|
1150 |
| 0 | 1151 return newm; |
| 1152 } | |
| 1153 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1154 vmSymbols::SID Method::klass_id_for_intrinsics(Klass* holder) { |
| 0 | 1155 // if loader is not the default loader (i.e., != NULL), we can't know the intrinsics |
| 1156 // because we are not loading from core libraries | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1157 if (InstanceKlass::cast(holder)->class_loader() != NULL) |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1158 return vmSymbols::NO_SID; // regardless of name, no intrinsics here |
| 0 | 1159 |
| 1160 // see if the klass name is well-known: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1161 Symbol* klass_name = InstanceKlass::cast(holder)->name(); |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1162 return vmSymbols::find_sid(klass_name); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1163 } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1164 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1165 void Method::init_intrinsic_id() { |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1166 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
|
1167 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
|
1168 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
|
1169 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
|
1170 |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1171 // the klass name is well-known: |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1172 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
|
1173 assert(klass_id != vmSymbols::NO_SID, "caller responsibility"); |
| 0 | 1174 |
| 1175 // ditto for method and signature: | |
| 1176 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
|
1177 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
|
1178 && name_id == vmSymbols::NO_SID) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1179 return; |
| 0 | 1180 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
|
1181 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
|
1182 && sig_id == vmSymbols::NO_SID) return; |
| 0 | 1183 jshort flags = access_flags().as_short(); |
| 1184 | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1185 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
|
1186 if (id != vmIntrinsics::_none) { |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1187 set_intrinsic_id(id); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1188 return; |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1189 } |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1190 |
| 0 | 1191 // A few slightly irregular cases: |
| 1192 switch (klass_id) { | |
| 1193 case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_StrictMath): | |
| 1194 // Second chance: check in regular Math. | |
| 1195 switch (name_id) { | |
| 1196 case vmSymbols::VM_SYMBOL_ENUM_NAME(min_name): | |
| 1197 case vmSymbols::VM_SYMBOL_ENUM_NAME(max_name): | |
| 1198 case vmSymbols::VM_SYMBOL_ENUM_NAME(sqrt_name): | |
| 1199 // pretend it is the corresponding method in the non-strict class: | |
| 1200 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
|
1201 id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags); |
| 0 | 1202 break; |
| 1203 } | |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1204 break; |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1205 |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1206 // 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
|
1207 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
|
1208 if (!is_native()) break; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1209 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
|
1210 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
|
1211 id = vmIntrinsics::_none; |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1506
diff
changeset
|
1212 break; |
| 0 | 1213 } |
| 1214 | |
|
856
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1215 if (id != vmIntrinsics::_none) { |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1216 // 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
|
1217 set_intrinsic_id(id); |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1218 return; |
|
75596850f863
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
726
diff
changeset
|
1219 } |
| 0 | 1220 } |
| 1221 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1222 // 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
|
1223 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
|
1224 if (THREAD->is_Compiler_thread()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1225 // 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
|
1226 // 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
|
1227 // 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
|
1228 return false; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6216
diff
changeset
|
1229 } |
| 0 | 1230 bool sig_is_loaded = true; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1231 Handle class_loader(THREAD, InstanceKlass::cast(m->method_holder())->class_loader()); |
| 0 | 1232 Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1233 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1234 Symbol* signature = m->signature(); |
| 0 | 1235 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
| 1236 if (ss.is_object()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1237 Symbol* sym = ss.as_symbol(CHECK_(false)); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1238 Symbol* name = sym; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1239 Klass* klass = SystemDictionary::resolve_or_null(name, class_loader, |
| 0 | 1240 protection_domain, THREAD); |
|
104
541929da62d2
6624474: Server compiler generates unexpected LinkageError
rasbold
parents:
48
diff
changeset
|
1241 // We are loading classes eagerly. If a ClassNotFoundException or |
|
541929da62d2
6624474: Server compiler generates unexpected LinkageError
rasbold
parents:
48
diff
changeset
|
1242 // a LinkageError was generated, be sure to ignore it. |
| 0 | 1243 if (HAS_PENDING_EXCEPTION) { |
| 1142 | 1244 if (PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass()) || |
| 1245 PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { | |
| 0 | 1246 CLEAR_PENDING_EXCEPTION; |
| 1247 } else { | |
| 1248 return false; | |
| 1249 } | |
| 1250 } | |
| 1251 if( klass == NULL) { sig_is_loaded = false; } | |
| 1252 } | |
| 1253 } | |
| 1254 return sig_is_loaded; | |
| 1255 } | |
| 1256 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1257 bool Method::has_unloaded_classes_in_signature(methodHandle m, TRAPS) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1258 Handle class_loader(THREAD, InstanceKlass::cast(m->method_holder())->class_loader()); |
| 0 | 1259 Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1260 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1261 Symbol* signature = m->signature(); |
| 0 | 1262 for(SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
| 1263 if (ss.type() == T_OBJECT) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1264 Symbol* name = ss.as_symbol_or_null(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1265 if (name == NULL) return true; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1266 Klass* klass = SystemDictionary::find(name, class_loader, protection_domain, THREAD); |
| 0 | 1267 if (klass == NULL) return true; |
| 1268 } | |
| 1269 } | |
| 1270 return false; | |
| 1271 } | |
| 1272 | |
| 1273 // Exposed so field engineers can debug VM | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1274 void Method::print_short_name(outputStream* st) { |
| 0 | 1275 ResourceMark rm; |
| 1276 #ifdef PRODUCT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1277 st->print(" %s::", method_holder()->external_name()); |
| 0 | 1278 #else |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1279 st->print(" %s::", method_holder()->internal_name()); |
| 0 | 1280 #endif |
| 1281 name()->print_symbol_on(st); | |
| 1282 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
|
1283 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
|
1284 MethodHandles::print_as_basic_type_signature_on(st, signature(), true); |
| 0 | 1285 } |
| 1286 | |
| 1287 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1288 static void reorder_based_on_method_index(Array<Method*>* methods, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1289 Array<AnnotationArray*>* annotations, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1290 GrowableArray<AnnotationArray*>* temp_array) { |
| 0 | 1291 if (annotations == NULL) { |
| 1292 return; | |
| 1293 } | |
| 1294 | |
| 1295 int length = methods->length(); | |
| 1296 int i; | |
| 1297 // Copy to temp array | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
104
diff
changeset
|
1298 temp_array->clear(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
104
diff
changeset
|
1299 for (i = 0; i < length; i++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1300 temp_array->append(annotations->at(i)); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
104
diff
changeset
|
1301 } |
| 0 | 1302 |
| 1303 // Copy back using old method indices | |
| 1304 for (i = 0; i < length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1305 Method* m = methods->at(i); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1306 annotations->at_put(i, temp_array->at(m->method_idnum())); |
| 0 | 1307 } |
| 1308 } | |
| 1309 | |
| 3779 | 1310 // Comparer for sorting an object array containing |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1311 // Method*s. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1312 static int method_comparator(Method* a, Method* b) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1313 return a->name()->fast_compare(b->name()); |
|
3929
f94227b6117b
7090259: Fix hotspot sources to build with old compilers
kvn
parents:
3891
diff
changeset
|
1314 } |
| 0 | 1315 |
| 1316 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1317 void Method::sort_methods(Array<Method*>* methods, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1318 Array<AnnotationArray*>* methods_annotations, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1319 Array<AnnotationArray*>* methods_parameter_annotations, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1320 Array<AnnotationArray*>* methods_default_annotations, |
| 0 | 1321 bool idempotent) { |
| 1322 int length = methods->length(); | |
| 1323 if (length > 1) { | |
| 1324 bool do_annotations = false; | |
| 1325 if (methods_annotations != NULL || | |
| 1326 methods_parameter_annotations != NULL || | |
| 1327 methods_default_annotations != NULL) { | |
| 1328 do_annotations = true; | |
| 1329 } | |
| 1330 if (do_annotations) { | |
| 1331 // Remember current method ordering so we can reorder annotations | |
| 1332 for (int i = 0; i < length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1333 Method* m = methods->at(i); |
| 0 | 1334 m->set_method_idnum(i); |
| 1335 } | |
| 1336 } | |
| 3779 | 1337 { |
| 1338 No_Safepoint_Verifier nsv; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1339 QuickSort::sort<Method*>(methods->data(), length, method_comparator, idempotent); |
| 0 | 1340 } |
| 1341 | |
| 1342 // Sort annotations if necessary | |
| 1343 assert(methods_annotations == NULL || methods_annotations->length() == methods->length(), ""); | |
| 1344 assert(methods_parameter_annotations == NULL || methods_parameter_annotations->length() == methods->length(), ""); | |
| 1345 assert(methods_default_annotations == NULL || methods_default_annotations->length() == methods->length(), ""); | |
| 1346 if (do_annotations) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
104
diff
changeset
|
1347 ResourceMark rm; |
| 0 | 1348 // Allocate temporary storage |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1349 GrowableArray<AnnotationArray*>* temp_array = new GrowableArray<AnnotationArray*>(length); |
| 0 | 1350 reorder_based_on_method_index(methods, methods_annotations, temp_array); |
| 1351 reorder_based_on_method_index(methods, methods_parameter_annotations, temp_array); | |
| 1352 reorder_based_on_method_index(methods, methods_default_annotations, temp_array); | |
| 1353 } | |
| 1354 | |
| 1355 // Reset method ordering | |
| 1356 for (int i = 0; i < length; i++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1357 Method* m = methods->at(i); |
| 0 | 1358 m->set_method_idnum(i); |
| 1359 } | |
| 1360 } | |
| 1361 } | |
| 1362 | |
| 1363 | |
| 1364 //----------------------------------------------------------------------------------- | |
| 1365 // Non-product code | |
| 1366 | |
| 1367 #ifndef PRODUCT | |
| 1368 class SignatureTypePrinter : public SignatureTypeNames { | |
| 1369 private: | |
| 1370 outputStream* _st; | |
| 1371 bool _use_separator; | |
| 1372 | |
| 1373 void type_name(const char* name) { | |
| 1374 if (_use_separator) _st->print(", "); | |
| 1375 _st->print(name); | |
| 1376 _use_separator = true; | |
| 1377 } | |
| 1378 | |
| 1379 public: | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
1380 SignatureTypePrinter(Symbol* signature, outputStream* st) : SignatureTypeNames(signature) { |
| 0 | 1381 _st = st; |
| 1382 _use_separator = false; | |
| 1383 } | |
| 1384 | |
| 1385 void print_parameters() { _use_separator = false; iterate_parameters(); } | |
| 1386 void print_returntype() { _use_separator = false; iterate_returntype(); } | |
| 1387 }; | |
| 1388 | |
| 1389 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1390 void Method::print_name(outputStream* st) { |
| 0 | 1391 Thread *thread = Thread::current(); |
| 1392 ResourceMark rm(thread); | |
| 1393 SignatureTypePrinter sig(signature(), st); | |
| 1394 st->print("%s ", is_static() ? "static" : "virtual"); | |
| 1395 sig.print_returntype(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1396 st->print(" %s.", method_holder()->internal_name()); |
| 0 | 1397 name()->print_symbol_on(st); |
| 1398 st->print("("); | |
| 1399 sig.print_parameters(); | |
| 1400 st->print(")"); | |
| 1401 } | |
| 1402 | |
| 1403 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1404 void Method::print_codes_on(outputStream* st) const { |
| 0 | 1405 print_codes_on(0, code_size(), st); |
| 1406 } | |
| 1407 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1408 void Method::print_codes_on(int from, int to, outputStream* st) const { |
| 0 | 1409 Thread *thread = Thread::current(); |
| 1410 ResourceMark rm(thread); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1411 methodHandle mh (thread, (Method*)this); |
| 0 | 1412 BytecodeStream s(mh); |
| 1413 s.set_interval(from, to); | |
| 1414 BytecodeTracer::set_closure(BytecodeTracer::std_closure()); | |
| 1415 while (s.next() >= 0) BytecodeTracer::trace(mh, s.bcp(), st); | |
| 1416 } | |
| 1417 #endif // not PRODUCT | |
| 1418 | |
| 1419 | |
| 1420 // Simple compression of line number tables. We use a regular compressed stream, except that we compress deltas | |
| 1421 // between (bci,line) pairs since they are smaller. If (bci delta, line delta) fits in (5-bit unsigned, 3-bit unsigned) | |
| 1422 // we save it as one byte, otherwise we write a 0xFF escape character and use regular compression. 0x0 is used | |
| 1423 // as end-of-stream terminator. | |
| 1424 | |
| 1425 void CompressedLineNumberWriteStream::write_pair_regular(int bci_delta, int line_delta) { | |
| 1426 // bci and line number does not compress into single byte. | |
| 1427 // Write out escape character and use regular compression for bci and line number. | |
| 1428 write_byte((jubyte)0xFF); | |
| 1429 write_signed_int(bci_delta); | |
| 1430 write_signed_int(line_delta); | |
| 1431 } | |
| 1432 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1433 // 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
|
1434 #if defined(_M_AMD64) && _MSC_VER >= 1400 |
| 0 | 1435 #pragma optimize("", off) |
| 1436 void CompressedLineNumberWriteStream::write_pair(int bci, int line) { | |
| 1437 write_pair_inline(bci, line); | |
| 1438 } | |
| 1439 #pragma optimize("", on) | |
| 1440 #endif | |
| 1441 | |
| 1442 CompressedLineNumberReadStream::CompressedLineNumberReadStream(u_char* buffer) : CompressedReadStream(buffer) { | |
| 1443 _bci = 0; | |
| 1444 _line = 0; | |
| 1445 }; | |
| 1446 | |
| 1447 | |
| 1448 bool CompressedLineNumberReadStream::read_pair() { | |
| 1449 jubyte next = read_byte(); | |
| 1450 // Check for terminator | |
| 1451 if (next == 0) return false; | |
| 1452 if (next == 0xFF) { | |
| 1453 // Escape character, regular compression used | |
| 1454 _bci += read_signed_int(); | |
| 1455 _line += read_signed_int(); | |
| 1456 } else { | |
| 1457 // Single byte compression used | |
| 1458 _bci += next >> 3; | |
| 1459 _line += next & 0x7; | |
| 1460 } | |
| 1461 return true; | |
| 1462 } | |
| 1463 | |
| 1464 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1465 Bytecodes::Code Method::orig_bytecode_at(int bci) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1466 BreakpointInfo* bp = InstanceKlass::cast(method_holder())->breakpoints(); |
| 0 | 1467 for (; bp != NULL; bp = bp->next()) { |
| 1468 if (bp->match(this, bci)) { | |
| 1469 return bp->orig_bytecode(); | |
| 1470 } | |
| 1471 } | |
| 1472 ShouldNotReachHere(); | |
| 1473 return Bytecodes::_shouldnotreachhere; | |
| 1474 } | |
| 1475 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1476 void Method::set_orig_bytecode_at(int bci, Bytecodes::Code code) { |
| 0 | 1477 assert(code != Bytecodes::_breakpoint, "cannot patch breakpoints this way"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1478 BreakpointInfo* bp = InstanceKlass::cast(method_holder())->breakpoints(); |
| 0 | 1479 for (; bp != NULL; bp = bp->next()) { |
| 1480 if (bp->match(this, bci)) { | |
| 1481 bp->set_orig_bytecode(code); | |
| 1482 // and continue, in case there is more than one | |
| 1483 } | |
| 1484 } | |
| 1485 } | |
| 1486 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1487 void Method::set_breakpoint(int bci) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1488 InstanceKlass* ik = InstanceKlass::cast(method_holder()); |
| 0 | 1489 BreakpointInfo *bp = new BreakpointInfo(this, bci); |
| 1490 bp->set_next(ik->breakpoints()); | |
| 1491 ik->set_breakpoints(bp); | |
| 1492 // do this last: | |
| 1493 bp->set(this); | |
| 1494 } | |
| 1495 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1496 static void clear_matches(Method* m, int bci) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1497 InstanceKlass* ik = InstanceKlass::cast(m->method_holder()); |
| 0 | 1498 BreakpointInfo* prev_bp = NULL; |
| 1499 BreakpointInfo* next_bp; | |
| 1500 for (BreakpointInfo* bp = ik->breakpoints(); bp != NULL; bp = next_bp) { | |
| 1501 next_bp = bp->next(); | |
| 1502 // bci value of -1 is used to delete all breakpoints in method m (ex: clear_all_breakpoint). | |
| 1503 if (bci >= 0 ? bp->match(m, bci) : bp->match(m)) { | |
| 1504 // do this first: | |
| 1505 bp->clear(m); | |
| 1506 // unhook it | |
| 1507 if (prev_bp != NULL) | |
| 1508 prev_bp->set_next(next_bp); | |
| 1509 else | |
| 1510 ik->set_breakpoints(next_bp); | |
| 1511 delete bp; | |
| 1512 // When class is redefined JVMTI sets breakpoint in all versions of EMCP methods | |
| 1513 // at same location. So we have multiple matching (method_index and bci) | |
| 1514 // BreakpointInfo nodes in BreakpointInfo list. We should just delete one | |
| 1515 // breakpoint for clear_breakpoint request and keep all other method versions | |
| 1516 // BreakpointInfo for future clear_breakpoint request. | |
| 1517 // bcivalue of -1 is used to clear all breakpoints (see clear_all_breakpoints) | |
| 1518 // which is being called when class is unloaded. We delete all the Breakpoint | |
| 1519 // information for all versions of method. We may not correctly restore the original | |
| 1520 // bytecode in all method versions, but that is ok. Because the class is being unloaded | |
| 1521 // so these methods won't be used anymore. | |
| 1522 if (bci >= 0) { | |
| 1523 break; | |
| 1524 } | |
| 1525 } else { | |
| 1526 // This one is a keeper. | |
| 1527 prev_bp = bp; | |
| 1528 } | |
| 1529 } | |
| 1530 } | |
| 1531 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1532 void Method::clear_breakpoint(int bci) { |
| 0 | 1533 assert(bci >= 0, ""); |
| 1534 clear_matches(this, bci); | |
| 1535 } | |
| 1536 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1537 void Method::clear_all_breakpoints() { |
| 0 | 1538 clear_matches(this, -1); |
| 1539 } | |
| 1540 | |
| 1541 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1542 int Method::invocation_count() { |
| 1783 | 1543 if (TieredCompilation) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1544 MethodData* const mdo = method_data(); |
| 1783 | 1545 if (invocation_counter()->carry() || ((mdo != NULL) ? mdo->invocation_counter()->carry() : false)) { |
| 1546 return InvocationCounter::count_limit; | |
| 1547 } else { | |
| 1548 return invocation_counter()->count() + ((mdo != NULL) ? mdo->invocation_counter()->count() : 0); | |
| 1549 } | |
| 1550 } else { | |
| 1551 return invocation_counter()->count(); | |
| 1552 } | |
| 1553 } | |
| 1554 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1555 int Method::backedge_count() { |
| 1783 | 1556 if (TieredCompilation) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1557 MethodData* const mdo = method_data(); |
| 1783 | 1558 if (backedge_counter()->carry() || ((mdo != NULL) ? mdo->backedge_counter()->carry() : false)) { |
| 1559 return InvocationCounter::count_limit; | |
| 1560 } else { | |
| 1561 return backedge_counter()->count() + ((mdo != NULL) ? mdo->backedge_counter()->count() : 0); | |
| 1562 } | |
| 1563 } else { | |
| 1564 return backedge_counter()->count(); | |
| 1565 } | |
| 1566 } | |
| 1567 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1568 int Method::highest_comp_level() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1569 MethodData* mdo = method_data(); |
| 1783 | 1570 if (mdo != NULL) { |
| 1571 return mdo->highest_comp_level(); | |
| 1572 } else { | |
| 1573 return CompLevel_none; | |
| 1574 } | |
| 1575 } | |
| 1576 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1577 int Method::highest_osr_comp_level() const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1578 MethodData* mdo = method_data(); |
| 1783 | 1579 if (mdo != NULL) { |
| 1580 return mdo->highest_osr_comp_level(); | |
| 1581 } else { | |
| 1582 return CompLevel_none; | |
| 1583 } | |
| 1584 } | |
| 1585 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1586 void Method::set_highest_comp_level(int level) { |
|
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 mdo->set_highest_comp_level(level); | |
| 1590 } | |
| 1591 } | |
| 1592 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1593 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
|
1594 MethodData* mdo = method_data(); |
| 1783 | 1595 if (mdo != NULL) { |
| 1596 mdo->set_highest_osr_comp_level(level); | |
| 1597 } | |
| 1598 } | |
| 1599 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1600 BreakpointInfo::BreakpointInfo(Method* m, int bci) { |
| 0 | 1601 _bci = bci; |
| 1602 _name_index = m->name_index(); | |
| 1603 _signature_index = m->signature_index(); | |
| 1604 _orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci); | |
| 1605 if (_orig_bytecode == Bytecodes::_breakpoint) | |
| 1606 _orig_bytecode = m->orig_bytecode_at(_bci); | |
| 1607 _next = NULL; | |
| 1608 } | |
| 1609 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1610 void BreakpointInfo::set(Method* method) { |
| 0 | 1611 #ifdef ASSERT |
| 1612 { | |
| 1613 Bytecodes::Code code = (Bytecodes::Code) *method->bcp_from(_bci); | |
| 1614 if (code == Bytecodes::_breakpoint) | |
| 1615 code = method->orig_bytecode_at(_bci); | |
| 1616 assert(orig_bytecode() == code, "original bytecode must be the same"); | |
| 1617 } | |
| 1618 #endif | |
| 1619 *method->bcp_from(_bci) = Bytecodes::_breakpoint; | |
| 1620 method->incr_number_of_breakpoints(); | |
| 1621 SystemDictionary::notice_modification(); | |
| 1622 { | |
| 1623 // Deoptimize all dependents on this method | |
| 1624 Thread *thread = Thread::current(); | |
| 1625 HandleMark hm(thread); | |
| 1626 methodHandle mh(thread, method); | |
| 1627 Universe::flush_dependents_on_method(mh); | |
| 1628 } | |
| 1629 } | |
| 1630 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1631 void BreakpointInfo::clear(Method* method) { |
| 0 | 1632 *method->bcp_from(_bci) = orig_bytecode(); |
| 1633 assert(method->number_of_breakpoints() > 0, "must not go negative"); | |
| 1634 method->decr_number_of_breakpoints(); | |
| 1635 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1636 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1637 // jmethodID handling |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1638 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1639 // 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
|
1640 // 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
|
1641 // 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
|
1642 // 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
|
1643 // never get rid of it. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1644 // 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
|
1645 // 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
|
1646 // into templates. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1647 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1648 // 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
|
1649 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1650 class JNIMethodBlock : public CHeapObj<mtClass> { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1651 enum { number_of_methods = 8 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1652 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1653 Method* _methods[number_of_methods]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1654 int _top; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1655 JNIMethodBlock* _next; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1656 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1657 static Method* const _free_method; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1658 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1659 JNIMethodBlock() : _next(NULL), _top(0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1660 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
|
1661 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1662 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1663 Method** add_method(Method* m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1664 if (_top < number_of_methods) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1665 // top points to the next free entry. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1666 int i = _top; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1667 _methods[i] = m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1668 _top++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1669 return &_methods[i]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1670 } else if (_top == number_of_methods) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1671 // 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
|
1672 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
|
1673 if (_methods[i] == _free_method) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1674 _methods[i] = m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1675 return &_methods[i]; |
|
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 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1678 // 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
|
1679 // Increment top past the end of the block. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1680 _top++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1681 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1682 // need to allocate a next block. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1683 if (_next == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1684 _next = new JNIMethodBlock(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1685 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1686 return _next->add_method(m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1687 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1688 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1689 bool contains(Method** m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1690 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
|
1691 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
|
1692 if (&(b->_methods[i]) == m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1693 return true; |
|
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 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1697 return false; // not found |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1698 } |
|
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 // 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
|
1701 void destroy_method(Method** m) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1702 #ifdef ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1703 assert(contains(m), "should be a methodID"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1704 #endif // ASSERT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1705 *m = _free_method; |
|
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 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1708 // 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
|
1709 // than freed. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1710 void clear_all_methods() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1711 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
|
1712 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
|
1713 _methods[i] = NULL; |
|
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 } |
|
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 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1718 int count_methods() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1719 // count all allocated methods |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1720 int count = 0; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1721 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
|
1722 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
|
1723 if (_methods[i] != _free_method) count++; |
|
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 return count; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1727 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1728 #endif // PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1729 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1730 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1731 // 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
|
1732 Method* const JNIMethodBlock::_free_method = (Method*)55; |
|
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 // Add a method id to the jmethod_ids |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1735 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
|
1736 ClassLoaderData* cld = loader_data; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1737 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1738 if (!SafepointSynchronize::is_at_safepoint()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1739 // 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
|
1740 // 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
|
1741 // protects as well. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1742 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
|
1743 if (cld->jmethod_ids() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1744 cld->set_jmethod_ids(new JNIMethodBlock()); |
|
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 // jmethodID is a pointer to Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1747 return (jmethodID)cld->jmethod_ids()->add_method(m); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1748 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1749 // 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
|
1750 if (cld->jmethod_ids() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1751 cld->set_jmethod_ids(new JNIMethodBlock()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1752 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1753 // jmethodID is a pointer to Method* |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1754 return (jmethodID)cld->jmethod_ids()->add_method(m); |
|
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 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1757 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1758 // 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
|
1759 // InstanceKlass while creating the jmethodID cache. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1760 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
|
1761 ClassLoaderData* cld = loader_data; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1762 Method** ptr = (Method**)m; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1763 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
|
1764 cld->jmethod_ids()->destroy_method(ptr); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1765 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1766 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1767 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
|
1768 // 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
|
1769 // scratch method holder. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1770 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
|
1771 == new_method->method_holder()->class_loader(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1772 "changing to a different class loader"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1773 // 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
|
1774 *((Method**)jmid) = new_method; |
|
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 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1777 bool Method::is_method_id(jmethodID mid) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1778 Method* m = resolve_jmethod_id(mid); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1779 assert(m != NULL, "should be called with non-null method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1780 InstanceKlass* ik = InstanceKlass::cast(m->method_holder()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1781 ClassLoaderData* cld = ik->class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1782 if (cld->jmethod_ids() == NULL) return false; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1783 return (cld->jmethod_ids()->contains((Method**)mid)); |
|
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 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1786 Method* Method::checked_resolve_jmethod_id(jmethodID mid) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1787 if (mid == NULL) return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1788 Method* o = resolve_jmethod_id(mid); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1789 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
|
1790 return NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1791 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1792 return o; |
|
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 void Method::set_on_stack(const bool value) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1796 // 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
|
1797 // 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
|
1798 _access_flags.set_on_stack(value); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1799 constants()->set_on_stack(value); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1800 if (value) MetadataOnStackMark::record(this); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1801 } |
|
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 // 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
|
1804 void Method::clear_jmethod_ids(ClassLoaderData* loader_data) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1805 loader_data->jmethod_ids()->clear_all_methods(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1806 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1807 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1808 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1809 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
|
1810 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
|
1811 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1812 #endif // PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1813 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1814 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1815 // Printing |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1816 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1817 #ifndef PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1818 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1819 void Method::print_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1820 ResourceMark rm; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1821 assert(is_method(), "must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1822 st->print_cr(internal_name()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1823 // get the effect of PrintOopAddress, always, for methods: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1824 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
|
1825 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
|
1826 st->print (" - constants: "INTPTR_FORMAT" ", (address)constants()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1827 constants()->print_value_on(st); st->cr(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1828 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
|
1829 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
|
1830 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
|
1831 st->print_cr(" - max stack: %d", max_stack()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1832 st->print_cr(" - max locals: %d", max_locals()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1833 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
|
1834 st->print_cr(" - method size: %d", method_size()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1835 if (intrinsic_id() != vmIntrinsics::_none) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1836 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
|
1837 if (highest_comp_level() != CompLevel_none) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1838 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
|
1839 st->print_cr(" - vtable index: %d", _vtable_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1840 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
|
1841 st->print( " - adapters: "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1842 AdapterHandlerEntry* a = ((Method*)this)->adapter(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1843 if (a == NULL) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1844 st->print_cr(INTPTR_FORMAT, a); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1845 else |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1846 a->print_adapter_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1847 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
|
1848 st->print_cr(" - code size: %d", code_size()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1849 if (code_size() != 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1850 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
|
1851 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
|
1852 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1853 if (method_data() != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1854 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
|
1855 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1856 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
|
1857 if (checked_exceptions_length() > 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1858 CheckedExceptionElement* table = checked_exceptions_start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1859 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
|
1860 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1861 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
|
1862 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
|
1863 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1864 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1865 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1866 if (has_linenumber_table()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1867 u_char* table = compressed_linenumber_table(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1868 st->print_cr(" - linenumber start: " INTPTR_FORMAT, table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1869 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1870 CompressedLineNumberReadStream stream(table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1871 while (stream.read_pair()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1872 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
|
1873 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1874 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1875 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1876 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
|
1877 if (localvariable_table_length() > 0) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1878 LocalVariableTableElement* table = localvariable_table_start(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1879 st->print_cr(" - localvar start: " INTPTR_FORMAT, table); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1880 if (Verbose) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1881 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
|
1882 int bci = table[i].start_bci; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1883 int len = table[i].length; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1884 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
|
1885 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
|
1886 int slot = table[i].slot; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1887 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
|
1888 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1889 } |
|
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 if (code() != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1892 st->print (" - compiled code: "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1893 code()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1894 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1895 if (is_native()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1896 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
|
1897 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
|
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 #endif //PRODUCT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1902 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1903 void Method::print_value_on(outputStream* st) const { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1904 assert(is_method(), "must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1905 st->print_cr(internal_name()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1906 print_address_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1907 st->print(" "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1908 name()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1909 st->print(" "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1910 signature()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1911 st->print(" in "); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1912 method_holder()->print_value_on(st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1913 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
|
1914 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
|
1915 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1916 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1917 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1918 // Verification |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1919 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1920 void Method::verify_on(outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1921 guarantee(is_method(), "object must be method"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1922 guarantee(is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1923 guarantee(constants()->is_constantPool(), "should be constant pool"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1924 guarantee(constants()->is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1925 guarantee(constMethod()->is_constMethod(), "should be ConstMethod*"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1926 guarantee(constMethod()->is_metadata(), "should be metadata"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1927 MethodData* md = method_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1928 guarantee(md == NULL || |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1929 md->is_metadata(), "should be in permspace"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1930 guarantee(md == NULL || |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1931 md->is_methodData(), "should be method data"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6267
diff
changeset
|
1932 } |