ciStreams.hpp revision 0:a61af66fc99e
1/* 2 * Copyright 1999-2005 Sun Microsystems, Inc. All Rights Reserved. 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. 32class ciBytecodeStream : StackObj { 33private: 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 58public: 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 94 address cur_bcp() { return _bc_start; } // Returns bcp to current instruction 95 int next_bci() const { return _pc -_start; } 96 int cur_bci() const { return _bc_start - _start; } 97 98 Bytecodes::Code cur_bc() const{ return check_java(_bc); } 99 Bytecodes::Code next_bc() { return Bytecodes::java_code((Bytecodes::Code)* _pc); } 100 101 // Return current ByteCode and increment PC to next bytecode, skipping all 102 // intermediate constants. Returns EOBC at end. 103 // Expected usage: 104 // while( (bc = iter.next()) != EOBC() ) { ... } 105 Bytecodes::Code next() { 106 _bc_start = _pc; // Capture start of bc 107 if( _pc >= _end ) return EOBC(); // End-Of-Bytecodes 108 109 // Fetch Java bytecode 110 // All rewritten bytecodes maintain the size of original bytecode. 111 _bc = Bytecodes::java_code((Bytecodes::Code)*_pc); 112 int csize = Bytecodes::length_for(_bc); // Expected size 113 114 if( _bc == Bytecodes::_wide ) { 115 _bc=wide(); // Handle wide bytecode 116 } else if( csize == 0 ) { 117 _bc=table(_bc); // Handle inline tables 118 } else { 119 _pc += csize; // Bump PC past bytecode 120 } 121 return check_java(_bc); 122 } 123 124 bool is_wide() { return ( _pc == _was_wide ); } 125 126 // Get a byte index following this bytecode. 127 // If prefixed with a wide bytecode, get a wide index. 128 int get_index() const { 129 return (_pc == _was_wide) // was widened? 130 ? Bytes::get_Java_u2(_bc_start+2) // yes, return wide index 131 : _bc_start[1]; // no, return narrow index 132 } 133 134 // Set a byte index following this bytecode. 135 // If prefixed with a wide bytecode, get a wide index. 136 void put_index(int idx) { 137 if (_pc == _was_wide) // was widened? 138 Bytes::put_Java_u2(_bc_start+2,idx); // yes, set wide index 139 else 140 _bc_start[1]=idx; // no, set narrow index 141 } 142 143 // Get 2-byte index (getfield/putstatic/etc) 144 int get_index_big() const { return Bytes::get_Java_u2(_bc_start+1); } 145 146 // Get dimensions byte (multinewarray) 147 int get_dimensions() const { return *(unsigned char*)(_pc-1); } 148 149 // Get unsigned index fast 150 int get_index_fast() const { return Bytes::get_native_u2(_pc-2); } 151 152 // Sign-extended index byte/short, no widening 153 int get_byte() const { return (int8_t)(_pc[-1]); } 154 int get_short() const { return (int16_t)Bytes::get_Java_u2(_pc-2); } 155 int get_long() const { return (int32_t)Bytes::get_Java_u4(_pc-4); } 156 157 // Get a byte signed constant for "iinc". Invalid for other bytecodes. 158 // If prefixed with a wide bytecode, get a wide constant 159 int get_iinc_con() const {return (_pc==_was_wide) ? get_short() :get_byte();} 160 161 // 2-byte branch offset from current pc 162 int get_dest( ) const { 163 assert( Bytecodes::length_at(_bc_start) == sizeof(jshort)+1, "get_dest called with bad bytecode" ); 164 return _bc_start-_start + (short)Bytes::get_Java_u2(_pc-2); 165 } 166 167 // 2-byte branch offset from next pc 168 int next_get_dest( ) const { 169 address next_bc_start = _pc; 170 assert( _pc < _end, "" ); 171 Bytecodes::Code next_bc = (Bytecodes::Code)*_pc; 172 assert( next_bc != Bytecodes::_wide, ""); 173 int next_csize = Bytecodes::length_for(next_bc); 174 assert( next_csize != 0, "" ); 175 assert( next_bc <= Bytecodes::_jsr_w, ""); 176 address next_pc = _pc + next_csize; 177 assert( Bytecodes::length_at(next_bc_start) == sizeof(jshort)+1, "next_get_dest called with bad bytecode" ); 178 return next_bc_start-_start + (short)Bytes::get_Java_u2(next_pc-2); 179 } 180 181 // 4-byte branch offset from current pc 182 int get_far_dest( ) const { 183 assert( Bytecodes::length_at(_bc_start) == sizeof(jint)+1, "dest4 called with bad bytecode" ); 184 return _bc_start-_start + (int)Bytes::get_Java_u4(_pc-4); 185 } 186 187 // For a lookup or switch table, return target destination 188 int get_int_table( int index ) const { 189 return Bytes::get_Java_u4((address)&_table_base[index]); } 190 191 // For tableswitch - get length of offset part 192 int get_tableswitch_length() { return get_int_table(2)-get_int_table(1)+1; } 193 194 int get_dest_table( int index ) const { 195 return cur_bci() + get_int_table(index); } 196 197 // --- Constant pool access --- 198 int get_constant_index() const; 199 int get_field_index(); 200 int get_method_index(); 201 202 // If this bytecode is a new, newarray, multianewarray, instanceof, 203 // or checkcast, get the referenced klass. 204 ciKlass* get_klass(bool& will_link); 205 int get_klass_index() const; 206 207 // If this bytecode is one of the ldc variants, get the referenced 208 // constant 209 ciConstant get_constant(); 210 // True if the ldc variant points to an unresolved string 211 bool is_unresolved_string() const; 212 // True if the ldc variant points to an unresolved klass 213 bool is_unresolved_klass() const; 214 215 // If this bytecode is one of get_field, get_static, put_field, 216 // or put_static, get the referenced field. 217 ciField* get_field(bool& will_link); 218 219 ciInstanceKlass* get_declared_field_holder(); 220 int get_field_holder_index(); 221 int get_field_signature_index(); 222 223 // If this is a method invocation bytecode, get the invoked method. 224 ciMethod* get_method(bool& will_link); 225 ciKlass* get_declared_method_holder(); 226 int get_method_holder_index(); 227 int get_method_signature_index(); 228}; 229 230 231// ciSignatureStream 232// 233// The class is used to iterate over the elements of a method signature. 234class ciSignatureStream : public StackObj { 235private: 236 ciSignature* _sig; 237 int _pos; 238public: 239 ciSignatureStream(ciSignature* signature) { 240 _sig = signature; 241 _pos = 0; 242 } 243 244 bool at_return_type() { return _pos == _sig->count(); } 245 246 bool is_done() { return _pos > _sig->count(); } 247 248 void next() { 249 if (_pos <= _sig->count()) { 250 _pos++; 251 } 252 } 253 254 ciType* type() { 255 if (at_return_type()) { 256 return _sig->return_type(); 257 } else { 258 return _sig->type_at(_pos); 259 } 260 } 261}; 262 263 264// ciExceptionHandlerStream 265// 266// The class is used to iterate over the exception handlers of 267// a method. 268class ciExceptionHandlerStream : public StackObj { 269private: 270 // The method whose handlers we are traversing 271 ciMethod* _method; 272 273 // Our current position in the list of handlers 274 int _pos; 275 int _end; 276 277 ciInstanceKlass* _exception_klass; 278 int _bci; 279 bool _is_exact; 280 281public: 282 ciExceptionHandlerStream(ciMethod* method) { 283 _method = method; 284 285 // Force loading of method code and handlers. 286 _method->code(); 287 288 _pos = 0; 289 _end = _method->_handler_count; 290 _exception_klass = NULL; 291 _bci = -1; 292 _is_exact = false; 293 } 294 295 ciExceptionHandlerStream(ciMethod* method, int bci, 296 ciInstanceKlass* exception_klass = NULL, 297 bool is_exact = false) { 298 _method = method; 299 300 // Force loading of method code and handlers. 301 _method->code(); 302 303 _pos = -1; 304 _end = _method->_handler_count + 1; // include the rethrow handler 305 _exception_klass = (exception_klass != NULL && exception_klass->is_loaded() 306 ? exception_klass 307 : NULL); 308 _bci = bci; 309 assert(_bci >= 0, "bci out of range"); 310 _is_exact = is_exact; 311 next(); 312 } 313 314 // These methods are currently implemented in an odd way. 315 // Count the number of handlers the iterator has ever produced 316 // or will ever produce. Do not include the final rethrow handler. 317 // That is, a trivial exception handler stream will have a count 318 // of zero and produce just the rethrow handler. 319 int count(); 320 321 // Count the number of handlers this stream will produce from now on. 322 // Include the current handler, and the final rethrow handler. 323 // The remaining count will be zero iff is_done() is true, 324 int count_remaining(); 325 326 bool is_done() { 327 return (_pos >= _end); 328 } 329 330 void next() { 331 _pos++; 332 if (_bci != -1) { 333 // We are not iterating over all handlers... 334 while (!is_done()) { 335 ciExceptionHandler* handler = _method->_exception_handlers[_pos]; 336 if (handler->is_in_range(_bci)) { 337 if (handler->is_catch_all()) { 338 // Found final active catch block. 339 _end = _pos+1; 340 return; 341 } else if (_exception_klass == NULL || !handler->catch_klass()->is_loaded()) { 342 // We cannot do any type analysis here. Must conservatively assume 343 // catch block is reachable. 344 return; 345 } else if (_exception_klass->is_subtype_of(handler->catch_klass())) { 346 // This catch clause will definitely catch the exception. 347 // Final candidate. 348 _end = _pos+1; 349 return; 350 } else if (!_is_exact && 351 handler->catch_klass()->is_subtype_of(_exception_klass)) { 352 // This catch block may be reachable. 353 return; 354 } 355 } 356 357 // The catch block was not pertinent. Go on. 358 _pos++; 359 } 360 } else { 361 // This is an iteration over all handlers. 362 return; 363 } 364 } 365 366 ciExceptionHandler* handler() { 367 return _method->_exception_handlers[_pos]; 368 } 369}; 370