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 ciBlock::ciBlock(ciMethod *method, int index, int start_bci) :
349 _idx(index), _start_bci(start_bci), _limit_bci(-1), _control_bci(fall_through_bci),
350 _flags(0), _ex_start_bci(-1), _ex_limit_bci(-1)
351 #ifndef PRODUCT
352 , _method(method)
353 #endif
354 {
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