Mercurial > hg > truffle
annotate src/share/vm/interpreter/bytecodeTracer.cpp @ 14649:f6301b007a16
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 | 190899198332 |
| children | fdad2932c73f |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 8104 | 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:
1138
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1138
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:
1138
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "interpreter/bytecodeHistogram.hpp" | |
| 27 #include "interpreter/bytecodeTracer.hpp" | |
| 28 #include "interpreter/bytecodes.hpp" | |
| 29 #include "interpreter/interpreter.hpp" | |
| 30 #include "interpreter/interpreterRuntime.hpp" | |
| 31 #include "memory/resourceArea.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
32 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
33 #include "oops/method.hpp" |
| 1972 | 34 #include "runtime/mutexLocker.hpp" |
| 35 #include "runtime/timer.hpp" | |
| 0 | 36 |
| 37 | |
| 38 #ifndef PRODUCT | |
| 39 | |
| 40 // Standard closure for BytecodeTracer: prints the current bytecode | |
| 41 // and its attributes using bytecode-specific information. | |
| 42 | |
| 43 class BytecodePrinter: public BytecodeClosure { | |
| 44 private: | |
| 45 // %%% This field is not GC-ed, and so can contain garbage | |
| 46 // between critical sections. Use only pointer-comparison | |
| 47 // operations on the pointer, except within a critical section. | |
| 48 // (Also, ensure that occasional false positives are benign.) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
49 Method* _current_method; |
| 0 | 50 bool _is_wide; |
| 1565 | 51 Bytecodes::Code _code; |
| 0 | 52 address _next_pc; // current decoding position |
| 53 | |
| 54 void align() { _next_pc = (address)round_to((intptr_t)_next_pc, sizeof(jint)); } | |
| 55 int get_byte() { return *(jbyte*) _next_pc++; } // signed | |
| 56 short get_short() { short i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; } | |
| 57 int get_int() { int i=Bytes::get_Java_u4(_next_pc); _next_pc+=4; return i; } | |
| 58 | |
| 1565 | 59 int get_index_u1() { return *(address)_next_pc++; } |
| 60 int get_index_u2() { int i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
61 int get_index_u1_cpcache() { return get_index_u1() + ConstantPool::CPCACHE_INDEX_TAG; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
62 int get_index_u2_cpcache() { int i=Bytes::get_native_u2(_next_pc); _next_pc+=2; return i + ConstantPool::CPCACHE_INDEX_TAG; } |
| 1565 | 63 int get_index_u4() { int i=Bytes::get_native_u4(_next_pc); _next_pc+=4; return i; } |
| 64 int get_index_special() { return (is_wide()) ? get_index_u2() : get_index_u1(); } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
65 Method* method() { return _current_method; } |
| 0 | 66 bool is_wide() { return _is_wide; } |
| 1565 | 67 Bytecodes::Code raw_code() { return Bytecodes::Code(_code); } |
| 0 | 68 |
| 69 | |
| 1565 | 70 bool check_index(int i, int& cp_index, outputStream* st = tty); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
71 bool check_cp_cache_index(int i, int& cp_index, outputStream* st = tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
72 bool check_obj_index(int i, int& cp_index, outputStream* st = tty); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
73 bool check_invokedynamic_index(int i, int& cp_index, outputStream* st = tty); |
| 0 | 74 void print_constant(int i, outputStream* st = tty); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
75 void print_field_or_method(int i, outputStream* st = tty); |
| 1602 | 76 void print_field_or_method(int orig_i, int i, outputStream* st = tty); |
| 1565 | 77 void print_attributes(int bci, outputStream* st = tty); |
| 0 | 78 void bytecode_epilog(int bci, outputStream* st = tty); |
| 79 | |
| 80 public: | |
| 81 BytecodePrinter() { | |
| 82 _is_wide = false; | |
| 1565 | 83 _code = Bytecodes::_illegal; |
| 0 | 84 } |
| 85 | |
| 86 // This method is called while executing the raw bytecodes, so none of | |
| 87 // the adjustments that BytecodeStream performs applies. | |
| 88 void trace(methodHandle method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) { | |
| 89 ResourceMark rm; | |
| 90 if (_current_method != method()) { | |
| 91 // Note 1: This code will not work as expected with true MT/MP. | |
| 92 // Need an explicit lock or a different solution. | |
| 93 // It is possible for this block to be skipped, if a garbage | |
| 94 // _current_method pointer happens to have the same bits as | |
| 95 // the incoming method. We could lose a line of trace output. | |
| 96 // This is acceptable in a debug-only feature. | |
| 97 st->cr(); | |
| 3960 | 98 st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id()); |
| 0 | 99 method->print_name(st); |
| 100 st->cr(); | |
| 101 _current_method = method(); | |
| 102 } | |
| 103 Bytecodes::Code code; | |
| 104 if (is_wide()) { | |
| 105 // bcp wasn't advanced if previous bytecode was _wide. | |
| 2142 | 106 code = Bytecodes::code_at(method(), bcp+1); |
| 0 | 107 } else { |
| 2142 | 108 code = Bytecodes::code_at(method(), bcp); |
| 0 | 109 } |
| 1565 | 110 _code = code; |
| 111 int bci = bcp - method->code_base(); | |
| 3960 | 112 st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id()); |
| 0 | 113 if (Verbose) { |
| 114 st->print("%8d %4d " INTPTR_FORMAT " " INTPTR_FORMAT " %s", | |
| 115 BytecodeCounter::counter_value(), bci, tos, tos2, Bytecodes::name(code)); | |
| 116 } else { | |
| 117 st->print("%8d %4d %s", | |
| 118 BytecodeCounter::counter_value(), bci, Bytecodes::name(code)); | |
| 119 } | |
| 120 _next_pc = is_wide() ? bcp+2 : bcp+1; | |
| 1565 | 121 print_attributes(bci); |
| 0 | 122 // Set is_wide for the next one, since the caller of this doesn't skip |
| 123 // the next bytecode. | |
| 124 _is_wide = (code == Bytecodes::_wide); | |
| 1565 | 125 _code = Bytecodes::_illegal; |
| 0 | 126 } |
| 127 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
128 // Used for Method*::print_codes(). The input bcp comes from |
| 0 | 129 // BytecodeStream, which will skip wide bytecodes. |
| 130 void trace(methodHandle method, address bcp, outputStream* st) { | |
| 131 _current_method = method(); | |
| 132 ResourceMark rm; | |
| 2142 | 133 Bytecodes::Code code = Bytecodes::code_at(method(), bcp); |
| 0 | 134 // Set is_wide |
| 135 _is_wide = (code == Bytecodes::_wide); | |
| 136 if (is_wide()) { | |
| 2142 | 137 code = Bytecodes::code_at(method(), bcp+1); |
| 0 | 138 } |
| 1565 | 139 _code = code; |
| 0 | 140 int bci = bcp - method->code_base(); |
| 141 // Print bytecode index and name | |
| 142 if (is_wide()) { | |
| 143 st->print("%d %s_w", bci, Bytecodes::name(code)); | |
| 144 } else { | |
| 145 st->print("%d %s", bci, Bytecodes::name(code)); | |
| 146 } | |
| 147 _next_pc = is_wide() ? bcp+2 : bcp+1; | |
| 1565 | 148 print_attributes(bci, st); |
| 0 | 149 bytecode_epilog(bci, st); |
| 150 } | |
| 151 }; | |
| 152 | |
| 153 | |
| 154 // Implementation of BytecodeTracer | |
| 155 | |
| 156 // %%% This set_closure thing seems overly general, given that | |
| 157 // nobody uses it. Also, if BytecodePrinter weren't hidden | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
158 // then Method* could use instances of it directly and it |
| 0 | 159 // would be easier to remove races on _current_method and bcp. |
| 160 // Since this is not product functionality, we can defer cleanup. | |
| 161 | |
| 162 BytecodeClosure* BytecodeTracer::_closure = NULL; | |
| 163 | |
| 164 static BytecodePrinter std_closure; | |
| 165 BytecodeClosure* BytecodeTracer::std_closure() { | |
| 166 return &::std_closure; | |
| 167 } | |
| 168 | |
| 169 | |
| 170 void BytecodeTracer::trace(methodHandle method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) { | |
| 171 if (TraceBytecodes && BytecodeCounter::counter_value() >= TraceBytecodesAt) { | |
| 172 ttyLocker ttyl; // 5065316: keep the following output coherent | |
| 173 // The ttyLocker also prevents races between two threads | |
| 174 // trying to use the single instance of BytecodePrinter. | |
| 175 // Using the ttyLocker prevents the system from coming to | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
176 // a safepoint within this code, which is sensitive to Method* |
| 0 | 177 // movement. |
| 178 // | |
| 179 // There used to be a leaf mutex here, but the ttyLocker will | |
| 180 // work just as well, as long as the printing operations never block. | |
| 181 // | |
| 182 // We put the locker on the static trace method, not the | |
| 183 // virtual one, because the clients of this module go through | |
| 184 // the static method. | |
| 185 _closure->trace(method, bcp, tos, tos2, st); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 void BytecodeTracer::trace(methodHandle method, address bcp, outputStream* st) { | |
| 190 ttyLocker ttyl; // 5065316: keep the following output coherent | |
| 191 _closure->trace(method, bcp, st); | |
| 192 } | |
| 193 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
194 void print_symbol(Symbol* sym, outputStream* st) { |
| 1602 | 195 char buf[40]; |
| 196 int len = sym->utf8_length(); | |
| 197 if (len >= (int)sizeof(buf)) { | |
| 198 st->print_cr(" %s...[%d]", sym->as_C_string(buf, sizeof(buf)), len); | |
| 199 } else { | |
| 200 st->print(" "); | |
| 201 sym->print_on(st); st->cr(); | |
| 202 } | |
| 203 } | |
| 204 | |
| 0 | 205 void print_oop(oop value, outputStream* st) { |
| 206 if (value == NULL) { | |
| 207 st->print_cr(" NULL"); | |
| 1602 | 208 } else if (java_lang_String::is_instance(value)) { |
|
3388
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
209 char buf[40]; |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
210 int len = java_lang_String::utf8_length(value); |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
211 java_lang_String::as_utf8_string(value, buf, sizeof(buf)); |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
212 if (len >= (int)sizeof(buf)) { |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
213 st->print_cr(" %s...[%d]", buf, len); |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
214 } else { |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
215 st->print_cr(" %s", buf); |
|
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2460
diff
changeset
|
216 } |
| 1602 | 217 } else { |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
8104
diff
changeset
|
218 st->print_cr(" " PTR_FORMAT, (void *)value); |
| 0 | 219 } |
| 220 } | |
| 221 | |
| 1565 | 222 bool BytecodePrinter::check_index(int i, int& cp_index, outputStream* st) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
223 ConstantPool* constants = method()->constants(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
224 int ilimit = constants->length(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
225 Bytecodes::Code code = raw_code(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
226 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
227 ConstantPoolCache* cache = NULL; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
228 if (Bytecodes::uses_cp_cache(code)) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
229 bool okay = true; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
230 switch (code) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
231 case Bytecodes::_fast_aldc: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
232 case Bytecodes::_fast_aldc_w: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
233 okay = check_obj_index(i, cp_index, st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
234 break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
235 case Bytecodes::_invokedynamic: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
236 okay = check_invokedynamic_index(i, cp_index, st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
237 break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
238 default: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
239 okay = check_cp_cache_index(i, cp_index, st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
240 break; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
241 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
242 if (!okay) return false; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
243 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
244 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
245 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
246 // check cp index |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
247 if (cp_index >= 0 && cp_index < ilimit) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
248 if (WizardMode) st->print(" cp[%d]", cp_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
249 return true; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
250 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
251 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
252 st->print_cr(" CP[%d] not in CP", cp_index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
253 return false; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
254 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
255 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
256 bool BytecodePrinter::check_cp_cache_index(int i, int& cp_index, outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
257 ConstantPool* constants = method()->constants(); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
258 int ilimit = constants->length(), climit = 0; |
| 1565 | 259 Bytecodes::Code code = raw_code(); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
260 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
261 ConstantPoolCache* cache = constants->cache(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
262 // If rewriter hasn't run, the index is the cp_index |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
263 if (cache == NULL) { |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
264 cp_index = i; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
265 return true; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
266 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
267 //climit = cache->length(); // %%% private! |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
268 size_t size = cache->size() * HeapWordSize; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
269 size -= sizeof(ConstantPoolCache); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
270 size /= sizeof(ConstantPoolCacheEntry); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
271 climit = (int) size; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
272 |
| 1565 | 273 #ifdef ASSERT |
| 274 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
275 const int CPCACHE_INDEX_TAG = ConstantPool::CPCACHE_INDEX_TAG; |
| 1565 | 276 if (i >= CPCACHE_INDEX_TAG && i < climit + CPCACHE_INDEX_TAG) { |
| 277 i -= CPCACHE_INDEX_TAG; | |
| 278 } else { | |
| 279 st->print_cr(" CP[%d] missing bias?", i); | |
| 280 return false; | |
| 281 } | |
| 282 } | |
| 283 #endif //ASSERT | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
284 if (i >= 0 && i < climit) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
285 cp_index = cache->entry_at(i)->constant_pool_index(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
286 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
287 st->print_cr(" not in CP[*]?", i); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
288 return false; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
289 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
290 return true; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
291 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
292 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
293 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
294 bool BytecodePrinter::check_obj_index(int i, int& cp_index, outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
295 ConstantPool* constants = method()->constants(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
296 i -= ConstantPool::CPCACHE_INDEX_TAG; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
297 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
298 if (i >= 0 && i < constants->resolved_references()->length()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
299 cp_index = constants->object_to_cp_index(i); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
300 return true; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
301 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
302 st->print_cr(" not in OBJ[*]?", i); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
303 return false; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
304 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
305 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
306 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
307 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
308 bool BytecodePrinter::check_invokedynamic_index(int i, int& cp_index, outputStream* st) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
309 ConstantPool* constants = method()->constants(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
310 assert(ConstantPool::is_invokedynamic_index(i), "not secondary index?"); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
311 i = ConstantPool::decode_invokedynamic_index(i) + ConstantPool::CPCACHE_INDEX_TAG; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
312 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
313 return check_cp_cache_index(i, cp_index, st); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
314 } |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
315 |
| 0 | 316 void BytecodePrinter::print_constant(int i, outputStream* st) { |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
317 int orig_i = i; |
| 1565 | 318 if (!check_index(orig_i, i, st)) return; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
319 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
320 ConstantPool* constants = method()->constants(); |
| 0 | 321 constantTag tag = constants->tag_at(i); |
| 322 | |
| 323 if (tag.is_int()) { | |
| 324 st->print_cr(" " INT32_FORMAT, constants->int_at(i)); | |
| 325 } else if (tag.is_long()) { | |
| 326 st->print_cr(" " INT64_FORMAT, constants->long_at(i)); | |
| 327 } else if (tag.is_float()) { | |
| 328 st->print_cr(" %f", constants->float_at(i)); | |
| 329 } else if (tag.is_double()) { | |
| 330 st->print_cr(" %f", constants->double_at(i)); | |
| 331 } else if (tag.is_string()) { | |
| 1602 | 332 const char* string = constants->string_at_noresolve(i); |
| 333 st->print_cr(" %s", string); | |
| 0 | 334 } else if (tag.is_klass()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
335 st->print_cr(" %s", constants->resolved_klass_at(i)->external_name()); |
| 0 | 336 } else if (tag.is_unresolved_klass()) { |
| 337 st->print_cr(" <unresolved klass at %d>", i); | |
| 1602 | 338 } else if (tag.is_method_type()) { |
| 339 int i2 = constants->method_type_index_at(i); | |
| 340 st->print(" <MethodType> %d", i2); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
341 print_symbol(constants->symbol_at(i2), st); |
| 1602 | 342 } else if (tag.is_method_handle()) { |
| 343 int kind = constants->method_handle_ref_kind_at(i); | |
| 344 int i2 = constants->method_handle_index_at(i); | |
| 345 st->print(" <MethodHandle of kind %d>", kind, i2); | |
| 346 print_field_or_method(-i, i2, st); | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
347 } else { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
348 st->print_cr(" bad tag=%d at %d", tag.value(), i); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
349 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
350 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
351 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
352 void BytecodePrinter::print_field_or_method(int i, outputStream* st) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
353 int orig_i = i; |
| 1565 | 354 if (!check_index(orig_i, i, st)) return; |
| 1602 | 355 print_field_or_method(orig_i, i, st); |
| 356 } | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
357 |
| 1602 | 358 void BytecodePrinter::print_field_or_method(int orig_i, int i, outputStream* st) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
359 ConstantPool* constants = method()->constants(); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
360 constantTag tag = constants->tag_at(i); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
361 |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
362 bool has_klass = true; |
|
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
844
diff
changeset
|
363 |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
364 switch (tag.value()) { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
365 case JVM_CONSTANT_InterfaceMethodref: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
366 case JVM_CONSTANT_Methodref: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
367 case JVM_CONSTANT_Fieldref: |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
368 break; |
|
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
844
diff
changeset
|
369 case JVM_CONSTANT_NameAndType: |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
370 case JVM_CONSTANT_InvokeDynamic: |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
371 has_klass = false; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
372 break; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
373 default: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
374 st->print_cr(" bad tag=%d at %d", tag.value(), i); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
375 return; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
376 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
377 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
378 Symbol* name = constants->uncached_name_ref_at(i); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
379 Symbol* signature = constants->uncached_signature_ref_at(i); |
| 1602 | 380 const char* sep = (tag.is_field() ? "/" : ""); |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
381 if (has_klass) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
382 Symbol* klass = constants->klass_name_at(constants->uncached_klass_ref_index_at(i)); |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
383 st->print_cr(" %d <%s.%s%s%s> ", i, klass->as_C_string(), name->as_C_string(), sep, signature->as_C_string()); |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
384 } else { |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
385 if (tag.is_invoke_dynamic()) { |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
386 int bsm = constants->invoke_dynamic_bootstrap_method_ref_index_at(i); |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
387 st->print(" bsm=%d", bsm); |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
388 } |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
389 st->print_cr(" %d <%s%s%s>", i, name->as_C_string(), sep, signature->as_C_string()); |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
390 } |
| 0 | 391 } |
| 392 | |
| 393 | |
| 1565 | 394 void BytecodePrinter::print_attributes(int bci, outputStream* st) { |
| 0 | 395 // Show attributes of pre-rewritten codes |
| 1565 | 396 Bytecodes::Code code = Bytecodes::java_code(raw_code()); |
| 0 | 397 // If the code doesn't have any fields there's nothing to print. |
| 398 // note this is ==1 because the tableswitch and lookupswitch are | |
| 399 // zero size (for some reason) and we want to print stuff out for them. | |
| 400 if (Bytecodes::length_for(code) == 1) { | |
| 401 st->cr(); | |
| 402 return; | |
| 403 } | |
| 404 | |
| 405 switch(code) { | |
| 406 // Java specific bytecodes only matter. | |
| 407 case Bytecodes::_bipush: | |
| 408 st->print_cr(" " INT32_FORMAT, get_byte()); | |
| 409 break; | |
| 410 case Bytecodes::_sipush: | |
| 411 st->print_cr(" " INT32_FORMAT, get_short()); | |
| 412 break; | |
| 413 case Bytecodes::_ldc: | |
| 1602 | 414 if (Bytecodes::uses_cp_cache(raw_code())) { |
| 415 print_constant(get_index_u1_cpcache(), st); | |
| 416 } else { | |
| 417 print_constant(get_index_u1(), st); | |
| 418 } | |
| 0 | 419 break; |
| 420 | |
| 421 case Bytecodes::_ldc_w: | |
| 422 case Bytecodes::_ldc2_w: | |
| 1602 | 423 if (Bytecodes::uses_cp_cache(raw_code())) { |
| 424 print_constant(get_index_u2_cpcache(), st); | |
| 425 } else { | |
| 426 print_constant(get_index_u2(), st); | |
| 427 } | |
| 0 | 428 break; |
| 429 | |
| 430 case Bytecodes::_iload: | |
| 431 case Bytecodes::_lload: | |
| 432 case Bytecodes::_fload: | |
| 433 case Bytecodes::_dload: | |
| 434 case Bytecodes::_aload: | |
| 435 case Bytecodes::_istore: | |
| 436 case Bytecodes::_lstore: | |
| 437 case Bytecodes::_fstore: | |
| 438 case Bytecodes::_dstore: | |
| 439 case Bytecodes::_astore: | |
| 440 st->print_cr(" #%d", get_index_special()); | |
| 441 break; | |
| 442 | |
| 443 case Bytecodes::_iinc: | |
| 444 { int index = get_index_special(); | |
| 445 jint offset = is_wide() ? get_short(): get_byte(); | |
| 446 st->print_cr(" #%d " INT32_FORMAT, index, offset); | |
| 447 } | |
| 448 break; | |
| 449 | |
| 450 case Bytecodes::_newarray: { | |
| 1565 | 451 BasicType atype = (BasicType)get_index_u1(); |
| 0 | 452 const char* str = type2name(atype); |
| 453 if (str == NULL || atype == T_OBJECT || atype == T_ARRAY) { | |
| 454 assert(false, "Unidentified basic type"); | |
| 455 } | |
| 456 st->print_cr(" %s", str); | |
| 457 } | |
| 458 break; | |
| 459 case Bytecodes::_anewarray: { | |
| 1565 | 460 int klass_index = get_index_u2(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
461 ConstantPool* constants = method()->constants(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
462 Symbol* name = constants->klass_name_at(klass_index); |
| 0 | 463 st->print_cr(" %s ", name->as_C_string()); |
| 464 } | |
| 465 break; | |
| 466 case Bytecodes::_multianewarray: { | |
| 1565 | 467 int klass_index = get_index_u2(); |
| 468 int nof_dims = get_index_u1(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
469 ConstantPool* constants = method()->constants(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
470 Symbol* name = constants->klass_name_at(klass_index); |
| 0 | 471 st->print_cr(" %s %d", name->as_C_string(), nof_dims); |
| 472 } | |
| 473 break; | |
| 474 | |
| 475 case Bytecodes::_ifeq: | |
| 476 case Bytecodes::_ifnull: | |
| 477 case Bytecodes::_iflt: | |
| 478 case Bytecodes::_ifle: | |
| 479 case Bytecodes::_ifne: | |
| 480 case Bytecodes::_ifnonnull: | |
| 481 case Bytecodes::_ifgt: | |
| 482 case Bytecodes::_ifge: | |
| 483 case Bytecodes::_if_icmpeq: | |
| 484 case Bytecodes::_if_icmpne: | |
| 485 case Bytecodes::_if_icmplt: | |
| 486 case Bytecodes::_if_icmpgt: | |
| 487 case Bytecodes::_if_icmple: | |
| 488 case Bytecodes::_if_icmpge: | |
| 489 case Bytecodes::_if_acmpeq: | |
| 490 case Bytecodes::_if_acmpne: | |
| 491 case Bytecodes::_goto: | |
| 492 case Bytecodes::_jsr: | |
| 493 st->print_cr(" %d", bci + get_short()); | |
| 494 break; | |
| 495 | |
| 496 case Bytecodes::_goto_w: | |
| 497 case Bytecodes::_jsr_w: | |
| 498 st->print_cr(" %d", bci + get_int()); | |
| 499 break; | |
| 500 | |
| 501 case Bytecodes::_ret: st->print_cr(" %d", get_index_special()); break; | |
| 502 | |
| 503 case Bytecodes::_tableswitch: | |
| 504 { align(); | |
| 505 int default_dest = bci + get_int(); | |
| 506 int lo = get_int(); | |
| 507 int hi = get_int(); | |
| 508 int len = hi - lo + 1; | |
| 509 jint* dest = NEW_RESOURCE_ARRAY(jint, len); | |
| 510 for (int i = 0; i < len; i++) { | |
| 511 dest[i] = bci + get_int(); | |
| 512 } | |
| 513 st->print(" %d " INT32_FORMAT " " INT32_FORMAT " ", | |
| 514 default_dest, lo, hi); | |
| 515 int first = true; | |
| 516 for (int ll = lo; ll <= hi; ll++, first = false) { | |
| 517 int idx = ll - lo; | |
| 518 const char *format = first ? " %d:" INT32_FORMAT " (delta: %d)" : | |
| 519 ", %d:" INT32_FORMAT " (delta: %d)"; | |
| 520 st->print(format, ll, dest[idx], dest[idx]-bci); | |
| 521 } | |
| 522 st->cr(); | |
| 523 } | |
| 524 break; | |
| 525 case Bytecodes::_lookupswitch: | |
| 526 { align(); | |
| 527 int default_dest = bci + get_int(); | |
| 528 int len = get_int(); | |
| 529 jint* key = NEW_RESOURCE_ARRAY(jint, len); | |
| 530 jint* dest = NEW_RESOURCE_ARRAY(jint, len); | |
| 531 for (int i = 0; i < len; i++) { | |
| 532 key [i] = get_int(); | |
| 533 dest[i] = bci + get_int(); | |
| 534 }; | |
| 535 st->print(" %d %d ", default_dest, len); | |
| 536 bool first = true; | |
| 537 for (int ll = 0; ll < len; ll++, first = false) { | |
| 538 const char *format = first ? " " INT32_FORMAT ":" INT32_FORMAT : | |
| 539 ", " INT32_FORMAT ":" INT32_FORMAT ; | |
| 540 st->print(format, key[ll], dest[ll]); | |
| 541 } | |
| 542 st->cr(); | |
| 543 } | |
| 544 break; | |
| 545 | |
| 546 case Bytecodes::_putstatic: | |
| 547 case Bytecodes::_getstatic: | |
| 548 case Bytecodes::_putfield: | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
549 case Bytecodes::_getfield: |
| 1565 | 550 print_field_or_method(get_index_u2_cpcache(), st); |
| 0 | 551 break; |
| 552 | |
| 553 case Bytecodes::_invokevirtual: | |
| 554 case Bytecodes::_invokespecial: | |
| 555 case Bytecodes::_invokestatic: | |
| 1565 | 556 print_field_or_method(get_index_u2_cpcache(), st); |
| 0 | 557 break; |
| 558 | |
| 559 case Bytecodes::_invokeinterface: | |
| 1565 | 560 { int i = get_index_u2_cpcache(); |
| 561 int n = get_index_u1(); | |
| 562 get_byte(); // ignore zero byte | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
563 print_field_or_method(i, st); |
| 0 | 564 } |
| 565 break; | |
| 566 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
567 case Bytecodes::_invokedynamic: |
| 1565 | 568 print_field_or_method(get_index_u4(), st); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
569 break; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
570 |
| 0 | 571 case Bytecodes::_new: |
| 572 case Bytecodes::_checkcast: | |
| 573 case Bytecodes::_instanceof: | |
| 1565 | 574 { int i = get_index_u2(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
575 ConstantPool* constants = method()->constants(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2142
diff
changeset
|
576 Symbol* name = constants->klass_name_at(i); |
| 0 | 577 st->print_cr(" %d <%s>", i, name->as_C_string()); |
| 578 } | |
| 579 break; | |
| 580 | |
| 581 case Bytecodes::_wide: | |
| 582 // length is zero not one, but printed with no more info. | |
| 583 break; | |
| 584 | |
| 585 default: | |
| 586 ShouldNotReachHere(); | |
| 587 break; | |
| 588 } | |
| 589 } | |
| 590 | |
| 591 | |
| 592 void BytecodePrinter::bytecode_epilog(int bci, outputStream* st) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
4042
diff
changeset
|
593 MethodData* mdo = method()->method_data(); |
| 0 | 594 if (mdo != NULL) { |
| 595 ProfileData* data = mdo->bci_to_data(bci); | |
| 596 if (data != NULL) { | |
| 597 st->print(" %d", mdo->dp_to_di(data->dp())); | |
| 598 st->fill_to(6); | |
| 599 data->print_data_on(st); | |
| 600 } | |
| 601 } | |
| 602 } | |
| 603 #endif // PRODUCT |