Mercurial > hg > truffle
annotate src/share/vm/ci/ciStreams.hpp @ 844:bd02caa94611
6862919: Update copyright year
Summary: Update copyright for files that have been modified in 2009, up to 07/09
Reviewed-by: tbell, ohair
| author | xdono |
|---|---|
| date | Tue, 28 Jul 2009 12:12:40 -0700 |
| parents | be93aad57795 |
| children | 97125851f396 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 844 | 2 * Copyright 1999-2009 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // ciBytecodeStream | |
| 26 // | |
| 27 // The class is used to iterate over the bytecodes of a method. | |
| 28 // It hides the details of constant pool structure/access by | |
| 29 // providing accessors for constant pool items. It returns only pure | |
| 30 // Java bytecodes; VM-internal _fast bytecodes are translated back to | |
| 31 // their original form during iteration. | |
| 32 class ciBytecodeStream : StackObj { | |
| 33 private: | |
| 34 // Handling for the weird bytecodes | |
| 35 Bytecodes::Code wide(); // Handle wide bytecode | |
| 36 Bytecodes::Code table(Bytecodes::Code); // Handle complicated inline table | |
| 37 | |
| 38 static Bytecodes::Code check_java(Bytecodes::Code c) { | |
| 39 assert(Bytecodes::is_java_code(c), "should not return _fast bytecodes"); | |
| 40 return c; | |
| 41 } | |
| 42 | |
| 43 ciMethod* _method; // the method | |
| 44 ciInstanceKlass* _holder; | |
| 45 address _bc_start; // Start of current bytecode for table | |
| 46 address _was_wide; // Address past last wide bytecode | |
| 47 jint* _table_base; // Aligned start of last table or switch | |
| 48 | |
| 49 address _start; // Start of bytecodes | |
| 50 address _end; // Past end of bytecodes | |
| 51 address _pc; // Current PC | |
| 52 Bytecodes::Code _bc; // Current bytecode | |
| 53 | |
| 54 void reset( address base, unsigned int size ) { | |
| 55 _bc_start =_was_wide = 0; | |
| 56 _start = _pc = base; _end = base + size; } | |
| 57 | |
| 58 public: | |
| 59 // End-Of-Bytecodes | |
| 60 static Bytecodes::Code EOBC() { | |
| 61 return Bytecodes::_illegal; | |
| 62 } | |
| 63 | |
| 64 ciBytecodeStream(ciMethod* m) { | |
| 65 reset_to_method(m); | |
| 66 } | |
| 67 | |
| 68 ciBytecodeStream() { | |
| 69 reset_to_method(NULL); | |
| 70 } | |
| 71 | |
| 72 ciMethod* method() const { return _method; } | |
| 73 | |
| 74 void reset_to_method(ciMethod* m) { | |
| 75 _method = m; | |
| 76 if (m == NULL) { | |
| 77 _holder = NULL; | |
| 78 reset(NULL, 0); | |
| 79 } else { | |
| 80 _holder = m->holder(); | |
| 81 reset(m->code(), m->code_size()); | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 void reset_to_bci( int bci ); | |
| 86 | |
| 87 // Force the iterator to report a certain bci. | |
| 88 void force_bci(int bci); | |
| 89 | |
| 90 void set_max_bci( int max ) { | |
| 91 _end = _start + max; | |
| 92 } | |
| 93 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
94 address cur_bcp() const { return _bc_start; } // Returns bcp to current instruction |
| 0 | 95 int next_bci() const { return _pc -_start; } |
| 96 int cur_bci() const { return _bc_start - _start; } | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
97 int instruction_size() const { return _pc - _bc_start; } |
| 0 | 98 |
| 99 Bytecodes::Code cur_bc() const{ return check_java(_bc); } | |
| 100 Bytecodes::Code next_bc() { return Bytecodes::java_code((Bytecodes::Code)* _pc); } | |
| 101 | |
| 102 // Return current ByteCode and increment PC to next bytecode, skipping all | |
| 103 // intermediate constants. Returns EOBC at end. | |
| 104 // Expected usage: | |
| 105 // while( (bc = iter.next()) != EOBC() ) { ... } | |
| 106 Bytecodes::Code next() { | |
| 107 _bc_start = _pc; // Capture start of bc | |
| 108 if( _pc >= _end ) return EOBC(); // End-Of-Bytecodes | |
| 109 | |
| 110 // Fetch Java bytecode | |
| 111 // All rewritten bytecodes maintain the size of original bytecode. | |
| 112 _bc = Bytecodes::java_code((Bytecodes::Code)*_pc); | |
| 113 int csize = Bytecodes::length_for(_bc); // Expected size | |
| 114 | |
| 115 if( _bc == Bytecodes::_wide ) { | |
| 116 _bc=wide(); // Handle wide bytecode | |
| 117 } else if( csize == 0 ) { | |
| 118 _bc=table(_bc); // Handle inline tables | |
| 119 } else { | |
| 120 _pc += csize; // Bump PC past bytecode | |
| 121 } | |
| 122 return check_java(_bc); | |
| 123 } | |
| 124 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
125 bool is_wide() const { return ( _pc == _was_wide ); } |
| 0 | 126 |
| 127 // Get a byte index following this bytecode. | |
| 128 // If prefixed with a wide bytecode, get a wide index. | |
| 129 int get_index() const { | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
130 assert_index_size(is_wide() ? 2 : 1); |
| 0 | 131 return (_pc == _was_wide) // was widened? |
| 132 ? Bytes::get_Java_u2(_bc_start+2) // yes, return wide index | |
| 133 : _bc_start[1]; // no, return narrow index | |
| 134 } | |
| 135 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
136 // Get 2-byte index (getfield/putstatic/etc) |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
137 int get_index_big() const { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
138 assert_index_size(2); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
139 return Bytes::get_Java_u2(_bc_start+1); |
| 0 | 140 } |
| 141 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
142 // Get 2-byte index (or 4-byte, for invokedynamic) |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
143 int get_index_int() const { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
144 return has_giant_index() ? get_index_giant() : get_index_big(); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
145 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
146 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
147 // Get 4-byte index, for invokedynamic. |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
148 int get_index_giant() const { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
149 assert_index_size(4); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
150 return Bytes::get_native_u4(_bc_start+1); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
151 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
152 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
153 bool has_giant_index() const { return (cur_bc() == Bytecodes::_invokedynamic); } |
| 0 | 154 |
| 155 // Get dimensions byte (multinewarray) | |
| 156 int get_dimensions() const { return *(unsigned char*)(_pc-1); } | |
| 157 | |
| 158 // Sign-extended index byte/short, no widening | |
| 159 int get_byte() const { return (int8_t)(_pc[-1]); } | |
| 160 int get_short() const { return (int16_t)Bytes::get_Java_u2(_pc-2); } | |
| 161 int get_long() const { return (int32_t)Bytes::get_Java_u4(_pc-4); } | |
| 162 | |
| 163 // Get a byte signed constant for "iinc". Invalid for other bytecodes. | |
| 164 // If prefixed with a wide bytecode, get a wide constant | |
| 165 int get_iinc_con() const {return (_pc==_was_wide) ? get_short() :get_byte();} | |
| 166 | |
| 167 // 2-byte branch offset from current pc | |
| 168 int get_dest( ) const { | |
| 169 assert( Bytecodes::length_at(_bc_start) == sizeof(jshort)+1, "get_dest called with bad bytecode" ); | |
| 170 return _bc_start-_start + (short)Bytes::get_Java_u2(_pc-2); | |
| 171 } | |
| 172 | |
| 173 // 2-byte branch offset from next pc | |
| 174 int next_get_dest( ) const { | |
| 175 address next_bc_start = _pc; | |
| 176 assert( _pc < _end, "" ); | |
| 177 Bytecodes::Code next_bc = (Bytecodes::Code)*_pc; | |
| 178 assert( next_bc != Bytecodes::_wide, ""); | |
| 179 int next_csize = Bytecodes::length_for(next_bc); | |
| 180 assert( next_csize != 0, "" ); | |
| 181 assert( next_bc <= Bytecodes::_jsr_w, ""); | |
| 182 address next_pc = _pc + next_csize; | |
| 183 assert( Bytecodes::length_at(next_bc_start) == sizeof(jshort)+1, "next_get_dest called with bad bytecode" ); | |
| 184 return next_bc_start-_start + (short)Bytes::get_Java_u2(next_pc-2); | |
| 185 } | |
| 186 | |
| 187 // 4-byte branch offset from current pc | |
| 188 int get_far_dest( ) const { | |
| 189 assert( Bytecodes::length_at(_bc_start) == sizeof(jint)+1, "dest4 called with bad bytecode" ); | |
| 190 return _bc_start-_start + (int)Bytes::get_Java_u4(_pc-4); | |
| 191 } | |
| 192 | |
| 193 // For a lookup or switch table, return target destination | |
| 194 int get_int_table( int index ) const { | |
| 195 return Bytes::get_Java_u4((address)&_table_base[index]); } | |
| 196 | |
| 197 // For tableswitch - get length of offset part | |
| 198 int get_tableswitch_length() { return get_int_table(2)-get_int_table(1)+1; } | |
| 199 | |
| 200 int get_dest_table( int index ) const { | |
| 201 return cur_bci() + get_int_table(index); } | |
| 202 | |
| 203 // --- Constant pool access --- | |
| 204 int get_constant_index() const; | |
| 205 int get_field_index(); | |
| 206 int get_method_index(); | |
| 207 | |
| 208 // If this bytecode is a new, newarray, multianewarray, instanceof, | |
| 209 // or checkcast, get the referenced klass. | |
| 210 ciKlass* get_klass(bool& will_link); | |
| 211 int get_klass_index() const; | |
| 212 | |
| 213 // If this bytecode is one of the ldc variants, get the referenced | |
| 214 // constant | |
| 215 ciConstant get_constant(); | |
| 216 // True if the ldc variant points to an unresolved string | |
| 217 bool is_unresolved_string() const; | |
| 218 // True if the ldc variant points to an unresolved klass | |
| 219 bool is_unresolved_klass() const; | |
| 220 | |
| 221 // If this bytecode is one of get_field, get_static, put_field, | |
| 222 // or put_static, get the referenced field. | |
| 223 ciField* get_field(bool& will_link); | |
| 224 | |
| 225 ciInstanceKlass* get_declared_field_holder(); | |
| 226 int get_field_holder_index(); | |
| 227 int get_field_signature_index(); | |
| 228 | |
| 229 // If this is a method invocation bytecode, get the invoked method. | |
| 230 ciMethod* get_method(bool& will_link); | |
| 231 ciKlass* get_declared_method_holder(); | |
| 232 int get_method_holder_index(); | |
| 233 int get_method_signature_index(); | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
234 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
235 private: |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
236 void assert_index_size(int required_size) const { |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
237 #ifdef ASSERT |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
238 int isize = instruction_size() - (is_wide() ? 1 : 0) - 1; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
239 if (isize == 2 && cur_bc() == Bytecodes::_iinc) |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
240 isize = 1; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
241 else if (isize <= 2) |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
242 ; // no change |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
243 else if (has_giant_index()) |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
244 isize = 4; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
245 else |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
246 isize = 2; |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
247 assert(isize = required_size, "wrong index size"); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
248 #endif |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
0
diff
changeset
|
249 } |
| 0 | 250 }; |
| 251 | |
| 252 | |
| 253 // ciSignatureStream | |
| 254 // | |
| 255 // The class is used to iterate over the elements of a method signature. | |
| 256 class ciSignatureStream : public StackObj { | |
| 257 private: | |
| 258 ciSignature* _sig; | |
| 259 int _pos; | |
| 260 public: | |
| 261 ciSignatureStream(ciSignature* signature) { | |
| 262 _sig = signature; | |
| 263 _pos = 0; | |
| 264 } | |
| 265 | |
| 266 bool at_return_type() { return _pos == _sig->count(); } | |
| 267 | |
| 268 bool is_done() { return _pos > _sig->count(); } | |
| 269 | |
| 270 void next() { | |
| 271 if (_pos <= _sig->count()) { | |
| 272 _pos++; | |
| 273 } | |
| 274 } | |
| 275 | |
| 276 ciType* type() { | |
| 277 if (at_return_type()) { | |
| 278 return _sig->return_type(); | |
| 279 } else { | |
| 280 return _sig->type_at(_pos); | |
| 281 } | |
| 282 } | |
| 283 }; | |
| 284 | |
| 285 | |
| 286 // ciExceptionHandlerStream | |
| 287 // | |
| 288 // The class is used to iterate over the exception handlers of | |
| 289 // a method. | |
| 290 class ciExceptionHandlerStream : public StackObj { | |
| 291 private: | |
| 292 // The method whose handlers we are traversing | |
| 293 ciMethod* _method; | |
| 294 | |
| 295 // Our current position in the list of handlers | |
| 296 int _pos; | |
| 297 int _end; | |
| 298 | |
| 299 ciInstanceKlass* _exception_klass; | |
| 300 int _bci; | |
| 301 bool _is_exact; | |
| 302 | |
| 303 public: | |
| 304 ciExceptionHandlerStream(ciMethod* method) { | |
| 305 _method = method; | |
| 306 | |
| 307 // Force loading of method code and handlers. | |
| 308 _method->code(); | |
| 309 | |
| 310 _pos = 0; | |
| 311 _end = _method->_handler_count; | |
| 312 _exception_klass = NULL; | |
| 313 _bci = -1; | |
| 314 _is_exact = false; | |
| 315 } | |
| 316 | |
| 317 ciExceptionHandlerStream(ciMethod* method, int bci, | |
| 318 ciInstanceKlass* exception_klass = NULL, | |
| 319 bool is_exact = false) { | |
| 320 _method = method; | |
| 321 | |
| 322 // Force loading of method code and handlers. | |
| 323 _method->code(); | |
| 324 | |
| 325 _pos = -1; | |
| 326 _end = _method->_handler_count + 1; // include the rethrow handler | |
| 327 _exception_klass = (exception_klass != NULL && exception_klass->is_loaded() | |
| 328 ? exception_klass | |
| 329 : NULL); | |
| 330 _bci = bci; | |
| 331 assert(_bci >= 0, "bci out of range"); | |
| 332 _is_exact = is_exact; | |
| 333 next(); | |
| 334 } | |
| 335 | |
| 336 // These methods are currently implemented in an odd way. | |
| 337 // Count the number of handlers the iterator has ever produced | |
| 338 // or will ever produce. Do not include the final rethrow handler. | |
| 339 // That is, a trivial exception handler stream will have a count | |
| 340 // of zero and produce just the rethrow handler. | |
| 341 int count(); | |
| 342 | |
| 343 // Count the number of handlers this stream will produce from now on. | |
| 344 // Include the current handler, and the final rethrow handler. | |
| 345 // The remaining count will be zero iff is_done() is true, | |
| 346 int count_remaining(); | |
| 347 | |
| 348 bool is_done() { | |
| 349 return (_pos >= _end); | |
| 350 } | |
| 351 | |
| 352 void next() { | |
| 353 _pos++; | |
| 354 if (_bci != -1) { | |
| 355 // We are not iterating over all handlers... | |
| 356 while (!is_done()) { | |
| 357 ciExceptionHandler* handler = _method->_exception_handlers[_pos]; | |
| 358 if (handler->is_in_range(_bci)) { | |
| 359 if (handler->is_catch_all()) { | |
| 360 // Found final active catch block. | |
| 361 _end = _pos+1; | |
| 362 return; | |
| 363 } else if (_exception_klass == NULL || !handler->catch_klass()->is_loaded()) { | |
| 364 // We cannot do any type analysis here. Must conservatively assume | |
| 365 // catch block is reachable. | |
| 366 return; | |
| 367 } else if (_exception_klass->is_subtype_of(handler->catch_klass())) { | |
| 368 // This catch clause will definitely catch the exception. | |
| 369 // Final candidate. | |
| 370 _end = _pos+1; | |
| 371 return; | |
| 372 } else if (!_is_exact && | |
| 373 handler->catch_klass()->is_subtype_of(_exception_klass)) { | |
| 374 // This catch block may be reachable. | |
| 375 return; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 // The catch block was not pertinent. Go on. | |
| 380 _pos++; | |
| 381 } | |
| 382 } else { | |
| 383 // This is an iteration over all handlers. | |
| 384 return; | |
| 385 } | |
| 386 } | |
| 387 | |
| 388 ciExceptionHandler* handler() { | |
| 389 return _method->_exception_handlers[_pos]; | |
| 390 } | |
| 391 }; |