1 /* 2 * Copyright (c) 2006, 2017, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "ci/ciMethodBlocks.hpp" 27 #include "ci/ciStreams.hpp" 28 #include "interpreter/bytecode.hpp" 29 #include "utilities/copy.hpp" 30 31 // ciMethodBlocks 32 33 34 35 ciBlock *ciMethodBlocks::block_containing(int bci) { 36 ciBlock *blk = _bci_to_block[bci]; 37 return blk; 38 } 39 40 bool ciMethodBlocks::is_block_start(int bci) { 41 assert(bci >=0 && bci < _code_size, "valid bytecode range"); 42 ciBlock *b = _bci_to_block[bci]; 43 assert(b != NULL, "must have block for bytecode"); 44 return b->start_bci() == bci; 45 } 46 47 // ------------------------------------------------------------------ 48 // ciMethodBlocks::split_block_at 49 // 50 // Split the block spanning bci into two separate ranges. The former 51 // block becomes the second half and a new range is created for the 52 // first half. Returns the range beginning at bci. 53 ciBlock *ciMethodBlocks::split_block_at(int bci) { 54 ciBlock *former_block = block_containing(bci); 55 ciBlock *new_block = new(_arena) ciBlock(_method, _num_blocks++, former_block->start_bci()); 56 _blocks->append(new_block); 57 assert(former_block != NULL, "must not be NULL"); 58 new_block->set_limit_bci(bci); 59 former_block->set_start_bci(bci); 60 for (int pos=bci-1; pos >= 0; pos--) { 61 ciBlock *current_block = block_containing(pos); 62 if (current_block == former_block) { 63 // Replace it. 64 _bci_to_block[pos] = new_block; 65 } else if (current_block == NULL) { 66 // Non-bytecode start. Skip. 67 continue; 68 } else { 69 // We are done with our backwards walk 70 break; 71 } 72 } 73 // Move an exception handler information if needed. 74 if (former_block->is_handler()) { 75 int ex_start = former_block->ex_start_bci(); 76 int ex_end = former_block->ex_limit_bci(); 77 new_block->set_exception_range(ex_start, ex_end); 78 // Clear information in former_block. 79 former_block->clear_exception_handler(); 80 } 81 return former_block; 82 } 83 84 ciBlock *ciMethodBlocks::make_block_at(int bci) { 85 ciBlock *cb = block_containing(bci); 86 if (cb == NULL ) { 87 // This is our first time visiting this bytecode. Create 88 // a fresh block and assign it this starting point. 89 ciBlock *nb = new(_arena) ciBlock(_method, _num_blocks++, bci); 90 _blocks->append(nb); 91 _bci_to_block[bci] = nb; 92 return nb; 93 } else if (cb->start_bci() == bci) { 94 // The block begins at bci. Simply return it. 95 return cb; 96 } else { 97 // We have already created a block containing bci but 98 // not starting at bci. This existing block needs to 99 // be split into two. 100 return split_block_at(bci); 101 } 102 } 103 104 ciBlock *ciMethodBlocks::make_dummy_block() { 105 ciBlock *dum = new(_arena) ciBlock(_method, -1, 0); 106 return dum; 107 } 108 109 void ciMethodBlocks::do_analysis() { 110 ciBytecodeStream s(_method); 111 ciBlock *cur_block = block_containing(0); 112 int limit_bci = _method->code_size(); 113 114 while (s.next() != ciBytecodeStream::EOBC()) { 115 int bci = s.cur_bci(); 116 // Determine if a new block has been made at the current bci. If 117 // this block differs from our current range, switch to the new 118 // one and end the old one. 119 assert(cur_block != NULL, "must always have a current block"); 120 ciBlock *new_block = block_containing(bci); 121 if (new_block == NULL || new_block == cur_block) { 122 // We have not marked this bci as the start of a new block. 123 // Keep interpreting the current_range. 124 _bci_to_block[bci] = cur_block; 125 } else { 126 cur_block->set_limit_bci(bci); 127 cur_block = new_block; 128 } 129 130 switch (s.cur_bc()) { 131 case Bytecodes::_ifeq : 132 case Bytecodes::_ifne : 133 case Bytecodes::_iflt : 134 case Bytecodes::_ifge : 135 case Bytecodes::_ifgt : 136 case Bytecodes::_ifle : 137 case Bytecodes::_if_icmpeq : 138 case Bytecodes::_if_icmpne : 139 case Bytecodes::_if_icmplt : 140 case Bytecodes::_if_icmpge : 141 case Bytecodes::_if_icmpgt : 142 case Bytecodes::_if_icmple : 143 case Bytecodes::_if_acmpeq : 144 case Bytecodes::_if_acmpne : 145 case Bytecodes::_ifnull : 146 case Bytecodes::_ifnonnull : 147 { 148 cur_block->set_control_bci(bci); 149 ciBlock *fall_through = make_block_at(s.next_bci()); 150 int dest_bci = s.get_dest(); 151 ciBlock *dest = make_block_at(dest_bci); 152 break; 153 } 154 155 case Bytecodes::_goto : 156 { 157 cur_block->set_control_bci(bci); 158 if (s.next_bci() < limit_bci) { 159 (void) make_block_at(s.next_bci()); 160 } 161 int dest_bci = s.get_dest(); 162 ciBlock *dest = make_block_at(dest_bci); 163 break; 164 } 165 166 case Bytecodes::_jsr : 167 { 168 cur_block->set_control_bci(bci); 169 ciBlock *ret = make_block_at(s.next_bci()); 170 int dest_bci = s.get_dest(); 171 ciBlock *dest = make_block_at(dest_bci); 172 break; 173 } 174 175 case Bytecodes::_tableswitch : 176 { 177 cur_block->set_control_bci(bci); 178 Bytecode_tableswitch sw(&s); 179 int len = sw.length(); 180 ciBlock *dest; 181 int dest_bci; 182 for (int i = 0; i < len; i++) { 183 dest_bci = s.cur_bci() + sw.dest_offset_at(i); 184 dest = make_block_at(dest_bci); 185 } 186 dest_bci = s.cur_bci() + sw.default_offset(); 187 make_block_at(dest_bci); 188 if (s.next_bci() < limit_bci) { 189 dest = make_block_at(s.next_bci()); 190 } 191 } 192 break; 193 194 case Bytecodes::_lookupswitch: 195 { 196 cur_block->set_control_bci(bci); 197 Bytecode_lookupswitch sw(&s); 198 int len = sw.number_of_pairs(); 199 ciBlock *dest; 200 int dest_bci; 201 for (int i = 0; i < len; i++) { 202 dest_bci = s.cur_bci() + sw.pair_at(i).offset(); 203 dest = make_block_at(dest_bci); 204 } 205 dest_bci = s.cur_bci() + sw.default_offset(); 206 dest = make_block_at(dest_bci); 207 if (s.next_bci() < limit_bci) { 208 dest = make_block_at(s.next_bci()); 209 } 210 } 211 break; 212 213 case Bytecodes::_goto_w : 214 { 215 cur_block->set_control_bci(bci); 216 if (s.next_bci() < limit_bci) { 217 (void) make_block_at(s.next_bci()); 218 } 219 int dest_bci = s.get_far_dest(); 220 ciBlock *dest = make_block_at(dest_bci); 221 break; 222 } 223 224 case Bytecodes::_jsr_w : 225 { 226 cur_block->set_control_bci(bci); 227 ciBlock *ret = make_block_at(s.next_bci()); 228 int dest_bci = s.get_far_dest(); 229 ciBlock *dest = make_block_at(dest_bci); 230 break; 231 } 232 233 case Bytecodes::_athrow : 234 cur_block->set_may_throw(); 235 // fall-through 236 case Bytecodes::_ret : 237 case Bytecodes::_ireturn : 238 case Bytecodes::_lreturn : 239 case Bytecodes::_freturn : 240 case Bytecodes::_dreturn : 241 case Bytecodes::_areturn : 242 case Bytecodes::_return : 243 cur_block->set_control_bci(bci); 244 if (s.next_bci() < limit_bci) { 245 (void) make_block_at(s.next_bci()); 246 } 247 break; 248 249 default: 250 break; 251 } 252 } 253 // End the last block 254 cur_block->set_limit_bci(limit_bci); 255 } 256 257 ciMethodBlocks::ciMethodBlocks(Arena *arena, ciMethod *meth): _method(meth), 258 _arena(arena), _num_blocks(0), _code_size(meth->code_size()) { 259 int block_estimate = _code_size / 8; 260 261 _blocks = new(_arena) GrowableArray<ciBlock *>(_arena, block_estimate, 0, NULL); 262 int b2bsize = _code_size * sizeof(ciBlock **); 263 _bci_to_block = (ciBlock **) arena->Amalloc(b2bsize); 264 Copy::zero_to_words((HeapWord*) _bci_to_block, b2bsize / sizeof(HeapWord)); 265 266 // create initial block covering the entire method 267 ciBlock *b = new(arena) ciBlock(_method, _num_blocks++, 0); 268 _blocks->append(b); 269 _bci_to_block[0] = b; 270 271 // create blocks for exception handlers 272 if (meth->has_exception_handlers()) { 273 for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) { 274 ciExceptionHandler* handler = str.handler(); 275 ciBlock *eb = make_block_at(handler->handler_bci()); 276 // 277 // Several exception handlers can have the same handler_bci: 278 // 279 // try { 280 // if (a.foo(b) < 0) { 281 // return a.error(); 282 // } 283 // return CoderResult.UNDERFLOW; 284 // } finally { 285 // a.position(b); 286 // } 287 // 288 // The try block above is divided into 2 exception blocks 289 // separated by 'areturn' bci. 290 // 291 int ex_start = handler->start(); 292 int ex_end = handler->limit(); 293 // ensure a block at the start of exception range and start of following code 294 (void) make_block_at(ex_start); 295 if (ex_end < _code_size) 296 (void) make_block_at(ex_end); 297 298 if (eb->is_handler()) { 299 // Extend old handler exception range to cover additional range. 300 int old_ex_start = eb->ex_start_bci(); 301 int old_ex_end = eb->ex_limit_bci(); 302 if (ex_start > old_ex_start) 303 ex_start = old_ex_start; 304 if (ex_end < old_ex_end) 305 ex_end = old_ex_end; 306 eb->clear_exception_handler(); // Reset exception information 307 } 308 eb->set_exception_range(ex_start, ex_end); 309 } 310 } 311 312 // scan the bytecodes and identify blocks 313 do_analysis(); 314 315 // mark blocks that have exception handlers 316 if (meth->has_exception_handlers()) { 317 for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) { 318 ciExceptionHandler* handler = str.handler(); 319 int ex_start = handler->start(); 320 int ex_end = handler->limit(); 321 322 int bci = ex_start; 323 while (bci < ex_end) { 324 ciBlock *b = block_containing(bci); 325 b->set_has_handler(); 326 bci = b->limit_bci(); 327 } 328 } 329 } 330 } 331 332 void ciMethodBlocks::clear_processed() { 333 for (int i = 0; i < _blocks->length(); i++) 334 _blocks->at(i)->clear_processed(); 335 } 336 337 #ifndef PRODUCT 338 void ciMethodBlocks::dump() { 339 tty->print("---- blocks for method: "); 340 _method->print(); 341 tty->cr(); 342 for (int i = 0; i < _blocks->length(); i++) { 343 tty->print(" B%d: ", i); _blocks->at(i)->dump(); 344 } 345 } 346 #endif 347 348 349 ciBlock::ciBlock(ciMethod *method, int index, int start_bci) : 350 #ifndef PRODUCT 351 _method(method), 352 #endif 353 _idx(index), _flags(0), _start_bci(start_bci), _limit_bci(-1), _control_bci(fall_through_bci), 354 _ex_start_bci(-1), _ex_limit_bci(-1) { 355 } 356 357 void ciBlock::set_exception_range(int start_bci, int limit_bci) { 358 assert(limit_bci >= start_bci, "valid range"); 359 assert(!is_handler() && _ex_start_bci == -1 && _ex_limit_bci == -1, "must not be handler"); 360 _ex_start_bci = start_bci; 361 _ex_limit_bci = limit_bci; 362 set_handler(); 363 } 364 365 #ifndef PRODUCT 366 static const char *flagnames[] = { 367 "Processed", 368 "Handler", 369 "MayThrow", 370 "Jsr", 371 "Ret", 372 "RetTarget", 373 "HasHandler", 374 }; 375 376 void ciBlock::dump() { 377 tty->print(" [%d .. %d), {", _start_bci, _limit_bci); 378 for (int i = 0; i < 7; i++) { 379 if ((_flags & (1 << i)) != 0) { 380 tty->print(" %s", flagnames[i]); 381 } 382 } 383 tty->print(" ]"); 384 if (is_handler()) 385 tty->print(" handles(%d..%d)", _ex_start_bci, _ex_limit_bci); 386 tty->cr(); 387 } 388 389 // ------------------------------------------------------------------ 390 // ciBlock::print_on 391 void ciBlock::print_on(outputStream* st) const { 392 st->print_cr("--------------------------------------------------------"); 393 st->print ("ciBlock [%d - %d) control : ", start_bci(), limit_bci()); 394 if (control_bci() == fall_through_bci) { 395 st->print_cr("%d:fall through", limit_bci()); 396 } else { 397 st->print_cr("%d:%s", control_bci(), 398 Bytecodes::name(method()->java_code_at_bci(control_bci()))); 399 } 400 401 if (Verbose || WizardMode) { 402 method()->print_codes_on(start_bci(), limit_bci(), st); 403 } 404 } 405 #endif