Mercurial > hg > graal-compiler
annotate src/share/vm/interpreter/bytecodeStream.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | da91efe96a93 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
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:
844
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP |
| 26 #define SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP | |
| 27 | |
| 28 #include "interpreter/bytecode.hpp" | |
| 29 #include "memory/allocation.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2192
diff
changeset
|
30 #include "oops/method.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2192
diff
changeset
|
31 #include "runtime/handles.inline.hpp" |
| 1972 | 32 #ifdef TARGET_ARCH_x86 |
| 33 # include "bytes_x86.hpp" | |
| 34 #endif | |
| 35 #ifdef TARGET_ARCH_sparc | |
| 36 # include "bytes_sparc.hpp" | |
| 37 #endif | |
| 38 #ifdef TARGET_ARCH_zero | |
| 39 # include "bytes_zero.hpp" | |
| 40 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
41 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
42 # include "bytes_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
43 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
44 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
45 # include "bytes_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2142
diff
changeset
|
46 #endif |
| 1972 | 47 |
| 0 | 48 // A BytecodeStream is used for fast iteration over the bytecodes |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2192
diff
changeset
|
49 // of a Method*. |
| 0 | 50 // |
| 51 // Usage: | |
| 52 // | |
| 53 // BytecodeStream s(method); | |
| 54 // Bytecodes::Code c; | |
| 55 // while ((c = s.next()) >= 0) { | |
| 56 // ... | |
| 57 // } | |
| 1565 | 58 |
| 0 | 59 // A RawBytecodeStream is a simple version of BytecodeStream. |
| 60 // It is used ONLY when we know the bytecodes haven't been rewritten | |
| 1565 | 61 // yet, such as in the rewriter or the verifier. |
| 0 | 62 |
| 1565 | 63 // Here is the common base class for both RawBytecodeStream and BytecodeStream: |
| 64 class BaseBytecodeStream: StackObj { | |
| 0 | 65 protected: |
| 66 // stream buffer | |
| 67 methodHandle _method; // read from method directly | |
| 68 | |
| 69 // reading position | |
| 70 int _bci; // bci if current bytecode | |
| 71 int _next_bci; // bci of next bytecode | |
| 72 int _end_bci; // bci after the current iteration interval | |
| 73 | |
| 74 // last bytecode read | |
| 1565 | 75 Bytecodes::Code _raw_code; |
| 0 | 76 bool _is_wide; |
| 1565 | 77 bool _is_raw; // false in 'cooked' BytecodeStream |
| 78 | |
| 79 // Construction | |
| 80 BaseBytecodeStream(methodHandle method) : _method(method) { | |
| 81 set_interval(0, _method->code_size()); | |
| 82 _is_raw = false; | |
| 83 } | |
| 0 | 84 |
| 85 public: | |
| 86 // Iteration control | |
| 87 void set_interval(int beg_bci, int end_bci) { | |
| 88 // iterate over the interval [beg_bci, end_bci) | |
| 89 assert(0 <= beg_bci && beg_bci <= method()->code_size(), "illegal beg_bci"); | |
| 90 assert(0 <= end_bci && end_bci <= method()->code_size(), "illegal end_bci"); | |
| 91 // setup of iteration pointers | |
| 92 _bci = beg_bci; | |
| 93 _next_bci = beg_bci; | |
| 94 _end_bci = end_bci; | |
| 95 } | |
| 96 void set_start (int beg_bci) { | |
| 97 set_interval(beg_bci, _method->code_size()); | |
| 98 } | |
| 99 | |
| 1565 | 100 bool is_raw() const { return _is_raw; } |
| 101 | |
| 102 // Stream attributes | |
| 103 methodHandle method() const { return _method; } | |
| 104 | |
| 105 int bci() const { return _bci; } | |
| 106 int next_bci() const { return _next_bci; } | |
| 107 int end_bci() const { return _end_bci; } | |
| 108 | |
| 109 Bytecodes::Code raw_code() const { return _raw_code; } | |
| 110 bool is_wide() const { return _is_wide; } | |
| 111 int instruction_size() const { return (_next_bci - _bci); } | |
| 112 bool is_last_bytecode() const { return _next_bci >= _end_bci; } | |
| 113 | |
| 114 address bcp() const { return method()->code_base() + _bci; } | |
| 2142 | 115 Bytecode bytecode() const { return Bytecode(_method(), bcp()); } |
| 1565 | 116 |
| 117 // State changes | |
| 118 void set_next_bci(int bci) { assert(0 <= bci && bci <= method()->code_size(), "illegal bci"); _next_bci = bci; } | |
| 119 | |
| 120 // Bytecode-specific attributes | |
| 2142 | 121 int dest() const { return bci() + bytecode().get_offset_s2(raw_code()); } |
| 122 int dest_w() const { return bci() + bytecode().get_offset_s4(raw_code()); } | |
| 1565 | 123 |
| 124 // One-byte indices. | |
| 125 int get_index_u1() const { assert_raw_index_size(1); return *(jubyte*)(bcp()+1); } | |
| 126 | |
| 127 protected: | |
| 128 void assert_raw_index_size(int size) const NOT_DEBUG_RETURN; | |
| 129 void assert_raw_stream(bool want_raw) const NOT_DEBUG_RETURN; | |
| 130 }; | |
| 131 | |
| 132 class RawBytecodeStream: public BaseBytecodeStream { | |
| 133 public: | |
| 134 // Construction | |
| 135 RawBytecodeStream(methodHandle method) : BaseBytecodeStream(method) { | |
| 136 _is_raw = true; | |
| 137 } | |
| 138 | |
| 139 public: | |
| 0 | 140 // Iteration |
| 141 // Use raw_next() rather than next() for faster method reference | |
| 142 Bytecodes::Code raw_next() { | |
| 143 Bytecodes::Code code; | |
| 144 // set reading position | |
| 145 _bci = _next_bci; | |
| 146 assert(!is_last_bytecode(), "caller should check is_last_bytecode()"); | |
| 147 | |
| 1565 | 148 address bcp = this->bcp(); |
| 0 | 149 code = Bytecodes::code_or_bp_at(bcp); |
| 150 | |
| 151 // set next bytecode position | |
| 152 int l = Bytecodes::length_for(code); | |
| 153 if (l > 0 && (_bci + l) <= _end_bci) { | |
| 154 assert(code != Bytecodes::_wide && code != Bytecodes::_tableswitch | |
| 155 && code != Bytecodes::_lookupswitch, "can't be special bytecode"); | |
| 156 _is_wide = false; | |
| 157 _next_bci += l; | |
| 1565 | 158 _raw_code = code; |
| 0 | 159 return code; |
| 160 } else { | |
| 161 return raw_next_special(code); | |
| 162 } | |
| 163 } | |
| 164 Bytecodes::Code raw_next_special(Bytecodes::Code code); | |
| 165 | |
| 1565 | 166 // Unsigned indices, widening, with no swapping of bytes |
| 167 int get_index() const { return (is_wide()) ? get_index_u2_raw(bcp() + 2) : get_index_u1(); } | |
| 168 // Get an unsigned 2-byte index, with no swapping of bytes. | |
| 169 int get_index_u2() const { assert(!is_wide(), ""); return get_index_u2_raw(bcp() + 1); } | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
170 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
171 private: |
| 1565 | 172 int get_index_u2_raw(address p) const { |
| 173 assert_raw_index_size(2); assert_raw_stream(true); | |
| 174 return Bytes::get_Java_u2(p); | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
175 } |
| 0 | 176 }; |
| 177 | |
| 178 // In BytecodeStream, non-java bytecodes will be translated into the | |
| 179 // corresponding java bytecodes. | |
| 180 | |
| 1565 | 181 class BytecodeStream: public BaseBytecodeStream { |
| 182 Bytecodes::Code _code; | |
| 183 | |
| 0 | 184 public: |
| 185 // Construction | |
| 1565 | 186 BytecodeStream(methodHandle method) : BaseBytecodeStream(method) { } |
| 0 | 187 |
| 188 // Iteration | |
| 189 Bytecodes::Code next() { | |
| 1565 | 190 Bytecodes::Code raw_code, code; |
| 0 | 191 // set reading position |
| 192 _bci = _next_bci; | |
| 193 if (is_last_bytecode()) { | |
| 194 // indicate end of bytecode stream | |
| 1565 | 195 raw_code = code = Bytecodes::_illegal; |
| 0 | 196 } else { |
| 197 // get bytecode | |
| 1565 | 198 address bcp = this->bcp(); |
| 2142 | 199 raw_code = Bytecodes::code_at(_method(), bcp); |
| 1565 | 200 code = Bytecodes::java_code(raw_code); |
| 0 | 201 // set next bytecode position |
| 202 // | |
| 203 // note that we cannot advance before having the | |
| 204 // tty bytecode otherwise the stepping is wrong! | |
| 205 // (carefull: length_for(...) must be used first!) | |
| 206 int l = Bytecodes::length_for(code); | |
| 2142 | 207 if (l == 0) l = Bytecodes::length_at(_method(), bcp); |
| 0 | 208 _next_bci += l; |
| 209 assert(_bci < _next_bci, "length must be > 0"); | |
| 210 // set attributes | |
| 211 _is_wide = false; | |
| 212 // check for special (uncommon) cases | |
| 213 if (code == Bytecodes::_wide) { | |
| 1565 | 214 raw_code = (Bytecodes::Code)bcp[1]; |
| 215 code = raw_code; // wide BCs are always Java-normal | |
| 0 | 216 _is_wide = true; |
| 217 } | |
| 218 assert(Bytecodes::is_java_code(code), "sanity check"); | |
| 219 } | |
| 1565 | 220 _raw_code = raw_code; |
| 0 | 221 _code = code; |
| 222 return _code; | |
| 223 } | |
| 224 | |
| 225 bool is_active_breakpoint() const { return Bytecodes::is_active_breakpoint_at(bcp()); } | |
| 1565 | 226 Bytecodes::Code code() const { return _code; } |
| 227 | |
| 228 // Unsigned indices, widening | |
| 2142 | 229 int get_index() const { return is_wide() ? bytecode().get_index_u2(raw_code(), true) : get_index_u1(); } |
| 1565 | 230 // Get an unsigned 2-byte index, swapping the bytes if necessary. |
| 231 int get_index_u2() const { assert_raw_stream(false); | |
| 2142 | 232 return bytecode().get_index_u2(raw_code(), false); } |
| 1565 | 233 // Get an unsigned 2-byte index in native order. |
| 234 int get_index_u2_cpcache() const { assert_raw_stream(false); | |
| 2142 | 235 return bytecode().get_index_u2_cpcache(raw_code()); } |
| 1565 | 236 int get_index_u4() const { assert_raw_stream(false); |
| 2142 | 237 return bytecode().get_index_u4(raw_code()); } |
| 238 bool has_index_u4() const { return bytecode().has_index_u4(raw_code()); } | |
| 0 | 239 }; |
| 1972 | 240 |
| 241 #endif // SHARE_VM_INTERPRETER_BYTECODESTREAM_HPP |