truffle: src/share/vm/interpreter/bytecodeTracer.cpp annotate

annotate src/share/vm/interpreter/bytecodeTracer.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	78bbf4d43a14
children	52b4284cb496

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	26 #include "interpreter/bytecodeHistogram.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	27 #include "interpreter/bytecodeTracer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	28 #include "interpreter/bytecodes.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	29 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	30 #include "interpreter/interpreterRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	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 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	34 #include "runtime/mutexLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1660 diff changeset	35 #include "runtime/timer.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37
a61af66fc99e Initial load duke parents: diff changeset	38 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 // Standard closure for BytecodeTracer: prints the current bytecode
a61af66fc99e Initial load duke parents: diff changeset	41 // and its attributes using bytecode-specific information.
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43 class BytecodePrinter: public BytecodeClosure {
a61af66fc99e Initial load duke parents: diff changeset	44 private:
a61af66fc99e Initial load duke parents: diff changeset	45 // %%% This field is not GC-ed, and so can contain garbage
a61af66fc99e Initial load duke parents: diff changeset	46 // between critical sections. Use only pointer-comparison
a61af66fc99e Initial load duke parents: diff changeset	47 // operations on the pointer, except within a critical section.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	50 bool _is_wide;
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	51 Bytecodes::Code _code;
0 a61af66fc99e Initial load duke parents: diff changeset	52 address _next_pc; // current decoding position
a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 void align() { _next_pc = (address)round_to((intptr_t)_next_pc, sizeof(jint)); }
a61af66fc99e Initial load duke parents: diff changeset	55 int get_byte() { return (jbyte) _next_pc++; } // signed
a61af66fc99e Initial load duke parents: diff changeset	56 short get_short() { short i=Bytes::get_Java_u2(_next_pc); _next_pc+=2; return i; }
a61af66fc99e Initial load duke parents: diff changeset	57 int get_int() { int i=Bytes::get_Java_u4(_next_pc); _next_pc+=4; return i; }
a61af66fc99e Initial load duke parents: diff changeset	58
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	59 int get_index_u1() { return *(address)_next_pc++; }
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	63 int get_index_u4() { int i=Bytes::get_native_u4(_next_pc); _next_pc+=4; return i; }
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	66 bool is_wide() { return _is_wide; }
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	67 Bytecodes::Code raw_code() { return Bytecodes::Code(_code); }
0 a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	76 void print_field_or_method(int orig_i, int i, outputStream* st = tty);
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	77 void print_attributes(int bci, outputStream* st = tty);
0 a61af66fc99e Initial load duke parents: diff changeset	78 void bytecode_epilog(int bci, outputStream* st = tty);
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 public:
a61af66fc99e Initial load duke parents: diff changeset	81 BytecodePrinter() {
a61af66fc99e Initial load duke parents: diff changeset	82 _is_wide = false;
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	83 _code = Bytecodes::_illegal;
0 a61af66fc99e Initial load duke parents: diff changeset	84 }
a61af66fc99e Initial load duke parents: diff changeset	85
a61af66fc99e Initial load duke parents: diff changeset	86 // This method is called while executing the raw bytecodes, so none of
a61af66fc99e Initial load duke parents: diff changeset	87 // the adjustments that BytecodeStream performs applies.
a61af66fc99e Initial load duke parents: diff changeset	88 void trace(methodHandle method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	89 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	90 if (_current_method != method()) {
a61af66fc99e Initial load duke parents: diff changeset	91 // Note 1: This code will not work as expected with true MT/MP.
a61af66fc99e Initial load duke parents: diff changeset	92 // Need an explicit lock or a different solution.
a61af66fc99e Initial load duke parents: diff changeset	93 // It is possible for this block to be skipped, if a garbage
a61af66fc99e Initial load duke parents: diff changeset	94 // _current_method pointer happens to have the same bits as
a61af66fc99e Initial load duke parents: diff changeset	95 // the incoming method. We could lose a line of trace output.
a61af66fc99e Initial load duke parents: diff changeset	96 // This is acceptable in a debug-only feature.
a61af66fc99e Initial load duke parents: diff changeset	97 st->cr();
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3388 diff changeset	98 st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
0 a61af66fc99e Initial load duke parents: diff changeset	99 method->print_name(st);
a61af66fc99e Initial load duke parents: diff changeset	100 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	101 _current_method = method();
a61af66fc99e Initial load duke parents: diff changeset	102 }
a61af66fc99e Initial load duke parents: diff changeset	103 Bytecodes::Code code;
a61af66fc99e Initial load duke parents: diff changeset	104 if (is_wide()) {
a61af66fc99e Initial load duke parents: diff changeset	105 // bcp wasn't advanced if previous bytecode was _wide.
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 2011 diff changeset	106 code = Bytecodes::code_at(method(), bcp+1);
0 a61af66fc99e Initial load duke parents: diff changeset	107 } else {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 2011 diff changeset	108 code = Bytecodes::code_at(method(), bcp);
0 a61af66fc99e Initial load duke parents: diff changeset	109 }
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	110 _code = code;
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	111 int bci = bcp - method->code_base();
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3388 diff changeset	112 st->print("[%ld] ", (long) Thread::current()->osthread()->thread_id());
0 a61af66fc99e Initial load duke parents: diff changeset	113 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	114 st->print("%8d %4d " INTPTR_FORMAT " " INTPTR_FORMAT " %s",
a61af66fc99e Initial load duke parents: diff changeset	115 BytecodeCounter::counter_value(), bci, tos, tos2, Bytecodes::name(code));
a61af66fc99e Initial load duke parents: diff changeset	116 } else {
a61af66fc99e Initial load duke parents: diff changeset	117 st->print("%8d %4d %s",
a61af66fc99e Initial load duke parents: diff changeset	118 BytecodeCounter::counter_value(), bci, Bytecodes::name(code));
a61af66fc99e Initial load duke parents: diff changeset	119 }
a61af66fc99e Initial load duke parents: diff changeset	120 _next_pc = is_wide() ? bcp+2 : bcp+1;
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	121 print_attributes(bci);
0 a61af66fc99e Initial load duke parents: diff changeset	122 // Set is_wide for the next one, since the caller of this doesn't skip
a61af66fc99e Initial load duke parents: diff changeset	123 // the next bytecode.
a61af66fc99e Initial load duke parents: diff changeset	124 _is_wide = (code == Bytecodes::_wide);
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	125 _code = Bytecodes::_illegal;
0 a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	129 // BytecodeStream, which will skip wide bytecodes.
a61af66fc99e Initial load duke parents: diff changeset	130 void trace(methodHandle method, address bcp, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	131 _current_method = method();
a61af66fc99e Initial load duke parents: diff changeset	132 ResourceMark rm;
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 2011 diff changeset	133 Bytecodes::Code code = Bytecodes::code_at(method(), bcp);
0 a61af66fc99e Initial load duke parents: diff changeset	134 // Set is_wide
a61af66fc99e Initial load duke parents: diff changeset	135 _is_wide = (code == Bytecodes::_wide);
a61af66fc99e Initial load duke parents: diff changeset	136 if (is_wide()) {
2142 8012aa3ccede 4926272: methodOopDesc::method_from_bcp is unsafe never parents: 2011 diff changeset	137 code = Bytecodes::code_at(method(), bcp+1);
0 a61af66fc99e Initial load duke parents: diff changeset	138 }
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	139 _code = code;
0 a61af66fc99e Initial load duke parents: diff changeset	140 int bci = bcp - method->code_base();
a61af66fc99e Initial load duke parents: diff changeset	141 // Print bytecode index and name
a61af66fc99e Initial load duke parents: diff changeset	142 if (is_wide()) {
a61af66fc99e Initial load duke parents: diff changeset	143 st->print("%d %s_w", bci, Bytecodes::name(code));
a61af66fc99e Initial load duke parents: diff changeset	144 } else {
a61af66fc99e Initial load duke parents: diff changeset	145 st->print("%d %s", bci, Bytecodes::name(code));
a61af66fc99e Initial load duke parents: diff changeset	146 }
a61af66fc99e Initial load duke parents: diff changeset	147 _next_pc = is_wide() ? bcp+2 : bcp+1;
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	148 print_attributes(bci, st);
0 a61af66fc99e Initial load duke parents: diff changeset	149 bytecode_epilog(bci, st);
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151 };
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 // Implementation of BytecodeTracer
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 // %%% This set_closure thing seems overly general, given that
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	159 // would be easier to remove races on _current_method and bcp.
a61af66fc99e Initial load duke parents: diff changeset	160 // Since this is not product functionality, we can defer cleanup.
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 BytecodeClosure* BytecodeTracer::_closure = NULL;
a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 static BytecodePrinter std_closure;
a61af66fc99e Initial load duke parents: diff changeset	165 BytecodeClosure* BytecodeTracer::std_closure() {
a61af66fc99e Initial load duke parents: diff changeset	166 return &::std_closure;
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 void BytecodeTracer::trace(methodHandle method, address bcp, uintptr_t tos, uintptr_t tos2, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	171 if (TraceBytecodes && BytecodeCounter::counter_value() >= TraceBytecodesAt) {
a61af66fc99e Initial load duke parents: diff changeset	172 ttyLocker ttyl; // 5065316: keep the following output coherent
a61af66fc99e Initial load duke parents: diff changeset	173 // The ttyLocker also prevents races between two threads
a61af66fc99e Initial load duke parents: diff changeset	174 // trying to use the single instance of BytecodePrinter.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	177 // movement.
a61af66fc99e Initial load duke parents: diff changeset	178 //
a61af66fc99e Initial load duke parents: diff changeset	179 // There used to be a leaf mutex here, but the ttyLocker will
a61af66fc99e Initial load duke parents: diff changeset	180 // work just as well, as long as the printing operations never block.
a61af66fc99e Initial load duke parents: diff changeset	181 //
a61af66fc99e Initial load duke parents: diff changeset	182 // We put the locker on the static trace method, not the
a61af66fc99e Initial load duke parents: diff changeset	183 // virtual one, because the clients of this module go through
a61af66fc99e Initial load duke parents: diff changeset	184 // the static method.
a61af66fc99e Initial load duke parents: diff changeset	185 _closure->trace(method, bcp, tos, tos2, st);
a61af66fc99e Initial load duke parents: diff changeset	186 }
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 void BytecodeTracer::trace(methodHandle method, address bcp, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	190 ttyLocker ttyl; // 5065316: keep the following output coherent
a61af66fc99e Initial load duke parents: diff changeset	191 _closure->trace(method, bcp, st);
a61af66fc99e Initial load duke parents: diff changeset	192 }
a61af66fc99e Initial load duke parents: diff changeset	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 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	195 char buf[40];
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	196 int len = sym->utf8_length();
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	197 if (len >= (int)sizeof(buf)) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	198 st->print_cr(" %s...[%d]", sym->as_C_string(buf, sizeof(buf)), len);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	199 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	200 st->print(" ");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	201 sym->print_on(st); st->cr();
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	202 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	203 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	204
0 a61af66fc99e Initial load duke parents: diff changeset	205 void print_oop(oop value, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	206 if (value == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	207 st->print_cr(" NULL");
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	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 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	217 } else {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	218 st->print_cr(" " PTR_FORMAT, p2i((void *)value));
0 a61af66fc99e Initial load duke parents: diff changeset	219 }
a61af66fc99e Initial load duke parents: diff changeset	220 }
a61af66fc99e Initial load duke parents: diff changeset	221
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	273 #ifdef ASSERT
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	276 if (i >= CPCACHE_INDEX_TAG && i < climit + CPCACHE_INDEX_TAG) {
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	277 i -= CPCACHE_INDEX_TAG;
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	278 } else {
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	279 st->print_cr(" CP[%d] missing bias?", i);
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	280 return false;
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	281 }
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	282 }
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	287 st->print_cr("%d 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 {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	302 st->print_cr("%d 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 a61af66fc99e Initial load duke parents: diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	321 constantTag tag = constants->tag_at(i);
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 if (tag.is_int()) {
a61af66fc99e Initial load duke parents: diff changeset	324 st->print_cr(" " INT32_FORMAT, constants->int_at(i));
a61af66fc99e Initial load duke parents: diff changeset	325 } else if (tag.is_long()) {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	326 st->print_cr(" " INT64_FORMAT, (int64_t)(constants->long_at(i)));
0 a61af66fc99e Initial load duke parents: diff changeset	327 } else if (tag.is_float()) {
a61af66fc99e Initial load duke parents: diff changeset	328 st->print_cr(" %f", constants->float_at(i));
a61af66fc99e Initial load duke parents: diff changeset	329 } else if (tag.is_double()) {
a61af66fc99e Initial load duke parents: diff changeset	330 st->print_cr(" %f", constants->double_at(i));
a61af66fc99e Initial load duke parents: diff changeset	331 } else if (tag.is_string()) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	332 const char* string = constants->string_at_noresolve(i);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	333 st->print_cr(" %s", string);
0 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	336 } else if (tag.is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	337 st->print_cr(" <unresolved klass at %d>", i);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	338 } else if (tag.is_method_type()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	339 int i2 = constants->method_type_index_at(i);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	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 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	342 } else if (tag.is_method_handle()) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	343 int kind = constants->method_handle_ref_kind_at(i);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	344 int i2 = constants->method_handle_index_at(i);
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	345 st->print(" <MethodHandle of kind %d index at %d>", kind, i2);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	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 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	354 if (!check_index(orig_i, i, st)) return;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	355 print_field_or_method(orig_i, i, st);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	356 }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	357
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	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 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392
a61af66fc99e Initial load duke parents: diff changeset	393
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	394 PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	395 void BytecodePrinter::print_attributes(int bci, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	396 // Show attributes of pre-rewritten codes
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	397 Bytecodes::Code code = Bytecodes::java_code(raw_code());
0 a61af66fc99e Initial load duke parents: diff changeset	398 // If the code doesn't have any fields there's nothing to print.
a61af66fc99e Initial load duke parents: diff changeset	399 // note this is ==1 because the tableswitch and lookupswitch are
a61af66fc99e Initial load duke parents: diff changeset	400 // zero size (for some reason) and we want to print stuff out for them.
a61af66fc99e Initial load duke parents: diff changeset	401 if (Bytecodes::length_for(code) == 1) {
a61af66fc99e Initial load duke parents: diff changeset	402 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	403 return;
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 switch(code) {
a61af66fc99e Initial load duke parents: diff changeset	407 // Java specific bytecodes only matter.
a61af66fc99e Initial load duke parents: diff changeset	408 case Bytecodes::_bipush:
a61af66fc99e Initial load duke parents: diff changeset	409 st->print_cr(" " INT32_FORMAT, get_byte());
a61af66fc99e Initial load duke parents: diff changeset	410 break;
a61af66fc99e Initial load duke parents: diff changeset	411 case Bytecodes::_sipush:
a61af66fc99e Initial load duke parents: diff changeset	412 st->print_cr(" " INT32_FORMAT, get_short());
a61af66fc99e Initial load duke parents: diff changeset	413 break;
a61af66fc99e Initial load duke parents: diff changeset	414 case Bytecodes::_ldc:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	415 if (Bytecodes::uses_cp_cache(raw_code())) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	416 print_constant(get_index_u1_cpcache(), st);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	417 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	418 print_constant(get_index_u1(), st);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	419 }
0 a61af66fc99e Initial load duke parents: diff changeset	420 break;
a61af66fc99e Initial load duke parents: diff changeset	421
a61af66fc99e Initial load duke parents: diff changeset	422 case Bytecodes::_ldc_w:
a61af66fc99e Initial load duke parents: diff changeset	423 case Bytecodes::_ldc2_w:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	424 if (Bytecodes::uses_cp_cache(raw_code())) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	425 print_constant(get_index_u2_cpcache(), st);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	426 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	427 print_constant(get_index_u2(), st);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	428 }
0 a61af66fc99e Initial load duke parents: diff changeset	429 break;
a61af66fc99e Initial load duke parents: diff changeset	430
a61af66fc99e Initial load duke parents: diff changeset	431 case Bytecodes::_iload:
a61af66fc99e Initial load duke parents: diff changeset	432 case Bytecodes::_lload:
a61af66fc99e Initial load duke parents: diff changeset	433 case Bytecodes::_fload:
a61af66fc99e Initial load duke parents: diff changeset	434 case Bytecodes::_dload:
a61af66fc99e Initial load duke parents: diff changeset	435 case Bytecodes::_aload:
a61af66fc99e Initial load duke parents: diff changeset	436 case Bytecodes::_istore:
a61af66fc99e Initial load duke parents: diff changeset	437 case Bytecodes::_lstore:
a61af66fc99e Initial load duke parents: diff changeset	438 case Bytecodes::_fstore:
a61af66fc99e Initial load duke parents: diff changeset	439 case Bytecodes::_dstore:
a61af66fc99e Initial load duke parents: diff changeset	440 case Bytecodes::_astore:
a61af66fc99e Initial load duke parents: diff changeset	441 st->print_cr(" #%d", get_index_special());
a61af66fc99e Initial load duke parents: diff changeset	442 break;
a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 case Bytecodes::_iinc:
a61af66fc99e Initial load duke parents: diff changeset	445 { int index = get_index_special();
a61af66fc99e Initial load duke parents: diff changeset	446 jint offset = is_wide() ? get_short(): get_byte();
a61af66fc99e Initial load duke parents: diff changeset	447 st->print_cr(" #%d " INT32_FORMAT, index, offset);
a61af66fc99e Initial load duke parents: diff changeset	448 }
a61af66fc99e Initial load duke parents: diff changeset	449 break;
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 case Bytecodes::_newarray: {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	452 BasicType atype = (BasicType)get_index_u1();
0 a61af66fc99e Initial load duke parents: diff changeset	453 const char* str = type2name(atype);
a61af66fc99e Initial load duke parents: diff changeset	454 if (str == NULL \|\| atype == T_OBJECT \|\| atype == T_ARRAY) {
a61af66fc99e Initial load duke parents: diff changeset	455 assert(false, "Unidentified basic type");
a61af66fc99e Initial load duke parents: diff changeset	456 }
a61af66fc99e Initial load duke parents: diff changeset	457 st->print_cr(" %s", str);
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459 break;
a61af66fc99e Initial load duke parents: diff changeset	460 case Bytecodes::_anewarray: {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	461 int klass_index = get_index_u2();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4042 diff changeset	462 ConstantPool* constants = method()->constants();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	463 Symbol* name = constants->klass_name_at(klass_index);
0 a61af66fc99e Initial load duke parents: diff changeset	464 st->print_cr(" %s ", name->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	465 }
a61af66fc99e Initial load duke parents: diff changeset	466 break;
a61af66fc99e Initial load duke parents: diff changeset	467 case Bytecodes::_multianewarray: {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	468 int klass_index = get_index_u2();
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	469 int nof_dims = get_index_u1();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4042 diff changeset	470 ConstantPool* constants = method()->constants();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	471 Symbol* name = constants->klass_name_at(klass_index);
0 a61af66fc99e Initial load duke parents: diff changeset	472 st->print_cr(" %s %d", name->as_C_string(), nof_dims);
a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474 break;
a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 case Bytecodes::_ifeq:
a61af66fc99e Initial load duke parents: diff changeset	477 case Bytecodes::_ifnull:
a61af66fc99e Initial load duke parents: diff changeset	478 case Bytecodes::_iflt:
a61af66fc99e Initial load duke parents: diff changeset	479 case Bytecodes::_ifle:
a61af66fc99e Initial load duke parents: diff changeset	480 case Bytecodes::_ifne:
a61af66fc99e Initial load duke parents: diff changeset	481 case Bytecodes::_ifnonnull:
a61af66fc99e Initial load duke parents: diff changeset	482 case Bytecodes::_ifgt:
a61af66fc99e Initial load duke parents: diff changeset	483 case Bytecodes::_ifge:
a61af66fc99e Initial load duke parents: diff changeset	484 case Bytecodes::_if_icmpeq:
a61af66fc99e Initial load duke parents: diff changeset	485 case Bytecodes::_if_icmpne:
a61af66fc99e Initial load duke parents: diff changeset	486 case Bytecodes::_if_icmplt:
a61af66fc99e Initial load duke parents: diff changeset	487 case Bytecodes::_if_icmpgt:
a61af66fc99e Initial load duke parents: diff changeset	488 case Bytecodes::_if_icmple:
a61af66fc99e Initial load duke parents: diff changeset	489 case Bytecodes::_if_icmpge:
a61af66fc99e Initial load duke parents: diff changeset	490 case Bytecodes::_if_acmpeq:
a61af66fc99e Initial load duke parents: diff changeset	491 case Bytecodes::_if_acmpne:
a61af66fc99e Initial load duke parents: diff changeset	492 case Bytecodes::_goto:
a61af66fc99e Initial load duke parents: diff changeset	493 case Bytecodes::_jsr:
a61af66fc99e Initial load duke parents: diff changeset	494 st->print_cr(" %d", bci + get_short());
a61af66fc99e Initial load duke parents: diff changeset	495 break;
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 case Bytecodes::_goto_w:
a61af66fc99e Initial load duke parents: diff changeset	498 case Bytecodes::_jsr_w:
a61af66fc99e Initial load duke parents: diff changeset	499 st->print_cr(" %d", bci + get_int());
a61af66fc99e Initial load duke parents: diff changeset	500 break;
a61af66fc99e Initial load duke parents: diff changeset	501
a61af66fc99e Initial load duke parents: diff changeset	502 case Bytecodes::_ret: st->print_cr(" %d", get_index_special()); break;
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 case Bytecodes::_tableswitch:
a61af66fc99e Initial load duke parents: diff changeset	505 { align();
a61af66fc99e Initial load duke parents: diff changeset	506 int default_dest = bci + get_int();
a61af66fc99e Initial load duke parents: diff changeset	507 int lo = get_int();
a61af66fc99e Initial load duke parents: diff changeset	508 int hi = get_int();
a61af66fc99e Initial load duke parents: diff changeset	509 int len = hi - lo + 1;
a61af66fc99e Initial load duke parents: diff changeset	510 jint* dest = NEW_RESOURCE_ARRAY(jint, len);
a61af66fc99e Initial load duke parents: diff changeset	511 for (int i = 0; i < len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	512 dest[i] = bci + get_int();
a61af66fc99e Initial load duke parents: diff changeset	513 }
a61af66fc99e Initial load duke parents: diff changeset	514 st->print(" %d " INT32_FORMAT " " INT32_FORMAT " ",
a61af66fc99e Initial load duke parents: diff changeset	515 default_dest, lo, hi);
a61af66fc99e Initial load duke parents: diff changeset	516 int first = true;
a61af66fc99e Initial load duke parents: diff changeset	517 for (int ll = lo; ll <= hi; ll++, first = false) {
a61af66fc99e Initial load duke parents: diff changeset	518 int idx = ll - lo;
a61af66fc99e Initial load duke parents: diff changeset	519 const char *format = first ? " %d:" INT32_FORMAT " (delta: %d)" :
a61af66fc99e Initial load duke parents: diff changeset	520 ", %d:" INT32_FORMAT " (delta: %d)";
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	521 PRAGMA_DIAG_PUSH
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	522 PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL
0 a61af66fc99e Initial load duke parents: diff changeset	523 st->print(format, ll, dest[idx], dest[idx]-bci);
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	524 PRAGMA_DIAG_POP
0 a61af66fc99e Initial load duke parents: diff changeset	525 }
a61af66fc99e Initial load duke parents: diff changeset	526 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528 break;
a61af66fc99e Initial load duke parents: diff changeset	529 case Bytecodes::_lookupswitch:
a61af66fc99e Initial load duke parents: diff changeset	530 { align();
a61af66fc99e Initial load duke parents: diff changeset	531 int default_dest = bci + get_int();
a61af66fc99e Initial load duke parents: diff changeset	532 int len = get_int();
a61af66fc99e Initial load duke parents: diff changeset	533 jint* key = NEW_RESOURCE_ARRAY(jint, len);
a61af66fc99e Initial load duke parents: diff changeset	534 jint* dest = NEW_RESOURCE_ARRAY(jint, len);
a61af66fc99e Initial load duke parents: diff changeset	535 for (int i = 0; i < len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	536 key [i] = get_int();
a61af66fc99e Initial load duke parents: diff changeset	537 dest[i] = bci + get_int();
a61af66fc99e Initial load duke parents: diff changeset	538 };
a61af66fc99e Initial load duke parents: diff changeset	539 st->print(" %d %d ", default_dest, len);
a61af66fc99e Initial load duke parents: diff changeset	540 bool first = true;
a61af66fc99e Initial load duke parents: diff changeset	541 for (int ll = 0; ll < len; ll++, first = false) {
a61af66fc99e Initial load duke parents: diff changeset	542 const char *format = first ? " " INT32_FORMAT ":" INT32_FORMAT :
a61af66fc99e Initial load duke parents: diff changeset	543 ", " INT32_FORMAT ":" INT32_FORMAT ;
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	544 PRAGMA_DIAG_PUSH
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	545 PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL
0 a61af66fc99e Initial load duke parents: diff changeset	546 st->print(format, key[ll], dest[ll]);
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17728 diff changeset	547 PRAGMA_DIAG_POP
0 a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	550 }
a61af66fc99e Initial load duke parents: diff changeset	551 break;
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 case Bytecodes::_putstatic:
a61af66fc99e Initial load duke parents: diff changeset	554 case Bytecodes::_getstatic:
a61af66fc99e Initial load duke parents: diff changeset	555 case Bytecodes::_putfield:
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	556 case Bytecodes::_getfield:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	557 print_field_or_method(get_index_u2_cpcache(), st);
0 a61af66fc99e Initial load duke parents: diff changeset	558 break;
a61af66fc99e Initial load duke parents: diff changeset	559
a61af66fc99e Initial load duke parents: diff changeset	560 case Bytecodes::_invokevirtual:
a61af66fc99e Initial load duke parents: diff changeset	561 case Bytecodes::_invokespecial:
a61af66fc99e Initial load duke parents: diff changeset	562 case Bytecodes::_invokestatic:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	563 print_field_or_method(get_index_u2_cpcache(), st);
0 a61af66fc99e Initial load duke parents: diff changeset	564 break;
a61af66fc99e Initial load duke parents: diff changeset	565
a61af66fc99e Initial load duke parents: diff changeset	566 case Bytecodes::_invokeinterface:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	567 { int i = get_index_u2_cpcache();
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	568 int n = get_index_u1();
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	569 get_byte(); // ignore zero byte
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	570 print_field_or_method(i, st);
0 a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572 break;
a61af66fc99e Initial load duke parents: diff changeset	573
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	574 case Bytecodes::_invokedynamic:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	575 print_field_or_method(get_index_u4(), st);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	576 break;
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 0 diff changeset	577
0 a61af66fc99e Initial load duke parents: diff changeset	578 case Bytecodes::_new:
a61af66fc99e Initial load duke parents: diff changeset	579 case Bytecodes::_checkcast:
a61af66fc99e Initial load duke parents: diff changeset	580 case Bytecodes::_instanceof:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	581 { int i = get_index_u2();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4042 diff changeset	582 ConstantPool* constants = method()->constants();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2142 diff changeset	583 Symbol* name = constants->klass_name_at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	584 st->print_cr(" %d <%s>", i, name->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586 break;
a61af66fc99e Initial load duke parents: diff changeset	587
a61af66fc99e Initial load duke parents: diff changeset	588 case Bytecodes::_wide:
a61af66fc99e Initial load duke parents: diff changeset	589 // length is zero not one, but printed with no more info.
a61af66fc99e Initial load duke parents: diff changeset	590 break;
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 default:
a61af66fc99e Initial load duke parents: diff changeset	593 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	594 break;
a61af66fc99e Initial load duke parents: diff changeset	595 }
a61af66fc99e Initial load duke parents: diff changeset	596 }
a61af66fc99e Initial load duke parents: diff changeset	597
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 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	600 MethodData* mdo = method()->method_data();
0 a61af66fc99e Initial load duke parents: diff changeset	601 if (mdo != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	602 ProfileData* data = mdo->bci_to_data(bci);
a61af66fc99e Initial load duke parents: diff changeset	603 if (data != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	604 st->print(" %d", mdo->dp_to_di(data->dp()));
a61af66fc99e Initial load duke parents: diff changeset	605 st->fill_to(6);
17728 b8413a9cbb84 8031752: Failed speculative optimizations should be reattempted when root of compilation is different roland parents: 12316 diff changeset	606 data->print_data_on(st, mdo);
0 a61af66fc99e Initial load duke parents: diff changeset	607 }
a61af66fc99e Initial load duke parents: diff changeset	608 }
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610 #endif // PRODUCT

Mercurial > hg > truffle

annotate src/share/vm/interpreter/bytecodeTracer.cpp @ 20543:e7d0505c8a30