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