1 /*
2 * Copyright (c) 1997, 2026, 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 "classfile/vmSymbols.hpp"
26 #include "interpreter/bytecodeStream.hpp"
27 #include "logging/log.hpp"
28 #include "logging/logStream.hpp"
29 #include "memory/allocation.inline.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "oops/constantPool.hpp"
32 #include "oops/generateOopMap.hpp"
33 #include "oops/oop.inline.hpp"
34 #include "oops/symbol.hpp"
35 #include "runtime/handles.inline.hpp"
36 #include "runtime/java.hpp"
37 #include "runtime/os.hpp"
38 #include "runtime/relocator.hpp"
39 #include "runtime/timerTrace.hpp"
40 #include "utilities/bitMap.inline.hpp"
41 #include "utilities/ostream.hpp"
42
43 //
44 //
45 // Compute stack layouts for each instruction in method.
46 //
47 // Problems:
48 // - What to do about jsr with different types of local vars?
49 // Need maps that are conditional on jsr path?
50 // - Jsr and exceptions should be done more efficiently (the retAddr stuff)
51 //
52 // Alternative:
53 // - Could extend verifier to provide this information.
54 // For: one fewer abstract interpreter to maintain. Against: the verifier
55 // solves a bigger problem so slower (undesirable to force verification of
56 // everything?).
57 //
58 // Algorithm:
59 // Partition bytecodes into basic blocks
60 // For each basic block: store entry state (vars, stack). For instructions
61 // inside basic blocks we do not store any state (instead we recompute it
62 // from state produced by previous instruction).
63 //
64 // Perform abstract interpretation of bytecodes over this lattice:
65 //
66 // _--'#'--_
67 // / / \ \
68 // / / \ \
69 // / | | \
70 // 'r' 'v' 'p' ' '
71 // \ | | /
72 // \ \ / /
73 // \ \ / /
74 // -- '@' --
75 //
76 // '#' top, result of conflict merge
77 // 'r' reference type
78 // 'v' value type
79 // 'p' pc type for jsr/ret
80 // ' ' uninitialized; never occurs on operand stack in Java
81 // '@' bottom/unexecuted; initial state each bytecode.
82 //
83 // Basic block headers are the only merge points. We use this iteration to
84 // compute the information:
85 //
86 // find basic blocks;
87 // initialize them with uninitialized state;
88 // initialize first BB according to method signature;
89 // mark first BB changed
90 // while (some BB is changed) do {
91 // perform abstract interpration of all bytecodes in BB;
92 // merge exit state of BB into entry state of all successor BBs,
93 // noting if any of these change;
94 // }
95 //
96 // One additional complication is necessary. The jsr instruction pushes
97 // a return PC on the stack (a 'p' type in the abstract interpretation).
98 // To be able to process "ret" bytecodes, we keep track of these return
99 // PC's in a 'retAddrs' structure in abstract interpreter context (when
100 // processing a "ret" bytecodes, it is not sufficient to know that it gets
101 // an argument of the right type 'p'; we need to know which address it
102 // returns to).
103 //
104 // (Note this comment is borrowed form the original author of the algorithm)
105
106 // ComputeCallStack
107 //
108 // Specialization of SignatureIterator - compute the effects of a call
109 //
110 class ComputeCallStack : public SignatureIterator {
111 CellTypeState *_effect;
112 int _idx;
113
114 void setup();
115 void set(CellTypeState state) { _effect[_idx++] = state; }
116 int length() { return _idx; };
117
118 friend class SignatureIterator; // so do_parameters_on can call do_type
119 void do_type(BasicType type, bool for_return = false) {
120 if (for_return && type == T_VOID) {
121 set(CellTypeState::bottom);
122 } else if (is_reference_type(type)) {
123 set(CellTypeState::ref);
124 } else {
125 assert(is_java_primitive(type), "");
126 set(CellTypeState::value);
127 if (is_double_word_type(type)) {
128 set(CellTypeState::value);
129 }
130 }
131 }
132
133 public:
134 ComputeCallStack(Symbol* signature) : SignatureIterator(signature) {};
135
136 // Compute methods
137 int compute_for_parameters(bool is_static, CellTypeState *effect) {
138 _idx = 0;
139 _effect = effect;
140
141 if (!is_static)
142 effect[_idx++] = CellTypeState::ref;
143
144 do_parameters_on(this);
145
146 return length();
147 };
148
149 int compute_for_returntype(CellTypeState *effect) {
150 _idx = 0;
151 _effect = effect;
152 do_type(return_type(), true);
153 set(CellTypeState::bottom); // Always terminate with a bottom state, so ppush works
154
155 return length();
156 }
157 };
158
159 //=========================================================================================
160 // ComputeEntryStack
161 //
162 // Specialization of SignatureIterator - in order to set up first stack frame
163 //
164 class ComputeEntryStack : public SignatureIterator {
165 CellTypeState *_effect;
166 int _idx;
167
168 void setup();
169 void set(CellTypeState state) { _effect[_idx++] = state; }
170 int length() { return _idx; };
171
172 friend class SignatureIterator; // so do_parameters_on can call do_type
173 void do_type(BasicType type, bool for_return = false) {
174 if (for_return && type == T_VOID) {
175 set(CellTypeState::bottom);
176 } else if (is_reference_type(type)) {
177 set(CellTypeState::make_slot_ref(_idx));
178 } else {
179 assert(is_java_primitive(type), "");
180 set(CellTypeState::value);
181 if (is_double_word_type(type)) {
182 set(CellTypeState::value);
183 }
184 }
185 }
186
187 public:
188 ComputeEntryStack(Symbol* signature) : SignatureIterator(signature) {};
189
190 // Compute methods
191 int compute_for_parameters(bool is_static, CellTypeState *effect) {
192 _idx = 0;
193 _effect = effect;
194
195 if (!is_static)
196 effect[_idx++] = CellTypeState::make_slot_ref(0);
197
198 do_parameters_on(this);
199
200 return length();
201 };
202
203 int compute_for_returntype(CellTypeState *effect) {
204 _idx = 0;
205 _effect = effect;
206 do_type(return_type(), true);
207 set(CellTypeState::bottom); // Always terminate with a bottom state, so ppush works
208
209 return length();
210 }
211 };
212
213 //=====================================================================================
214 //
215 // Implementation of RetTable/RetTableEntry
216 //
217 // Contains function to itereate through all bytecodes
218 // and find all return entry points
219 //
220 int RetTable::_init_nof_entries = 10;
221 int RetTableEntry::_init_nof_jsrs = 5;
222
223 RetTableEntry::RetTableEntry(int target, RetTableEntry *next) {
224 _target_bci = target;
225 _jsrs = new GrowableArray<int>(_init_nof_jsrs);
226 _next = next;
227 }
228
229 void RetTableEntry::add_delta(int bci, int delta) {
230 if (_target_bci > bci) _target_bci += delta;
231
232 for (int k = 0; k < _jsrs->length(); k++) {
233 int jsr = _jsrs->at(k);
234 if (jsr > bci) _jsrs->at_put(k, jsr+delta);
235 }
236 }
237
238 void RetTable::compute_ret_table(const methodHandle& method) {
239 BytecodeStream i(method);
240 Bytecodes::Code bytecode;
241
242 while( (bytecode = i.next()) >= 0) {
243 switch (bytecode) {
244 case Bytecodes::_jsr:
245 add_jsr(i.next_bci(), i.dest());
246 break;
247 case Bytecodes::_jsr_w:
248 add_jsr(i.next_bci(), i.dest_w());
249 break;
250 default:
251 break;
252 }
253 }
254 }
255
256 void RetTable::add_jsr(int return_bci, int target_bci) {
257 RetTableEntry* entry = _first;
258
259 // Scan table for entry
260 for (;entry && entry->target_bci() != target_bci; entry = entry->next());
261
262 if (!entry) {
263 // Allocate new entry and put in list
264 entry = new RetTableEntry(target_bci, _first);
265 _first = entry;
266 }
267
268 // Now "entry" is set. Make sure that the entry is initialized
269 // and has room for the new jsr.
270 entry->add_jsr(return_bci);
271 }
272
273 RetTableEntry* RetTable::find_jsrs_for_target(int targBci) {
274 RetTableEntry *cur = _first;
275
276 while(cur) {
277 assert(cur->target_bci() != -1, "sanity check");
278 if (cur->target_bci() == targBci) return cur;
279 cur = cur->next();
280 }
281 ShouldNotReachHere();
282 return nullptr;
283 }
284
285 // The instruction at bci is changing size by "delta". Update the return map.
286 void RetTable::update_ret_table(int bci, int delta) {
287 RetTableEntry *cur = _first;
288 while(cur) {
289 cur->add_delta(bci, delta);
290 cur = cur->next();
291 }
292 }
293
294 //
295 // Celltype state
296 //
297
298 CellTypeState CellTypeState::bottom = CellTypeState::make_bottom();
299 CellTypeState CellTypeState::uninit = CellTypeState::make_any(uninit_value);
300 CellTypeState CellTypeState::ref = CellTypeState::make_any(ref_conflict);
301 CellTypeState CellTypeState::value = CellTypeState::make_any(val_value);
302 CellTypeState CellTypeState::refUninit = CellTypeState::make_any(ref_conflict | uninit_value);
303 CellTypeState CellTypeState::top = CellTypeState::make_top();
304 CellTypeState CellTypeState::addr = CellTypeState::make_any(addr_conflict);
305
306 // Commonly used constants
307 static CellTypeState epsilonCTS[1] = { CellTypeState::bottom };
308 static CellTypeState refCTS = CellTypeState::ref;
309 static CellTypeState valCTS = CellTypeState::value;
310 static CellTypeState vCTS[2] = { CellTypeState::value, CellTypeState::bottom };
311 static CellTypeState rCTS[2] = { CellTypeState::ref, CellTypeState::bottom };
312 static CellTypeState rrCTS[3] = { CellTypeState::ref, CellTypeState::ref, CellTypeState::bottom };
313 static CellTypeState vrCTS[3] = { CellTypeState::value, CellTypeState::ref, CellTypeState::bottom };
314 static CellTypeState vvCTS[3] = { CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
315 static CellTypeState rvrCTS[4] = { CellTypeState::ref, CellTypeState::value, CellTypeState::ref, CellTypeState::bottom };
316 static CellTypeState vvrCTS[4] = { CellTypeState::value, CellTypeState::value, CellTypeState::ref, CellTypeState::bottom };
317 static CellTypeState vvvCTS[4] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
318 static CellTypeState vvvrCTS[5] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::ref, CellTypeState::bottom };
319 static CellTypeState vvvvCTS[5] = { CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::value, CellTypeState::bottom };
320
321 char CellTypeState::to_char() const {
322 if (can_be_reference()) {
323 if (can_be_value() || can_be_address())
324 return '#'; // Conflict that needs to be rewritten
325 else
326 return 'r';
327 } else if (can_be_value())
328 return 'v';
329 else if (can_be_address())
330 return 'p';
331 else if (can_be_uninit())
332 return ' ';
333 else
334 return '@';
335 }
336
337
338 // Print a detailed CellTypeState. Indicate all bits that are set. If
339 // the CellTypeState represents an address or a reference, print the
340 // value of the additional information.
341 void CellTypeState::print(outputStream *os) {
342 if (can_be_address()) {
343 os->print("(p");
344 } else {
345 os->print("( ");
346 }
347 if (can_be_reference()) {
348 os->print("r");
349 } else {
350 os->print(" ");
351 }
352 if (can_be_value()) {
353 os->print("v");
354 } else {
355 os->print(" ");
356 }
357 if (can_be_uninit()) {
358 os->print("u|");
359 } else {
360 os->print(" |");
361 }
362 if (is_info_top()) {
363 os->print("Top)");
364 } else if (is_info_bottom()) {
365 os->print("Bot)");
366 } else {
367 if (is_reference()) {
368 int info = get_info();
369 int data = info & ~(ref_not_lock_bit | ref_slot_bit);
370 if (info & ref_not_lock_bit) {
371 // Not a monitor lock reference.
372 if (info & ref_slot_bit) {
373 // slot
374 os->print("slot%d)", data);
375 } else {
376 // line
377 os->print("line%d)", data);
378 }
379 } else {
380 // lock
381 os->print("lock%d)", data);
382 }
383 } else {
384 os->print("%d)", get_info());
385 }
386 }
387 }
388
389 //
390 // Basicblock handling methods
391 //
392
393 void GenerateOopMap::initialize_bb() {
394 _bb_count = 0;
395 _bb_hdr_bits.reinitialize(method()->code_size());
396 }
397
398 void GenerateOopMap::bb_mark_fct(GenerateOopMap *c, int bci, int *data) {
399 assert(bci>= 0 && bci < c->method()->code_size(), "index out of bounds");
400 if (c->is_bb_header(bci))
401 return;
402
403 log_debug(generateoopmap)( "Basicblock#%d begins at: %d", c->_bb_count, bci);
404 c->set_bbmark_bit(bci);
405 c->_bb_count++;
406 }
407
408
409 void GenerateOopMap::mark_bbheaders() {
410 initialize_bb();
411
412 bool fellThrough = false; // False to get first BB marked.
413
414 // First mark all exception handlers as start of a basic-block
415 ExceptionTable excps(method());
416 for(int i = 0; i < excps.length(); i ++) {
417 bb_mark_fct(this, excps.handler_pc(i), nullptr);
418 }
419
420 // Then iterate through the code
421 BytecodeStream bcs(_method);
422 Bytecodes::Code bytecode;
423
424 while( (bytecode = bcs.next()) >= 0) {
425 int bci = bcs.bci();
426
427 if (!fellThrough)
428 bb_mark_fct(this, bci, nullptr);
429
430 fellThrough = jump_targets_do(&bcs, &GenerateOopMap::bb_mark_fct, nullptr);
431
432 /* We will also mark successors of jsr's as basic block headers. */
433 switch (bytecode) {
434 case Bytecodes::_jsr:
435 case Bytecodes::_jsr_w:
436 assert(!fellThrough, "should not happen");
437 // If this is the last bytecode, there is no successor to mark
438 if (bci + Bytecodes::length_for(bytecode) < method()->code_size()) {
439 bb_mark_fct(this, bci + Bytecodes::length_for(bytecode), nullptr);
440 }
441 break;
442 default:
443 break;
444 }
445 }
446 }
447
448 void GenerateOopMap::set_bbmark_bit(int bci) {
449 _bb_hdr_bits.at_put(bci, true);
450 }
451
452 void GenerateOopMap::reachable_basicblock(GenerateOopMap *c, int bci, int *data) {
453 assert(bci>= 0 && bci < c->method()->code_size(), "index out of bounds");
454 BasicBlock* bb = c->get_basic_block_at(bci);
455 if (bb->is_dead()) {
456 bb->mark_as_alive();
457 *data = 1; // Mark basicblock as changed
458 }
459 }
460
461
462 void GenerateOopMap::mark_reachable_code() {
463 int change = 1; // int to get function pointers to work
464
465 // Mark entry basic block as alive and all exception handlers
466 _basic_blocks[0].mark_as_alive();
467 ExceptionTable excps(method());
468 for(int i = 0; i < excps.length(); i++) {
469 BasicBlock *bb = get_basic_block_at(excps.handler_pc(i));
470 // If block is not already alive (due to multiple exception handlers to same bb), then
471 // make it alive
472 if (bb->is_dead()) bb->mark_as_alive();
473 }
474
475 BytecodeStream bcs(_method);
476
477 // Iterate through all basic blocks until we reach a fixpoint
478 while (change) {
479 change = 0;
480
481 for (int i = 0; i < _bb_count; i++) {
482 BasicBlock *bb = &_basic_blocks[i];
483 if (bb->is_alive()) {
484 // Position bytecodestream at last bytecode in basicblock
485 bcs.set_start(bb->_end_bci);
486 bcs.next();
487 Bytecodes::Code bytecode = bcs.code();
488 int bci = bcs.bci();
489 assert(bci == bb->_end_bci, "wrong bci");
490
491 bool fell_through = jump_targets_do(&bcs, &GenerateOopMap::reachable_basicblock, &change);
492
493 // We will also mark successors of jsr's as alive.
494 switch (bytecode) {
495 case Bytecodes::_jsr:
496 case Bytecodes::_jsr_w:
497 assert(!fell_through, "should not happen");
498 // If this is the last bytecode, there is no successor to mark
499 if (bci + Bytecodes::length_for(bytecode) < method()->code_size()) {
500 reachable_basicblock(this, bci + Bytecodes::length_for(bytecode), &change);
501 }
502 break;
503 default:
504 break;
505 }
506 if (fell_through) {
507 // Mark successor as alive
508 if (bb[1].is_dead()) {
509 bb[1].mark_as_alive();
510 change = 1;
511 }
512 }
513 }
514 }
515 }
516 }
517
518 /* If the current instruction in "c" has no effect on control flow,
519 returns "true". Otherwise, calls "jmpFct" one or more times, with
520 "c", an appropriate "pcDelta", and "data" as arguments, then
521 returns "false". There is one exception: if the current
522 instruction is a "ret", returns "false" without calling "jmpFct".
523 Arrangements for tracking the control flow of a "ret" must be made
524 externally. */
525 bool GenerateOopMap::jump_targets_do(BytecodeStream *bcs, jmpFct_t jmpFct, int *data) {
526 int bci = bcs->bci();
527
528 switch (bcs->code()) {
529 case Bytecodes::_ifeq:
530 case Bytecodes::_ifne:
531 case Bytecodes::_iflt:
532 case Bytecodes::_ifge:
533 case Bytecodes::_ifgt:
534 case Bytecodes::_ifle:
535 case Bytecodes::_if_icmpeq:
536 case Bytecodes::_if_icmpne:
537 case Bytecodes::_if_icmplt:
538 case Bytecodes::_if_icmpge:
539 case Bytecodes::_if_icmpgt:
540 case Bytecodes::_if_icmple:
541 case Bytecodes::_if_acmpeq:
542 case Bytecodes::_if_acmpne:
543 case Bytecodes::_ifnull:
544 case Bytecodes::_ifnonnull:
545 (*jmpFct)(this, bcs->dest(), data);
546 // Class files verified by the old verifier can have a conditional branch
547 // as their last bytecode, provided the conditional branch is unreachable
548 // during execution. Check if this instruction is the method's last bytecode
549 // and, if so, don't call the jmpFct.
550 if (bci + 3 < method()->code_size()) {
551 (*jmpFct)(this, bci + 3, data);
552 }
553 break;
554
555 case Bytecodes::_goto:
556 (*jmpFct)(this, bcs->dest(), data);
557 break;
558 case Bytecodes::_goto_w:
559 (*jmpFct)(this, bcs->dest_w(), data);
560 break;
561 case Bytecodes::_tableswitch:
562 { Bytecode_tableswitch tableswitch(method(), bcs->bcp());
563 int len = tableswitch.length();
564
565 (*jmpFct)(this, bci + tableswitch.default_offset(), data); /* Default. jump address */
566 while (--len >= 0) {
567 (*jmpFct)(this, bci + tableswitch.dest_offset_at(len), data);
568 }
569 break;
570 }
571
572 case Bytecodes::_lookupswitch:
573 { Bytecode_lookupswitch lookupswitch(method(), bcs->bcp());
574 int npairs = lookupswitch.number_of_pairs();
575 (*jmpFct)(this, bci + lookupswitch.default_offset(), data); /* Default. */
576 while(--npairs >= 0) {
577 LookupswitchPair pair = lookupswitch.pair_at(npairs);
578 (*jmpFct)(this, bci + pair.offset(), data);
579 }
580 break;
581 }
582 case Bytecodes::_jsr:
583 assert(bcs->is_wide()==false, "sanity check");
584 (*jmpFct)(this, bcs->dest(), data);
585 break;
586 case Bytecodes::_jsr_w:
587 (*jmpFct)(this, bcs->dest_w(), data);
588 break;
589 case Bytecodes::_wide:
590 ShouldNotReachHere();
591 return true;
592 break;
593 case Bytecodes::_athrow:
594 case Bytecodes::_ireturn:
595 case Bytecodes::_lreturn:
596 case Bytecodes::_freturn:
597 case Bytecodes::_dreturn:
598 case Bytecodes::_areturn:
599 case Bytecodes::_return:
600 case Bytecodes::_ret:
601 break;
602 default:
603 return true;
604 }
605 return false;
606 }
607
608 /* Requires "pc" to be the head of a basic block; returns that basic
609 block. */
610 BasicBlock *GenerateOopMap::get_basic_block_at(int bci) const {
611 BasicBlock* bb = get_basic_block_containing(bci);
612 assert(bb->_bci == bci, "should have found BB");
613 return bb;
614 }
615
616 // Requires "pc" to be the start of an instruction; returns the basic
617 // block containing that instruction. */
618 BasicBlock *GenerateOopMap::get_basic_block_containing(int bci) const {
619 BasicBlock *bbs = _basic_blocks;
620 int lo = 0, hi = _bb_count - 1;
621
622 while (lo <= hi) {
623 int m = (lo + hi) / 2;
624 int mbci = bbs[m]._bci;
625 int nbci;
626
627 if ( m == _bb_count-1) {
628 assert( bci >= mbci && bci < method()->code_size(), "sanity check failed");
629 return bbs+m;
630 } else {
631 nbci = bbs[m+1]._bci;
632 }
633
634 if ( mbci <= bci && bci < nbci) {
635 return bbs+m;
636 } else if (mbci < bci) {
637 lo = m + 1;
638 } else {
639 assert(mbci > bci, "sanity check");
640 hi = m - 1;
641 }
642 }
643
644 fatal("should have found BB");
645 return nullptr;
646 }
647
648 void GenerateOopMap::restore_state(BasicBlock *bb)
649 {
650 memcpy(_state, bb->_state, _state_len*sizeof(CellTypeState));
651 _stack_top = bb->_stack_top;
652 _monitor_top = bb->_monitor_top;
653 }
654
655 int GenerateOopMap::next_bb_start_pc(BasicBlock *bb) {
656 intptr_t bbNum = bb - _basic_blocks + 1;
657 if (bbNum == _bb_count)
658 return method()->code_size();
659
660 return _basic_blocks[bbNum]._bci;
661 }
662
663 //
664 // CellType handling methods
665 //
666
667 // Allocate memory and throw LinkageError if failure.
668 #define ALLOC_RESOURCE_ARRAY(var, type, count) \
669 var = NEW_RESOURCE_ARRAY_RETURN_NULL(type, count); \
670 if (var == nullptr) { \
671 report_error("Cannot reserve enough memory to analyze this method"); \
672 return; \
673 }
674
675
676 void GenerateOopMap::init_state() {
677 _state_len = _max_locals + _max_stack + _max_monitors;
678 ALLOC_RESOURCE_ARRAY(_state, CellTypeState, _state_len);
679 memset(_state, 0, _state_len * sizeof(CellTypeState));
680 int count = MAX3(_max_locals, _max_stack, _max_monitors) + 1/*for null terminator char */;
681 ALLOC_RESOURCE_ARRAY(_state_vec_buf, char, count);
682 }
683
684 void GenerateOopMap::make_context_uninitialized() {
685 CellTypeState* vs = vars();
686
687 for (int i = 0; i < _max_locals; i++)
688 vs[i] = CellTypeState::uninit;
689
690 _stack_top = 0;
691 _monitor_top = 0;
692 }
693
694 int GenerateOopMap::methodsig_to_effect(Symbol* signature, bool is_static, CellTypeState* effect) {
695 ComputeEntryStack ces(signature);
696 return ces.compute_for_parameters(is_static, effect);
697 }
698
699 // Return result of merging cts1 and cts2.
700 CellTypeState CellTypeState::merge(CellTypeState cts, int slot) const {
701 CellTypeState result;
702
703 assert(!is_bottom() && !cts.is_bottom(),
704 "merge of bottom values is handled elsewhere");
705
706 result._state = _state | cts._state;
707
708 // If the top bit is set, we don't need to do any more work.
709 if (!result.is_info_top()) {
710 assert((result.can_be_address() || result.can_be_reference()),
711 "only addresses and references have non-top info");
712
713 if (!equal(cts)) {
714 // The two values being merged are different. Raise to top.
715 if (result.is_reference()) {
716 result = CellTypeState::make_slot_ref(slot);
717 } else {
718 result._state |= info_conflict;
719 }
720 }
721 }
722 assert(result.is_valid_state(), "checking that CTS merge maintains legal state");
723
724 return result;
725 }
726
727 // Merge the variable state for locals and stack from cts into bbts.
728 bool GenerateOopMap::merge_local_state_vectors(CellTypeState* cts,
729 CellTypeState* bbts) {
730 int i;
731 int len = _max_locals + _stack_top;
732 bool change = false;
733
734 for (i = len - 1; i >= 0; i--) {
735 CellTypeState v = cts[i].merge(bbts[i], i);
736 change = change || !v.equal(bbts[i]);
737 bbts[i] = v;
738 }
739
740 return change;
741 }
742
743 // Merge the monitor stack state from cts into bbts.
744 bool GenerateOopMap::merge_monitor_state_vectors(CellTypeState* cts,
745 CellTypeState* bbts) {
746 bool change = false;
747 if (_max_monitors > 0 && _monitor_top != bad_monitors) {
748 // If there are no monitors in the program, or there has been
749 // a monitor matching error before this point in the program,
750 // then we do not merge in the monitor state.
751
752 int base = _max_locals + _max_stack;
753 int len = base + _monitor_top;
754 for (int i = len - 1; i >= base; i--) {
755 CellTypeState v = cts[i].merge(bbts[i], i);
756
757 // Can we prove that, when there has been a change, it will already
758 // have been detected at this point? That would make this equal
759 // check here unnecessary.
760 change = change || !v.equal(bbts[i]);
761 bbts[i] = v;
762 }
763 }
764
765 return change;
766 }
767
768 void GenerateOopMap::copy_state(CellTypeState *dst, CellTypeState *src) {
769 int len = _max_locals + _stack_top;
770 for (int i = 0; i < len; i++) {
771 if (src[i].is_nonlock_reference()) {
772 dst[i] = CellTypeState::make_slot_ref(i);
773 } else {
774 dst[i] = src[i];
775 }
776 }
777 if (_max_monitors > 0 && _monitor_top != bad_monitors) {
778 int base = _max_locals + _max_stack;
779 len = base + _monitor_top;
780 for (int i = base; i < len; i++) {
781 dst[i] = src[i];
782 }
783 }
784 }
785
786
787 // Merge the states for the current block and the next. As long as a
788 // block is reachable the locals and stack must be merged. If the
789 // stack heights don't match then this is a verification error and
790 // it's impossible to interpret the code. Simultaneously monitor
791 // states are being check to see if they nest statically. If monitor
792 // depths match up then their states are merged. Otherwise the
793 // mismatch is simply recorded and interpretation continues since
794 // monitor matching is purely informational and doesn't say anything
795 // about the correctness of the code.
796 void GenerateOopMap::merge_state_into_bb(BasicBlock *bb) {
797 guarantee(bb != nullptr, "null basicblock");
798 assert(bb->is_alive(), "merging state into a dead basicblock");
799
800 if (_stack_top == bb->_stack_top) {
801 // always merge local state even if monitors don't match.
802 if (merge_local_state_vectors(_state, bb->_state)) {
803 bb->set_changed(true);
804 }
805 if (_monitor_top == bb->_monitor_top) {
806 // monitors still match so continue merging monitor states.
807 if (merge_monitor_state_vectors(_state, bb->_state)) {
808 bb->set_changed(true);
809 }
810 } else {
811 if (log_is_enabled(Info, monitormismatch)) {
812 report_monitor_mismatch("monitor stack height merge conflict");
813 }
814 // When the monitor stacks are not matched, we set _monitor_top to
815 // bad_monitors. This signals that, from here on, the monitor stack cannot
816 // be trusted. In particular, monitorexit bytecodes may throw
817 // exceptions. We mark this block as changed so that the change
818 // propagates properly.
819 bb->_monitor_top = bad_monitors;
820 bb->set_changed(true);
821 _monitor_safe = false;
822 }
823 } else if (!bb->is_reachable()) {
824 // First time we look at this BB
825 copy_state(bb->_state, _state);
826 bb->_stack_top = _stack_top;
827 bb->_monitor_top = _monitor_top;
828 bb->set_changed(true);
829 } else {
830 verify_error("stack height conflict: %d vs. %d", _stack_top, bb->_stack_top);
831 }
832 }
833
834 void GenerateOopMap::merge_state(GenerateOopMap *gom, int bci, int* data) {
835 gom->merge_state_into_bb(gom->get_basic_block_at(bci));
836 }
837
838 void GenerateOopMap::set_var(int localNo, CellTypeState cts) {
839 assert(cts.is_reference() || cts.is_value() || cts.is_address(),
840 "wrong celltypestate");
841 if (localNo < 0 || localNo > _max_locals) {
842 verify_error("variable write error: r%d", localNo);
843 return;
844 }
845 vars()[localNo] = cts;
846 }
847
848 CellTypeState GenerateOopMap::get_var(int localNo) {
849 assert(localNo < _max_locals + _nof_refval_conflicts, "variable read error");
850 if (localNo < 0 || localNo > _max_locals) {
851 verify_error("variable read error: r%d", localNo);
852 return valCTS; // just to pick something;
853 }
854 return vars()[localNo];
855 }
856
857 CellTypeState GenerateOopMap::pop() {
858 if ( _stack_top <= 0) {
859 verify_error("stack underflow");
860 return valCTS; // just to pick something
861 }
862 return stack()[--_stack_top];
863 }
864
865 void GenerateOopMap::push(CellTypeState cts) {
866 if ( _stack_top >= _max_stack) {
867 verify_error("stack overflow");
868 return;
869 }
870 stack()[_stack_top++] = cts;
871 }
872
873 CellTypeState GenerateOopMap::monitor_pop() {
874 assert(_monitor_top != bad_monitors, "monitor_pop called on error monitor stack");
875 if (_monitor_top == 0) {
876 // We have detected a pop of an empty monitor stack.
877 _monitor_safe = false;
878 _monitor_top = bad_monitors;
879
880 if (log_is_enabled(Info, monitormismatch)) {
881 report_monitor_mismatch("monitor stack underflow");
882 }
883 return CellTypeState::ref; // just to keep the analysis going.
884 }
885 return monitors()[--_monitor_top];
886 }
887
888 void GenerateOopMap::monitor_push(CellTypeState cts) {
889 assert(_monitor_top != bad_monitors, "monitor_push called on error monitor stack");
890 if (_monitor_top >= _max_monitors) {
891 // Some monitorenter is being executed more than once.
892 // This means that the monitor stack cannot be simulated.
893 _monitor_safe = false;
894 _monitor_top = bad_monitors;
895
896 if (log_is_enabled(Info, monitormismatch)) {
897 report_monitor_mismatch("monitor stack overflow");
898 }
899 return;
900 }
901 monitors()[_monitor_top++] = cts;
902 }
903
904 //
905 // Interpretation handling methods
906 //
907
908 void GenerateOopMap::do_interpretation()
909 {
910 // "i" is just for debugging, so we can detect cases where this loop is
911 // iterated more than once.
912 int i = 0;
913 do {
914 if (log_is_enabled(Trace, generateoopmap)) {
915 LogStream st(Log(generateoopmap)::trace());
916 st.print("Iteration #%d of do_interpretation loop, method:", i);
917 method()->print_name(&st);
918 st.print("\n\n");
919 }
920 _conflict = false;
921 _monitor_safe = true;
922 // init_state is now called from init_basic_blocks. The length of a
923 // state vector cannot be determined until we have made a pass through
924 // the bytecodes counting the possible monitor entries.
925 if (!_got_error) init_basic_blocks();
926 if (!_got_error) setup_method_entry_state();
927 if (!_got_error) interp_all();
928 if (!_got_error) rewrite_refval_conflicts();
929 i++;
930 } while (_conflict && !_got_error);
931 }
932
933 void GenerateOopMap::init_basic_blocks() {
934 // Note: Could consider reserving only the needed space for each BB's state
935 // (entry stack may not be of maximal height for every basic block).
936 // But cumbersome since we don't know the stack heights yet. (Nor the
937 // monitor stack heights...)
938
939 ALLOC_RESOURCE_ARRAY(_basic_blocks, BasicBlock, _bb_count);
940
941 // Make a pass through the bytecodes. Count the number of monitorenters.
942 // This can be used an upper bound on the monitor stack depth in programs
943 // which obey stack discipline with their monitor usage. Initialize the
944 // known information about basic blocks.
945 BytecodeStream j(_method);
946 Bytecodes::Code bytecode;
947
948 int bbNo = 0;
949 int monitor_count = 0;
950 int prev_bci = -1;
951 while( (bytecode = j.next()) >= 0) {
952 if (j.code() == Bytecodes::_monitorenter) {
953 monitor_count++;
954 }
955
956 int bci = j.bci();
957 if (is_bb_header(bci)) {
958 // Initialize the basicblock structure
959 BasicBlock *bb = _basic_blocks + bbNo;
960 bb->_bci = bci;
961 bb->_max_locals = _max_locals;
962 bb->_max_stack = _max_stack;
963 bb->set_changed(false);
964 bb->_stack_top = BasicBlock::_dead_basic_block; // Initialize all basicblocks are dead.
965 bb->_monitor_top = bad_monitors;
966
967 if (bbNo > 0) {
968 _basic_blocks[bbNo - 1]._end_bci = prev_bci;
969 }
970
971 bbNo++;
972 }
973 // Remember previous bci.
974 prev_bci = bci;
975 }
976 // Set
977 _basic_blocks[bbNo-1]._end_bci = prev_bci;
978
979
980 // Check that the correct number of basicblocks was found
981 if (bbNo !=_bb_count) {
982 if (bbNo < _bb_count) {
983 verify_error("jump into the middle of instruction?");
984 return;
985 } else {
986 verify_error("extra basic blocks - should not happen?");
987 return;
988 }
989 }
990
991 _max_monitors = monitor_count;
992
993 // Now that we have a bound on the depth of the monitor stack, we can
994 // initialize the CellTypeState-related information.
995 init_state();
996
997 // We allocate space for all state-vectors for all basicblocks in one huge
998 // chunk. Then in the next part of the code, we set a pointer in each
999 // _basic_block that points to each piece.
1000
1001 // The product of bbNo and _state_len can get large if there are lots of
1002 // basic blocks and stack/locals/monitors. Need to check to make sure
1003 // we don't overflow the capacity of a pointer.
1004 if ((unsigned)bbNo > UINTPTR_MAX / sizeof(CellTypeState) / _state_len) {
1005 report_error("The amount of memory required to analyze this method "
1006 "exceeds addressable range");
1007 return;
1008 }
1009
1010 CellTypeState *basicBlockState;
1011 ALLOC_RESOURCE_ARRAY(basicBlockState, CellTypeState, bbNo * _state_len);
1012 memset(basicBlockState, 0, bbNo * _state_len * sizeof(CellTypeState));
1013
1014 // Make a pass over the basicblocks and assign their state vectors.
1015 for (int blockNum=0; blockNum < bbNo; blockNum++) {
1016 BasicBlock *bb = _basic_blocks + blockNum;
1017 bb->_state = basicBlockState + blockNum * _state_len;
1018
1019 #ifdef ASSERT
1020 if (blockNum + 1 < bbNo) {
1021 address bcp = _method->bcp_from(bb->_end_bci);
1022 int bc_len = Bytecodes::java_length_at(_method(), bcp);
1023 assert(bb->_end_bci + bc_len == bb[1]._bci, "unmatched bci info in basicblock");
1024 }
1025 #endif
1026 }
1027 #ifdef ASSERT
1028 { BasicBlock *bb = &_basic_blocks[bbNo-1];
1029 address bcp = _method->bcp_from(bb->_end_bci);
1030 int bc_len = Bytecodes::java_length_at(_method(), bcp);
1031 assert(bb->_end_bci + bc_len == _method->code_size(), "wrong end bci");
1032 }
1033 #endif
1034
1035 // Mark all alive blocks
1036 mark_reachable_code();
1037 }
1038
1039 void GenerateOopMap::setup_method_entry_state() {
1040
1041 // Initialize all locals to 'uninit' and set stack-height to 0
1042 make_context_uninitialized();
1043
1044 // Initialize CellState type of arguments
1045 methodsig_to_effect(method()->signature(), method()->is_static(), vars());
1046
1047 // If some references must be pre-assigned to null, then set that up
1048 initialize_vars();
1049
1050 // This is the start state
1051 merge_state_into_bb(&_basic_blocks[0]);
1052
1053 assert(_basic_blocks[0].changed(), "we are not getting off the ground");
1054 }
1055
1056 // The instruction at bci is changing size by "delta". Update the basic blocks.
1057 void GenerateOopMap::update_basic_blocks(int bci, int delta,
1058 int new_method_size) {
1059 assert(new_method_size >= method()->code_size() + delta,
1060 "new method size is too small");
1061
1062 _bb_hdr_bits.reinitialize(new_method_size);
1063
1064 for(int k = 0; k < _bb_count; k++) {
1065 if (_basic_blocks[k]._bci > bci) {
1066 _basic_blocks[k]._bci += delta;
1067 _basic_blocks[k]._end_bci += delta;
1068 }
1069 _bb_hdr_bits.at_put(_basic_blocks[k]._bci, true);
1070 }
1071 }
1072
1073 //
1074 // Initvars handling
1075 //
1076
1077 void GenerateOopMap::initialize_vars() {
1078 for (int k = 0; k < _init_vars->length(); k++)
1079 _state[_init_vars->at(k)] = CellTypeState::make_slot_ref(k);
1080 }
1081
1082 void GenerateOopMap::add_to_ref_init_set(int localNo) {
1083
1084 log_debug(generateoopmap)("Added init vars: %d", localNo);
1085
1086 // Is it already in the set?
1087 if (_init_vars->contains(localNo) )
1088 return;
1089
1090 _init_vars->append(localNo);
1091 }
1092
1093 //
1094 // Interpreration code
1095 //
1096
1097 void GenerateOopMap::interp_all() {
1098 bool change = true;
1099
1100 while (change && !_got_error) {
1101 change = false;
1102 for (int i = 0; i < _bb_count && !_got_error; i++) {
1103 BasicBlock *bb = &_basic_blocks[i];
1104 if (bb->changed()) {
1105 if (_got_error) return;
1106 change = true;
1107 bb->set_changed(false);
1108 interp_bb(bb);
1109 }
1110 }
1111 }
1112 }
1113
1114 void GenerateOopMap::interp_bb(BasicBlock *bb) {
1115
1116 // We do not want to do anything in case the basic-block has not been initialized. This
1117 // will happen in the case where there is dead-code hang around in a method.
1118 assert(bb->is_reachable(), "should be reachable or deadcode exist");
1119 restore_state(bb);
1120
1121 BytecodeStream itr(_method);
1122
1123 // Set iterator interval to be the current basicblock
1124 int lim_bci = next_bb_start_pc(bb);
1125 itr.set_interval(bb->_bci, lim_bci);
1126 assert(lim_bci != bb->_bci, "must be at least one instruction in a basicblock");
1127 itr.next(); // read first instruction
1128
1129 // Iterates through all bytecodes except the last in a basic block.
1130 // We handle the last one special, since there is controlflow change.
1131 while(itr.next_bci() < lim_bci && !_got_error) {
1132 if (_has_exceptions || _monitor_top != 0) {
1133 // We do not need to interpret the results of exceptional
1134 // continuation from this instruction when the method has no
1135 // exception handlers and the monitor stack is currently
1136 // empty.
1137 do_exception_edge(&itr);
1138 }
1139 interp1(&itr);
1140 itr.next();
1141 }
1142
1143 // Handle last instruction.
1144 if (!_got_error) {
1145 assert(itr.next_bci() == lim_bci, "must point to end");
1146 if (_has_exceptions || _monitor_top != 0) {
1147 do_exception_edge(&itr);
1148 }
1149 interp1(&itr);
1150
1151 bool fall_through = jump_targets_do(&itr, GenerateOopMap::merge_state, nullptr);
1152 if (_got_error) return;
1153
1154 if (itr.code() == Bytecodes::_ret) {
1155 assert(!fall_through, "cannot be set if ret instruction");
1156 // Automatically handles 'wide' ret indices
1157 ret_jump_targets_do(&itr, GenerateOopMap::merge_state, itr.get_index(), nullptr);
1158 } else if (fall_through) {
1159 // Hit end of BB, but the instr. was a fall-through instruction,
1160 // so perform transition as if the BB ended in a "jump".
1161 if (lim_bci != bb[1]._bci) {
1162 verify_error("bytecodes fell through last instruction");
1163 return;
1164 }
1165 merge_state_into_bb(bb + 1);
1166 }
1167 }
1168 }
1169
1170 void GenerateOopMap::do_exception_edge(BytecodeStream* itr) {
1171
1172 // Only check exception edge, if bytecode can trap or if async exceptions can be thrown
1173 // from any bytecode in the interpreter when single stepping.
1174 if (!_all_exception_edges) {
1175 if (!Bytecodes::can_trap(itr->code())) return;
1176 switch (itr->code()) {
1177 case Bytecodes::_aload_0:
1178 // These bytecodes can trap for rewriting. We need to assume that
1179 // they do not throw exceptions to make the monitor analysis work.
1180 return;
1181
1182 case Bytecodes::_ireturn:
1183 case Bytecodes::_lreturn:
1184 case Bytecodes::_freturn:
1185 case Bytecodes::_dreturn:
1186 case Bytecodes::_areturn:
1187 case Bytecodes::_return:
1188 // If the monitor stack height is not zero when we leave the method,
1189 // then we are either exiting with a non-empty stack or we have
1190 // found monitor trouble earlier in our analysis. In either case,
1191 // assume an exception could be taken here.
1192 if (_monitor_top == 0) {
1193 return;
1194 }
1195 break;
1196
1197 case Bytecodes::_monitorexit:
1198 // If the monitor stack height is bad_monitors, then we have detected a
1199 // monitor matching problem earlier in the analysis. If the
1200 // monitor stack height is 0, we are about to pop a monitor
1201 // off of an empty stack. In either case, the bytecode
1202 // could throw an exception.
1203 if (_monitor_top != bad_monitors && _monitor_top != 0) {
1204 return;
1205 }
1206 break;
1207
1208 default:
1209 break;
1210 }
1211 }
1212
1213 if (_has_exceptions) {
1214 int bci = itr->bci();
1215 ExceptionTable exct(method());
1216 for(int i = 0; i< exct.length(); i++) {
1217 int start_pc = exct.start_pc(i);
1218 int end_pc = exct.end_pc(i);
1219 int handler_pc = exct.handler_pc(i);
1220 int catch_type = exct.catch_type_index(i);
1221
1222 if (start_pc <= bci && bci < end_pc) {
1223 BasicBlock *excBB = get_basic_block_at(handler_pc);
1224 guarantee(excBB != nullptr, "no basic block for exception");
1225 CellTypeState *excStk = excBB->stack();
1226 CellTypeState *cOpStck = stack();
1227 CellTypeState cOpStck_0 = cOpStck[0];
1228 int cOpStackTop = _stack_top;
1229
1230 // Exception stacks are always the same.
1231 assert(method()->max_stack() > 0, "sanity check");
1232
1233 // We remembered the size and first element of "cOpStck"
1234 // above; now we temporarily set them to the appropriate
1235 // values for an exception handler. */
1236 cOpStck[0] = CellTypeState::make_slot_ref(_max_locals);
1237 _stack_top = 1;
1238
1239 merge_state_into_bb(excBB);
1240
1241 // Now undo the temporary change.
1242 cOpStck[0] = cOpStck_0;
1243 _stack_top = cOpStackTop;
1244
1245 // If this is a "catch all" handler, then we do not need to
1246 // consider any additional handlers.
1247 if (catch_type == 0) {
1248 return;
1249 }
1250 }
1251 }
1252 }
1253
1254 // It is possible that none of the exception handlers would have caught
1255 // the exception. In this case, we will exit the method. We must
1256 // ensure that the monitor stack is empty in this case.
1257 if (_monitor_top == 0) {
1258 return;
1259 }
1260
1261 // We pessimistically assume that this exception can escape the
1262 // method. (It is possible that it will always be caught, but
1263 // we don't care to analyse the types of the catch clauses.)
1264
1265 // We don't set _monitor_top to bad_monitors because there are no successors
1266 // to this exceptional exit.
1267
1268 if (log_is_enabled(Info, monitormismatch) && _monitor_safe) {
1269 // We check _monitor_safe so that we only report the first mismatched
1270 // exceptional exit.
1271 report_monitor_mismatch("non-empty monitor stack at exceptional exit");
1272 }
1273 _monitor_safe = false;
1274
1275 }
1276
1277 void GenerateOopMap::report_monitor_mismatch(const char *msg) {
1278 LogStream ls(Log(monitormismatch)::info());
1279 ls.print("Monitor mismatch in method ");
1280 method()->print_short_name(&ls);
1281 ls.print_cr(": %s", msg);
1282 }
1283
1284 void GenerateOopMap::print_states(outputStream *os,
1285 CellTypeState* vec, int num) {
1286 for (int i = 0; i < num; i++) {
1287 vec[i].print(os);
1288 }
1289 }
1290
1291 // Print the state values at the current bytecode.
1292 void GenerateOopMap::print_current_state(outputStream* os,
1293 BytecodeStream* currentBC,
1294 bool detailed) {
1295 if (detailed) {
1296 os->print(" %4d vars = ", currentBC->bci());
1297 print_states(os, vars(), _max_locals);
1298 os->print(" %s", Bytecodes::name(currentBC->code()));
1299 } else {
1300 os->print(" %4d vars = '%s' ", currentBC->bci(), state_vec_to_string(vars(), _max_locals));
1301 os->print(" stack = '%s' ", state_vec_to_string(stack(), _stack_top));
1302 if (_monitor_top != bad_monitors) {
1303 os->print(" monitors = '%s' \t%s", state_vec_to_string(monitors(), _monitor_top), Bytecodes::name(currentBC->code()));
1304 } else {
1305 os->print(" [bad monitor stack]");
1306 }
1307 }
1308
1309 switch(currentBC->code()) {
1310 case Bytecodes::_invokevirtual:
1311 case Bytecodes::_invokespecial:
1312 case Bytecodes::_invokestatic:
1313 case Bytecodes::_invokedynamic:
1314 case Bytecodes::_invokeinterface: {
1315 ResourceMark rm;
1316 int idx = currentBC->has_index_u4() ? currentBC->get_index_u4() : currentBC->get_index_u2();
1317 ConstantPool* cp = method()->constants();
1318 int nameAndTypeIdx = cp->name_and_type_ref_index_at(idx, currentBC->code());
1319 int signatureIdx = cp->signature_ref_index_at(nameAndTypeIdx);
1320 Symbol* signature = cp->symbol_at(signatureIdx);
1321 os->print("%s", signature->as_C_string());
1322 }
1323 default:
1324 break;
1325 }
1326
1327 if (detailed) {
1328 os->cr();
1329 os->print(" stack = ");
1330 print_states(os, stack(), _stack_top);
1331 os->cr();
1332 if (_monitor_top != bad_monitors) {
1333 os->print(" monitors = ");
1334 print_states(os, monitors(), _monitor_top);
1335 } else {
1336 os->print(" [bad monitor stack]");
1337 }
1338 }
1339
1340 os->cr();
1341 }
1342
1343 // Sets the current state to be the state after executing the
1344 // current instruction, starting in the current state.
1345 void GenerateOopMap::interp1(BytecodeStream *itr) {
1346 if (log_is_enabled(Trace, generateoopmap)) {
1347 LogStream st(Log(generateoopmap)::trace());
1348 print_current_state(&st, itr, Verbose);
1349 }
1350
1351 // Should we report the results? Result is reported *before* the instruction at the current bci is executed.
1352 // However, not for calls. For calls we do not want to include the arguments, so we postpone the reporting until
1353 // they have been popped (in method ppl).
1354 if (_report_result == true) {
1355 switch(itr->code()) {
1356 case Bytecodes::_invokevirtual:
1357 case Bytecodes::_invokespecial:
1358 case Bytecodes::_invokestatic:
1359 case Bytecodes::_invokedynamic:
1360 case Bytecodes::_invokeinterface:
1361 _itr_send = itr;
1362 _report_result_for_send = true;
1363 break;
1364 default:
1365 fill_stackmap_for_opcodes(itr, vars(), stack(), _stack_top);
1366 break;
1367 }
1368 }
1369
1370 // abstract interpretation of current opcode
1371 switch(itr->code()) {
1372 case Bytecodes::_nop: break;
1373 case Bytecodes::_goto: break;
1374 case Bytecodes::_goto_w: break;
1375 case Bytecodes::_iinc: break;
1376 case Bytecodes::_return: do_return_monitor_check();
1377 break;
1378
1379 case Bytecodes::_aconst_null:
1380 case Bytecodes::_new: ppush1(CellTypeState::make_line_ref(itr->bci()));
1381 break;
1382
1383 case Bytecodes::_iconst_m1:
1384 case Bytecodes::_iconst_0:
1385 case Bytecodes::_iconst_1:
1386 case Bytecodes::_iconst_2:
1387 case Bytecodes::_iconst_3:
1388 case Bytecodes::_iconst_4:
1389 case Bytecodes::_iconst_5:
1390 case Bytecodes::_fconst_0:
1391 case Bytecodes::_fconst_1:
1392 case Bytecodes::_fconst_2:
1393 case Bytecodes::_bipush:
1394 case Bytecodes::_sipush: ppush1(valCTS); break;
1395
1396 case Bytecodes::_lconst_0:
1397 case Bytecodes::_lconst_1:
1398 case Bytecodes::_dconst_0:
1399 case Bytecodes::_dconst_1: ppush(vvCTS); break;
1400
1401 case Bytecodes::_ldc2_w: ppush(vvCTS); break;
1402
1403 case Bytecodes::_ldc: // fall through:
1404 case Bytecodes::_ldc_w: do_ldc(itr->bci()); break;
1405
1406 case Bytecodes::_iload:
1407 case Bytecodes::_fload: ppload(vCTS, itr->get_index()); break;
1408
1409 case Bytecodes::_lload:
1410 case Bytecodes::_dload: ppload(vvCTS,itr->get_index()); break;
1411
1412 case Bytecodes::_aload: ppload(rCTS, itr->get_index()); break;
1413
1414 case Bytecodes::_iload_0:
1415 case Bytecodes::_fload_0: ppload(vCTS, 0); break;
1416 case Bytecodes::_iload_1:
1417 case Bytecodes::_fload_1: ppload(vCTS, 1); break;
1418 case Bytecodes::_iload_2:
1419 case Bytecodes::_fload_2: ppload(vCTS, 2); break;
1420 case Bytecodes::_iload_3:
1421 case Bytecodes::_fload_3: ppload(vCTS, 3); break;
1422
1423 case Bytecodes::_lload_0:
1424 case Bytecodes::_dload_0: ppload(vvCTS, 0); break;
1425 case Bytecodes::_lload_1:
1426 case Bytecodes::_dload_1: ppload(vvCTS, 1); break;
1427 case Bytecodes::_lload_2:
1428 case Bytecodes::_dload_2: ppload(vvCTS, 2); break;
1429 case Bytecodes::_lload_3:
1430 case Bytecodes::_dload_3: ppload(vvCTS, 3); break;
1431
1432 case Bytecodes::_aload_0: ppload(rCTS, 0); break;
1433 case Bytecodes::_aload_1: ppload(rCTS, 1); break;
1434 case Bytecodes::_aload_2: ppload(rCTS, 2); break;
1435 case Bytecodes::_aload_3: ppload(rCTS, 3); break;
1436
1437 case Bytecodes::_iaload:
1438 case Bytecodes::_faload:
1439 case Bytecodes::_baload:
1440 case Bytecodes::_caload:
1441 case Bytecodes::_saload: pp(vrCTS, vCTS); break;
1442
1443 case Bytecodes::_laload: pp(vrCTS, vvCTS); break;
1444 case Bytecodes::_daload: pp(vrCTS, vvCTS); break;
1445
1446 case Bytecodes::_aaload: pp_new_ref(vrCTS, itr->bci()); break;
1447
1448 case Bytecodes::_istore:
1449 case Bytecodes::_fstore: ppstore(vCTS, itr->get_index()); break;
1450
1451 case Bytecodes::_lstore:
1452 case Bytecodes::_dstore: ppstore(vvCTS, itr->get_index()); break;
1453
1454 case Bytecodes::_astore: do_astore(itr->get_index()); break;
1455
1456 case Bytecodes::_istore_0:
1457 case Bytecodes::_fstore_0: ppstore(vCTS, 0); break;
1458 case Bytecodes::_istore_1:
1459 case Bytecodes::_fstore_1: ppstore(vCTS, 1); break;
1460 case Bytecodes::_istore_2:
1461 case Bytecodes::_fstore_2: ppstore(vCTS, 2); break;
1462 case Bytecodes::_istore_3:
1463 case Bytecodes::_fstore_3: ppstore(vCTS, 3); break;
1464
1465 case Bytecodes::_lstore_0:
1466 case Bytecodes::_dstore_0: ppstore(vvCTS, 0); break;
1467 case Bytecodes::_lstore_1:
1468 case Bytecodes::_dstore_1: ppstore(vvCTS, 1); break;
1469 case Bytecodes::_lstore_2:
1470 case Bytecodes::_dstore_2: ppstore(vvCTS, 2); break;
1471 case Bytecodes::_lstore_3:
1472 case Bytecodes::_dstore_3: ppstore(vvCTS, 3); break;
1473
1474 case Bytecodes::_astore_0: do_astore(0); break;
1475 case Bytecodes::_astore_1: do_astore(1); break;
1476 case Bytecodes::_astore_2: do_astore(2); break;
1477 case Bytecodes::_astore_3: do_astore(3); break;
1478
1479 case Bytecodes::_iastore:
1480 case Bytecodes::_fastore:
1481 case Bytecodes::_bastore:
1482 case Bytecodes::_castore:
1483 case Bytecodes::_sastore: ppop(vvrCTS); break;
1484 case Bytecodes::_lastore:
1485 case Bytecodes::_dastore: ppop(vvvrCTS); break;
1486 case Bytecodes::_aastore: ppop(rvrCTS); break;
1487
1488 case Bytecodes::_pop: ppop_any(1); break;
1489 case Bytecodes::_pop2: ppop_any(2); break;
1490
1491 case Bytecodes::_dup: ppdupswap(1, "11"); break;
1492 case Bytecodes::_dup_x1: ppdupswap(2, "121"); break;
1493 case Bytecodes::_dup_x2: ppdupswap(3, "1321"); break;
1494 case Bytecodes::_dup2: ppdupswap(2, "2121"); break;
1495 case Bytecodes::_dup2_x1: ppdupswap(3, "21321"); break;
1496 case Bytecodes::_dup2_x2: ppdupswap(4, "214321"); break;
1497 case Bytecodes::_swap: ppdupswap(2, "12"); break;
1498
1499 case Bytecodes::_iadd:
1500 case Bytecodes::_fadd:
1501 case Bytecodes::_isub:
1502 case Bytecodes::_fsub:
1503 case Bytecodes::_imul:
1504 case Bytecodes::_fmul:
1505 case Bytecodes::_idiv:
1506 case Bytecodes::_fdiv:
1507 case Bytecodes::_irem:
1508 case Bytecodes::_frem:
1509 case Bytecodes::_ishl:
1510 case Bytecodes::_ishr:
1511 case Bytecodes::_iushr:
1512 case Bytecodes::_iand:
1513 case Bytecodes::_ior:
1514 case Bytecodes::_ixor:
1515 case Bytecodes::_l2f:
1516 case Bytecodes::_l2i:
1517 case Bytecodes::_d2f:
1518 case Bytecodes::_d2i:
1519 case Bytecodes::_fcmpl:
1520 case Bytecodes::_fcmpg: pp(vvCTS, vCTS); break;
1521
1522 case Bytecodes::_ladd:
1523 case Bytecodes::_dadd:
1524 case Bytecodes::_lsub:
1525 case Bytecodes::_dsub:
1526 case Bytecodes::_lmul:
1527 case Bytecodes::_dmul:
1528 case Bytecodes::_ldiv:
1529 case Bytecodes::_ddiv:
1530 case Bytecodes::_lrem:
1531 case Bytecodes::_drem:
1532 case Bytecodes::_land:
1533 case Bytecodes::_lor:
1534 case Bytecodes::_lxor: pp(vvvvCTS, vvCTS); break;
1535
1536 case Bytecodes::_ineg:
1537 case Bytecodes::_fneg:
1538 case Bytecodes::_i2f:
1539 case Bytecodes::_f2i:
1540 case Bytecodes::_i2c:
1541 case Bytecodes::_i2s:
1542 case Bytecodes::_i2b: pp(vCTS, vCTS); break;
1543
1544 case Bytecodes::_lneg:
1545 case Bytecodes::_dneg:
1546 case Bytecodes::_l2d:
1547 case Bytecodes::_d2l: pp(vvCTS, vvCTS); break;
1548
1549 case Bytecodes::_lshl:
1550 case Bytecodes::_lshr:
1551 case Bytecodes::_lushr: pp(vvvCTS, vvCTS); break;
1552
1553 case Bytecodes::_i2l:
1554 case Bytecodes::_i2d:
1555 case Bytecodes::_f2l:
1556 case Bytecodes::_f2d: pp(vCTS, vvCTS); break;
1557
1558 case Bytecodes::_lcmp: pp(vvvvCTS, vCTS); break;
1559 case Bytecodes::_dcmpl:
1560 case Bytecodes::_dcmpg: pp(vvvvCTS, vCTS); break;
1561
1562 case Bytecodes::_ifeq:
1563 case Bytecodes::_ifne:
1564 case Bytecodes::_iflt:
1565 case Bytecodes::_ifge:
1566 case Bytecodes::_ifgt:
1567 case Bytecodes::_ifle:
1568 case Bytecodes::_tableswitch: ppop1(valCTS);
1569 break;
1570 case Bytecodes::_ireturn:
1571 case Bytecodes::_freturn: do_return_monitor_check();
1572 ppop1(valCTS);
1573 break;
1574 case Bytecodes::_if_icmpeq:
1575 case Bytecodes::_if_icmpne:
1576 case Bytecodes::_if_icmplt:
1577 case Bytecodes::_if_icmpge:
1578 case Bytecodes::_if_icmpgt:
1579 case Bytecodes::_if_icmple: ppop(vvCTS);
1580 break;
1581
1582 case Bytecodes::_lreturn: do_return_monitor_check();
1583 ppop(vvCTS);
1584 break;
1585
1586 case Bytecodes::_dreturn: do_return_monitor_check();
1587 ppop(vvCTS);
1588 break;
1589
1590 case Bytecodes::_if_acmpeq:
1591 case Bytecodes::_if_acmpne: ppop(rrCTS); break;
1592
1593 case Bytecodes::_jsr: do_jsr(itr->dest()); break;
1594 case Bytecodes::_jsr_w: do_jsr(itr->dest_w()); break;
1595
1596 case Bytecodes::_getstatic: do_field(true, true, itr->get_index_u2(), itr->bci(), itr->code()); break;
1597 case Bytecodes::_putstatic: do_field(false, true, itr->get_index_u2(), itr->bci(), itr->code()); break;
1598 case Bytecodes::_getfield: do_field(true, false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1599 case Bytecodes::_putfield: do_field(false, false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1600
1601 case Bytecodes::_invokevirtual:
1602 case Bytecodes::_invokespecial: do_method(false, false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1603 case Bytecodes::_invokestatic: do_method(true, false, itr->get_index_u2(), itr->bci(), itr->code()); break;
1604 case Bytecodes::_invokedynamic: do_method(true, false, itr->get_index_u4(), itr->bci(), itr->code()); break;
1605 case Bytecodes::_invokeinterface: do_method(false, true, itr->get_index_u2(), itr->bci(), itr->code()); break;
1606 case Bytecodes::_newarray:
1607 case Bytecodes::_anewarray: pp_new_ref(vCTS, itr->bci()); break;
1608 case Bytecodes::_checkcast: do_checkcast(); break;
1609 case Bytecodes::_arraylength:
1610 case Bytecodes::_instanceof: pp(rCTS, vCTS); break;
1611 case Bytecodes::_monitorenter: do_monitorenter(itr->bci()); break;
1612 case Bytecodes::_monitorexit: do_monitorexit(itr->bci()); break;
1613
1614 case Bytecodes::_athrow: // handled by do_exception_edge() BUT ...
1615 // vlh(apple): do_exception_edge() does not get
1616 // called if method has no exception handlers
1617 if ((!_has_exceptions) && (_monitor_top > 0)) {
1618 _monitor_safe = false;
1619 }
1620 break;
1621
1622 case Bytecodes::_areturn: do_return_monitor_check();
1623 ppop1(refCTS);
1624 break;
1625 case Bytecodes::_ifnull:
1626 case Bytecodes::_ifnonnull: ppop1(refCTS); break;
1627 case Bytecodes::_multianewarray: do_multianewarray(*(itr->bcp()+3), itr->bci()); break;
1628
1629 case Bytecodes::_wide: fatal("Iterator should skip this bytecode"); break;
1630 case Bytecodes::_ret: break;
1631
1632 // Java opcodes
1633 case Bytecodes::_lookupswitch: ppop1(valCTS); break;
1634
1635 default:
1636 tty->print("unexpected opcode: %d\n", itr->code());
1637 ShouldNotReachHere();
1638 break;
1639 }
1640 }
1641
1642 void GenerateOopMap::check_type(CellTypeState expected, CellTypeState actual) {
1643 if (!expected.equal_kind(actual)) {
1644 verify_error("wrong type on stack (found: %c expected: %c)", actual.to_char(), expected.to_char());
1645 }
1646 }
1647
1648 void GenerateOopMap::ppstore(CellTypeState *in, int loc_no) {
1649 while(!(*in).is_bottom()) {
1650 CellTypeState expected =*in++;
1651 CellTypeState actual = pop();
1652 check_type(expected, actual);
1653 assert(loc_no >= 0, "sanity check");
1654 set_var(loc_no++, actual);
1655 }
1656 }
1657
1658 void GenerateOopMap::ppload(CellTypeState *out, int loc_no) {
1659 while(!(*out).is_bottom()) {
1660 CellTypeState out1 = *out++;
1661 CellTypeState vcts = get_var(loc_no);
1662 assert(out1.can_be_reference() || out1.can_be_value(),
1663 "can only load refs. and values.");
1664 if (out1.is_reference()) {
1665 assert(loc_no>=0, "sanity check");
1666 if (!vcts.is_reference()) {
1667 // We were asked to push a reference, but the type of the
1668 // variable can be something else
1669 _conflict = true;
1670 if (vcts.can_be_uninit()) {
1671 // It is a ref-uninit conflict (at least). If there are other
1672 // problems, we'll get them in the next round
1673 add_to_ref_init_set(loc_no);
1674 vcts = out1;
1675 } else {
1676 // It wasn't a ref-uninit conflict. So must be a
1677 // ref-val or ref-pc conflict. Split the variable.
1678 record_refval_conflict(loc_no);
1679 vcts = out1;
1680 }
1681 push(out1); // recover...
1682 } else {
1683 push(vcts); // preserve reference.
1684 }
1685 // Otherwise it is a conflict, but one that verification would
1686 // have caught if illegal. In particular, it can't be a topCTS
1687 // resulting from mergeing two difference pcCTS's since the verifier
1688 // would have rejected any use of such a merge.
1689 } else {
1690 push(out1); // handle val/init conflict
1691 }
1692 loc_no++;
1693 }
1694 }
1695
1696 void GenerateOopMap::ppdupswap(int poplen, const char *out) {
1697 CellTypeState actual[5];
1698 assert(poplen < 5, "this must be less than length of actual vector");
1699
1700 // Pop all arguments.
1701 for (int i = 0; i < poplen; i++) {
1702 actual[i] = pop();
1703 }
1704 // Field _state is uninitialized when calling push.
1705 for (int i = poplen; i < 5; i++) {
1706 actual[i] = CellTypeState::uninit;
1707 }
1708
1709 // put them back
1710 char push_ch = *out++;
1711 while (push_ch != '\0') {
1712 int idx = push_ch - '1';
1713 assert(idx >= 0 && idx < poplen, "wrong arguments");
1714 push(actual[idx]);
1715 push_ch = *out++;
1716 }
1717 }
1718
1719 void GenerateOopMap::ppop1(CellTypeState out) {
1720 CellTypeState actual = pop();
1721 check_type(out, actual);
1722 }
1723
1724 void GenerateOopMap::ppop(CellTypeState *out) {
1725 while (!(*out).is_bottom()) {
1726 ppop1(*out++);
1727 }
1728 }
1729
1730 void GenerateOopMap::ppush1(CellTypeState in) {
1731 assert(in.is_reference() || in.is_value(), "sanity check");
1732 push(in);
1733 }
1734
1735 void GenerateOopMap::ppush(CellTypeState *in) {
1736 while (!(*in).is_bottom()) {
1737 ppush1(*in++);
1738 }
1739 }
1740
1741 void GenerateOopMap::pp(CellTypeState *in, CellTypeState *out) {
1742 ppop(in);
1743 ppush(out);
1744 }
1745
1746 void GenerateOopMap::pp_new_ref(CellTypeState *in, int bci) {
1747 ppop(in);
1748 ppush1(CellTypeState::make_line_ref(bci));
1749 }
1750
1751 void GenerateOopMap::ppop_any(int poplen) {
1752 if (_stack_top >= poplen) {
1753 _stack_top -= poplen;
1754 } else {
1755 verify_error("stack underflow");
1756 }
1757 }
1758
1759 // Replace all occurrences of the state 'match' with the state 'replace'
1760 // in our current state vector.
1761 void GenerateOopMap::replace_all_CTS_matches(CellTypeState match,
1762 CellTypeState replace) {
1763 int i;
1764 int len = _max_locals + _stack_top;
1765 bool change = false;
1766
1767 for (i = len - 1; i >= 0; i--) {
1768 if (match.equal(_state[i])) {
1769 _state[i] = replace;
1770 }
1771 }
1772
1773 if (_monitor_top > 0) {
1774 int base = _max_locals + _max_stack;
1775 len = base + _monitor_top;
1776 for (i = len - 1; i >= base; i--) {
1777 if (match.equal(_state[i])) {
1778 _state[i] = replace;
1779 }
1780 }
1781 }
1782 }
1783
1784 void GenerateOopMap::do_checkcast() {
1785 CellTypeState actual = pop();
1786 check_type(refCTS, actual);
1787 push(actual);
1788 }
1789
1790 void GenerateOopMap::do_monitorenter(int bci) {
1791 CellTypeState actual = pop();
1792 if (_monitor_top == bad_monitors) {
1793 return;
1794 }
1795
1796 // Bail out when we get repeated locks on an identical monitor. This case
1797 // isn't too hard to handle and can be made to work if supporting nested
1798 // redundant synchronized statements becomes a priority.
1799 //
1800 // See also "Note" in do_monitorexit(), below.
1801 if (actual.is_lock_reference()) {
1802 _monitor_top = bad_monitors;
1803 _monitor_safe = false;
1804
1805 if (log_is_enabled(Info, monitormismatch)) {
1806 report_monitor_mismatch("nested redundant lock -- bailout...");
1807 }
1808 return;
1809 }
1810
1811 CellTypeState lock = CellTypeState::make_lock_ref(bci);
1812 check_type(refCTS, actual);
1813 if (!actual.is_info_top()) {
1814 replace_all_CTS_matches(actual, lock);
1815 monitor_push(lock);
1816 }
1817 }
1818
1819 void GenerateOopMap::do_monitorexit(int bci) {
1820 CellTypeState actual = pop();
1821 if (_monitor_top == bad_monitors) {
1822 return;
1823 }
1824 check_type(refCTS, actual);
1825 CellTypeState expected = monitor_pop();
1826 if (!actual.is_lock_reference() || !expected.equal(actual)) {
1827 // The monitor we are exiting is not verifiably the one
1828 // on the top of our monitor stack. This causes a monitor
1829 // mismatch.
1830 _monitor_top = bad_monitors;
1831 _monitor_safe = false;
1832
1833 // We need to mark this basic block as changed so that
1834 // this monitorexit will be visited again. We need to
1835 // do this to ensure that we have accounted for the
1836 // possibility that this bytecode will throw an
1837 // exception.
1838 BasicBlock* bb = get_basic_block_containing(bci);
1839 guarantee(bb != nullptr, "no basic block for bci");
1840 bb->set_changed(true);
1841 bb->_monitor_top = bad_monitors;
1842
1843 if (log_is_enabled(Info, monitormismatch)) {
1844 report_monitor_mismatch("improper monitor pair");
1845 }
1846 } else {
1847 // This code is a fix for the case where we have repeated
1848 // locking of the same object in straightline code. We clear
1849 // out the lock when it is popped from the monitor stack
1850 // and replace it with an unobtrusive reference value that can
1851 // be locked again.
1852 //
1853 // Note: when generateOopMap is fixed to properly handle repeated,
1854 // nested, redundant locks on the same object, then this
1855 // fix will need to be removed at that time.
1856 replace_all_CTS_matches(actual, CellTypeState::make_line_ref(bci));
1857 }
1858 }
1859
1860 void GenerateOopMap::do_return_monitor_check() {
1861 if (_monitor_top > 0) {
1862 // The monitor stack must be empty when we leave the method
1863 // for the monitors to be properly matched.
1864 _monitor_safe = false;
1865
1866 // Since there are no successors to the *return bytecode, it
1867 // isn't necessary to set _monitor_top to bad_monitors.
1868
1869 if (log_is_enabled(Info, monitormismatch)) {
1870 report_monitor_mismatch("non-empty monitor stack at return");
1871 }
1872 }
1873 }
1874
1875 void GenerateOopMap::do_jsr(int targ_bci) {
1876 push(CellTypeState::make_addr(targ_bci));
1877 }
1878
1879
1880
1881 void GenerateOopMap::do_ldc(int bci) {
1882 Bytecode_loadconstant ldc(methodHandle(Thread::current(), method()), bci);
1883 ConstantPool* cp = method()->constants();
1884 constantTag tag = cp->tag_at(ldc.pool_index()); // idx is index in resolved_references
1885 BasicType bt = ldc.result_type();
1886 #ifdef ASSERT
1887 BasicType tag_bt = (tag.is_dynamic_constant() || tag.is_dynamic_constant_in_error()) ? bt : tag.basic_type();
1888 assert(bt == tag_bt, "same result");
1889 #endif
1890 CellTypeState cts;
1891 if (is_reference_type(bt)) { // could be T_ARRAY with condy
1892 assert(!tag.is_string_index() && !tag.is_klass_index(), "Unexpected index tag");
1893 cts = CellTypeState::make_line_ref(bci);
1894 } else {
1895 cts = valCTS;
1896 }
1897 ppush1(cts);
1898 }
1899
1900 void GenerateOopMap::do_multianewarray(int dims, int bci) {
1901 assert(dims >= 1, "sanity check");
1902 for(int i = dims -1; i >=0; i--) {
1903 ppop1(valCTS);
1904 }
1905 ppush1(CellTypeState::make_line_ref(bci));
1906 }
1907
1908 void GenerateOopMap::do_astore(int idx) {
1909 CellTypeState r_or_p = pop();
1910 if (!r_or_p.is_address() && !r_or_p.is_reference()) {
1911 // We actually expected ref or pc, but we only report that we expected a ref. It does not
1912 // really matter (at least for now)
1913 verify_error("wrong type on stack (found: %c, expected: {pr})", r_or_p.to_char());
1914 return;
1915 }
1916 set_var(idx, r_or_p);
1917 }
1918
1919 // Copies bottom/zero terminated CTS string from "src" into "dst".
1920 // Does NOT terminate with a bottom. Returns the number of cells copied.
1921 int GenerateOopMap::copy_cts(CellTypeState *dst, CellTypeState *src) {
1922 int idx = 0;
1923 while (!src[idx].is_bottom()) {
1924 dst[idx] = src[idx];
1925 idx++;
1926 }
1927 return idx;
1928 }
1929
1930 void GenerateOopMap::do_field(int is_get, int is_static, int idx, int bci, Bytecodes::Code bc) {
1931 // Dig up signature for field in constant pool
1932 ConstantPool* cp = method()->constants();
1933 int nameAndTypeIdx = cp->name_and_type_ref_index_at(idx, bc);
1934 int signatureIdx = cp->signature_ref_index_at(nameAndTypeIdx);
1935 Symbol* signature = cp->symbol_at(signatureIdx);
1936
1937 CellTypeState temp[4];
1938 CellTypeState *eff = signature_to_effect(signature, bci, temp);
1939
1940 CellTypeState in[4];
1941 CellTypeState *out;
1942 int i = 0;
1943
1944 if (is_get) {
1945 out = eff;
1946 } else {
1947 out = epsilonCTS;
1948 i = copy_cts(in, eff);
1949 }
1950 if (!is_static) in[i++] = CellTypeState::ref;
1951 in[i] = CellTypeState::bottom;
1952 assert(i<=3, "sanity check");
1953 pp(in, out);
1954 }
1955
1956 void GenerateOopMap::do_method(int is_static, int is_interface, int idx, int bci, Bytecodes::Code bc) {
1957 // Dig up signature for field in constant pool
1958 ConstantPool* cp = _method->constants();
1959 Symbol* signature = cp->signature_ref_at(idx, bc);
1960
1961 // Parse method signature
1962 CellTypeState out[4];
1963 CellTypeState in[MAXARGSIZE+1]; // Includes result
1964 ComputeCallStack cse(signature);
1965
1966 // Compute return type
1967 int res_length= cse.compute_for_returntype(out);
1968
1969 // Temporary hack.
1970 if (out[0].equal(CellTypeState::ref) && out[1].equal(CellTypeState::bottom)) {
1971 out[0] = CellTypeState::make_line_ref(bci);
1972 }
1973
1974 assert(res_length<=4, "max value should be vv");
1975
1976 // Compute arguments
1977 int arg_length = cse.compute_for_parameters(is_static != 0, in);
1978 assert(arg_length<=MAXARGSIZE, "too many locals");
1979
1980 // Pop arguments
1981 for (int i = arg_length - 1; i >= 0; i--) ppop1(in[i]);// Do args in reverse order.
1982
1983 // Report results
1984 if (_report_result_for_send == true) {
1985 fill_stackmap_for_opcodes(_itr_send, vars(), stack(), _stack_top);
1986 _report_result_for_send = false;
1987 }
1988
1989 // Push return address
1990 ppush(out);
1991 }
1992
1993 // This is used to parse the signature for fields, since they are very simple...
1994 CellTypeState *GenerateOopMap::signature_to_effect(const Symbol* sig, int bci, CellTypeState *out) {
1995 // Object and array
1996 BasicType bt = Signature::basic_type(sig);
1997 if (is_reference_type(bt)) {
1998 out[0] = CellTypeState::make_line_ref(bci);
1999 out[1] = CellTypeState::bottom;
2000 return out;
2001 }
2002 if (is_double_word_type(bt)) return vvCTS; // Long and Double
2003 if (bt == T_VOID) return epsilonCTS; // Void
2004 return vCTS; // Otherwise
2005 }
2006
2007 uint64_t GenerateOopMap::_total_byte_count = 0;
2008 elapsedTimer GenerateOopMap::_total_oopmap_time;
2009
2010 // This function assumes "bcs" is at a "ret" instruction and that the vars
2011 // state is valid for that instruction. Furthermore, the ret instruction
2012 // must be the last instruction in "bb" (we store information about the
2013 // "ret" in "bb").
2014 void GenerateOopMap::ret_jump_targets_do(BytecodeStream *bcs, jmpFct_t jmpFct, int varNo, int *data) {
2015 CellTypeState ra = vars()[varNo];
2016 if (!ra.is_good_address()) {
2017 verify_error("ret returns from two jsr subroutines?");
2018 return;
2019 }
2020 int target = ra.get_info();
2021
2022 RetTableEntry* rtEnt = _rt.find_jsrs_for_target(target);
2023 int bci = bcs->bci();
2024 for (int i = 0; i < rtEnt->nof_jsrs(); i++) {
2025 int target_bci = rtEnt->jsrs(i);
2026 // Make sure a jrtRet does not set the changed bit for dead basicblock.
2027 BasicBlock* jsr_bb = get_basic_block_containing(target_bci - 1);
2028 DEBUG_ONLY(BasicBlock* target_bb = &jsr_bb[1];)
2029 assert(target_bb == get_basic_block_at(target_bci), "wrong calc. of successor basicblock");
2030 bool alive = jsr_bb->is_alive();
2031 log_debug(generateoopmap)("pc = %d, ret -> %d alive: %s", bci, target_bci, alive ? "true" : "false");
2032 if (alive) jmpFct(this, target_bci, data);
2033 }
2034 }
2035
2036 //
2037 // Debug method
2038 //
2039 char* GenerateOopMap::state_vec_to_string(CellTypeState* vec, int len) {
2040 #ifdef ASSERT
2041 int checklen = MAX3(_max_locals, _max_stack, _max_monitors) + 1;
2042 assert(len < checklen, "state_vec_buf overflow");
2043 #endif
2044 for (int i = 0; i < len; i++) _state_vec_buf[i] = vec[i].to_char();
2045 _state_vec_buf[len] = 0;
2046 return _state_vec_buf;
2047 }
2048
2049 #ifndef PRODUCT
2050 void GenerateOopMap::print_time() {
2051 tty->print_cr ("Accumulated oopmap times:");
2052 tty->print_cr ("---------------------------");
2053 tty->print_cr (" Total : %3.3f sec.", GenerateOopMap::_total_oopmap_time.seconds());
2054 tty->print_cr (" (%3.0f bytecodes per sec) ",
2055 (double)GenerateOopMap::_total_byte_count / GenerateOopMap::_total_oopmap_time.seconds());
2056 }
2057 #endif
2058
2059 //
2060 // ============ Main Entry Point ===========
2061 //
2062 GenerateOopMap::GenerateOopMap(const methodHandle& method, bool all_exception_edges) :
2063 // We have to initialize all variables here, that can be queried directly
2064 _method(method),
2065 _max_locals(0),
2066 _all_exception_edges(all_exception_edges),
2067 _init_vars(nullptr) {}
2068
2069 bool GenerateOopMap::compute_map(Thread* current) {
2070 #ifndef PRODUCT
2071 if (TimeOopMap) {
2072 _total_byte_count += method()->code_size();
2073 TraceTime t_all(nullptr, &_total_oopmap_time, TimeOopMap);
2074 }
2075 #endif
2076 TraceTime t_single("oopmap time", TRACETIME_LOG(Debug, generateoopmap));
2077
2078 // Initialize values
2079 _got_error = false;
2080 _conflict = false;
2081 _max_locals = method()->max_locals();
2082 _max_stack = method()->max_stack();
2083 _has_exceptions = (method()->has_exception_handler());
2084 _nof_refval_conflicts = 0;
2085 _init_vars = new GrowableArray<intptr_t>(5); // There are seldom more than 5 init_vars
2086 _report_result = false;
2087 _report_result_for_send = false;
2088 _new_var_map = nullptr;
2089 _ret_adr_tos = new GrowableArray<int>(5); // 5 seems like a good number;
2090 _did_rewriting = false;
2091 _did_relocation = false;
2092
2093 if (log_is_enabled(Debug, generateoopmap)) {
2094 ResourceMark rm;
2095 LogStream st(Log(generateoopmap)::debug());
2096 st.print_cr("Method name: %s\n", method()->name()->as_C_string());
2097 _method->print_codes_on(&st);
2098 st.print_cr("Exception table:");
2099 ExceptionTable excps(method());
2100 for (int i = 0; i < excps.length(); i ++) {
2101 st.print_cr("[%d - %d] -> %d",
2102 excps.start_pc(i), excps.end_pc(i), excps.handler_pc(i));
2103 }
2104 }
2105
2106 // if no code - do nothing
2107 // compiler needs info
2108 if (method()->code_size() == 0 || _max_locals + method()->max_stack() == 0) {
2109 return true;
2110 }
2111 // Step 1: Compute all jump targets and their return value
2112 if (!_got_error)
2113 _rt.compute_ret_table(_method);
2114
2115 // Step 2: Find all basic blocks and count GC points
2116 if (!_got_error)
2117 mark_bbheaders();
2118
2119 // Step 3: Calculate stack maps
2120 if (!_got_error)
2121 do_interpretation();
2122
2123 // Step 4:Return results
2124 if (!_got_error && report_results())
2125 report_result();
2126
2127 return !_got_error;
2128 }
2129
2130 // Error handling methods
2131 //
2132 // If we compute from a suitable JavaThread then we create an exception for the GenerateOopMap
2133 // calling code to retrieve (via exception()) and throw if desired (in most cases errors are ignored).
2134 // Otherwise it is considered a fatal error to hit malformed bytecode.
2135 void GenerateOopMap::error_work(const char *format, va_list ap) {
2136 _got_error = true;
2137 char msg_buffer[512];
2138 (void) os::vsnprintf(msg_buffer, sizeof(msg_buffer), format, ap);
2139 // Append method name
2140 char msg_buffer2[512];
2141 (void) os::snprintf(msg_buffer2, sizeof(msg_buffer2), "%s in method %s", msg_buffer, method()->name()->as_C_string());
2142 Thread* current = Thread::current();
2143 if (current->can_call_java()) {
2144 _exception = Exceptions::new_exception(JavaThread::cast(current),
2145 vmSymbols::java_lang_LinkageError(),
2146 msg_buffer2);
2147 } else {
2148 fatal("%s", msg_buffer2);
2149 }
2150 }
2151
2152 void GenerateOopMap::report_error(const char *format, ...) {
2153 va_list ap;
2154 va_start(ap, format);
2155 error_work(format, ap);
2156 }
2157
2158 void GenerateOopMap::verify_error(const char *format, ...) {
2159 // We do not distinguish between different types of errors for verification
2160 // errors. Let the verifier give a better message.
2161 report_error("Illegal class file encountered. Try running with -Xverify:all");
2162 }
2163
2164 //
2165 // Report result opcodes
2166 //
2167 void GenerateOopMap::report_result() {
2168
2169 log_debug(generateoopmap)("Report result pass");
2170
2171 // We now want to report the result of the parse
2172 _report_result = true;
2173
2174 // Mark everything changed, then do one interpretation pass.
2175 for (int i = 0; i<_bb_count; i++) {
2176 if (_basic_blocks[i].is_reachable()) {
2177 _basic_blocks[i].set_changed(true);
2178 interp_bb(&_basic_blocks[i]);
2179 }
2180 }
2181
2182 _report_result = false;
2183 }
2184
2185 void GenerateOopMap::result_for_basicblock(int bci) {
2186 log_debug(generateoopmap)("Report result pass for basicblock");
2187
2188 // We now want to report the result of the parse
2189 _report_result = true;
2190
2191 // Find basicblock and report results
2192 BasicBlock* bb = get_basic_block_containing(bci);
2193 guarantee(bb != nullptr, "no basic block for bci");
2194 assert(bb->is_reachable(), "getting result from unreachable basicblock at bci %d", bci);
2195 bb->set_changed(true);
2196 interp_bb(bb);
2197 }
2198
2199 //
2200 // Conflict handling code
2201 //
2202
2203 void GenerateOopMap::record_refval_conflict(int varNo) {
2204 assert(varNo>=0 && varNo< _max_locals, "index out of range");
2205
2206 log_trace(generateoopmap)("### Conflict detected (local no: %d)", varNo);
2207
2208 if (!_new_var_map) {
2209 _new_var_map = NEW_RESOURCE_ARRAY(int, _max_locals);
2210 for (int k = 0; k < _max_locals; k++) _new_var_map[k] = k;
2211 }
2212
2213 if ( _new_var_map[varNo] == varNo) {
2214 // Check if max. number of locals has been reached
2215 if (_max_locals + _nof_refval_conflicts >= MAX_LOCAL_VARS) {
2216 report_error("Rewriting exceeded local variable limit");
2217 return;
2218 }
2219 _new_var_map[varNo] = _max_locals + _nof_refval_conflicts;
2220 _nof_refval_conflicts++;
2221 }
2222 }
2223
2224 void GenerateOopMap::rewrite_refval_conflicts()
2225 {
2226 // We can get here two ways: Either a rewrite conflict was detected, or
2227 // an uninitialize reference was detected. In the second case, we do not
2228 // do any rewriting, we just want to recompute the reference set with the
2229 // new information
2230
2231 int nof_conflicts = 0; // Used for debugging only
2232
2233 if ( _nof_refval_conflicts == 0 )
2234 return;
2235
2236 // Check if rewrites are allowed in this parse.
2237 if (!allow_rewrites()) {
2238 fatal("Rewriting method not allowed at this stage");
2239 }
2240
2241
2242 // Tracing flag
2243 _did_rewriting = true;
2244
2245 if (log_is_enabled(Trace, generateoopmap)) {
2246 ResourceMark rm;
2247 LogStream st(Log(generateoopmap)::trace());
2248 st.print_cr("ref/value conflict for method %s - bytecodes are getting rewritten", method()->name()->as_C_string());
2249 method()->print_on(&st);
2250 method()->print_codes_on(&st);
2251 }
2252
2253 assert(_new_var_map!=nullptr, "nothing to rewrite");
2254 assert(_conflict==true, "We should not be here");
2255
2256 compute_ret_adr_at_TOS();
2257 if (!_got_error) {
2258 for (int k = 0; k < _max_locals && !_got_error; k++) {
2259 if (_new_var_map[k] != k) {
2260 log_trace(generateoopmap)("Rewriting: %d -> %d", k, _new_var_map[k]);
2261 rewrite_refval_conflict(k, _new_var_map[k]);
2262 if (_got_error) return;
2263 nof_conflicts++;
2264 }
2265 }
2266 }
2267
2268 assert(nof_conflicts == _nof_refval_conflicts, "sanity check");
2269
2270 // Adjust the number of locals
2271 method()->set_max_locals(_max_locals+_nof_refval_conflicts);
2272 _max_locals += _nof_refval_conflicts;
2273
2274 // That was that...
2275 _new_var_map = nullptr;
2276 _nof_refval_conflicts = 0;
2277 }
2278
2279 void GenerateOopMap::rewrite_refval_conflict(int from, int to) {
2280 bool startOver;
2281 do {
2282 // Make sure that the BytecodeStream is constructed in the loop, since
2283 // during rewriting a new method is going to be used, and the next time
2284 // around we want to use that.
2285 BytecodeStream bcs(_method);
2286 startOver = false;
2287
2288 while( !startOver && !_got_error &&
2289 // test bcs in case method changed and it became invalid
2290 bcs.next() >=0) {
2291 startOver = rewrite_refval_conflict_inst(&bcs, from, to);
2292 }
2293 } while (startOver && !_got_error);
2294 }
2295
2296 /* If the current instruction is one that uses local variable "from"
2297 in a ref way, change it to use "to". There's a subtle reason why we
2298 renumber the ref uses and not the non-ref uses: non-ref uses may be
2299 2 slots wide (double, long) which would necessitate keeping track of
2300 whether we should add one or two variables to the method. If the change
2301 affected the width of some instruction, returns "TRUE"; otherwise, returns "FALSE".
2302 Another reason for moving ref's value is for solving (addr, ref) conflicts, which
2303 both uses aload/astore methods.
2304 */
2305 bool GenerateOopMap::rewrite_refval_conflict_inst(BytecodeStream *itr, int from, int to) {
2306 Bytecodes::Code bc = itr->code();
2307 int index;
2308 int bci = itr->bci();
2309
2310 if (is_aload(itr, &index) && index == from) {
2311 log_trace(generateoopmap)("Rewriting aload at bci: %d", bci);
2312 return rewrite_load_or_store(itr, Bytecodes::_aload, Bytecodes::_aload_0, to);
2313 }
2314
2315 if (is_astore(itr, &index) && index == from) {
2316 if (!stack_top_holds_ret_addr(bci)) {
2317 log_trace(generateoopmap)("Rewriting astore at bci: %d", bci);
2318 return rewrite_load_or_store(itr, Bytecodes::_astore, Bytecodes::_astore_0, to);
2319 } else {
2320 log_trace(generateoopmap)("Suppress rewriting of astore at bci: %d", bci);
2321 }
2322 }
2323
2324 return false;
2325 }
2326
2327 // The argument to this method is:
2328 // bc : Current bytecode
2329 // bcN : either _aload or _astore
2330 // bc0 : either _aload_0 or _astore_0
2331 bool GenerateOopMap::rewrite_load_or_store(BytecodeStream *bcs, Bytecodes::Code bcN, Bytecodes::Code bc0, unsigned int varNo) {
2332 assert(bcN == Bytecodes::_astore || bcN == Bytecodes::_aload, "wrong argument (bcN)");
2333 assert(bc0 == Bytecodes::_astore_0 || bc0 == Bytecodes::_aload_0, "wrong argument (bc0)");
2334 int ilen = Bytecodes::length_at(_method(), bcs->bcp());
2335 int newIlen;
2336
2337 if (ilen == 4) {
2338 // Original instruction was wide; keep it wide for simplicity
2339 newIlen = 4;
2340 } else if (varNo < 4)
2341 newIlen = 1;
2342 else if (varNo >= 256)
2343 newIlen = 4;
2344 else
2345 newIlen = 2;
2346
2347 // If we need to relocate in order to patch the byte, we
2348 // do the patching in a temp. buffer, that is passed to the reloc.
2349 // The patching of the bytecode stream is then done by the Relocator.
2350 // This is necessary, since relocating the instruction at a certain bci, might
2351 // also relocate that instruction, e.g., if a _goto before it gets widen to a _goto_w.
2352 // Hence, we do not know which bci to patch after relocation.
2353
2354 assert(newIlen <= 4, "sanity check");
2355 u_char inst_buffer[4]; // Max. instruction size is 4.
2356 address bcp;
2357
2358 if (newIlen != ilen) {
2359 // Relocation needed do patching in temp. buffer
2360 bcp = (address)inst_buffer;
2361 } else {
2362 bcp = _method->bcp_from(bcs->bci());
2363 }
2364
2365 // Patch either directly in Method* or in temp. buffer
2366 if (newIlen == 1) {
2367 assert(varNo < 4, "varNo too large");
2368 *bcp = (u1)(bc0 + varNo);
2369 } else if (newIlen == 2) {
2370 assert(varNo < 256, "2-byte index needed!");
2371 *(bcp + 0) = bcN;
2372 *(bcp + 1) = (u1)varNo;
2373 } else {
2374 assert(newIlen == 4, "Wrong instruction length");
2375 *(bcp + 0) = Bytecodes::_wide;
2376 *(bcp + 1) = bcN;
2377 Bytes::put_Java_u2(bcp+2, (u2)varNo);
2378 }
2379
2380 if (newIlen != ilen) {
2381 expand_current_instr(bcs->bci(), ilen, newIlen, inst_buffer);
2382 }
2383
2384
2385 return (newIlen != ilen);
2386 }
2387
2388 class RelocCallback : public RelocatorListener {
2389 private:
2390 GenerateOopMap* _gom;
2391 public:
2392 RelocCallback(GenerateOopMap* gom) { _gom = gom; };
2393
2394 // Callback method
2395 virtual void relocated(int bci, int delta, int new_code_length) {
2396 _gom->update_basic_blocks (bci, delta, new_code_length);
2397 _gom->update_ret_adr_at_TOS(bci, delta);
2398 _gom->_rt.update_ret_table (bci, delta);
2399 }
2400 };
2401
2402 // Returns true if expanding was successful. Otherwise, reports an error and
2403 // returns false.
2404 void GenerateOopMap::expand_current_instr(int bci, int ilen, int newIlen, u_char inst_buffer[]) {
2405 JavaThread* THREAD = JavaThread::current(); // For exception macros.
2406 RelocCallback rcb(this);
2407 Relocator rc(_method, &rcb);
2408 methodHandle m= rc.insert_space_at(bci, newIlen, inst_buffer, THREAD);
2409 if (m.is_null() || HAS_PENDING_EXCEPTION) {
2410 report_error("could not rewrite method - exception occurred or bytecode buffer overflow");
2411 return;
2412 }
2413
2414 // Relocator returns a new method.
2415 _did_relocation = true;
2416 _method = m;
2417 }
2418
2419
2420 bool GenerateOopMap::is_astore(BytecodeStream *itr, int *index) {
2421 Bytecodes::Code bc = itr->code();
2422 switch(bc) {
2423 case Bytecodes::_astore_0:
2424 case Bytecodes::_astore_1:
2425 case Bytecodes::_astore_2:
2426 case Bytecodes::_astore_3:
2427 *index = bc - Bytecodes::_astore_0;
2428 return true;
2429 case Bytecodes::_astore:
2430 *index = itr->get_index();
2431 return true;
2432 default:
2433 return false;
2434 }
2435 }
2436
2437 bool GenerateOopMap::is_aload(BytecodeStream *itr, int *index) {
2438 Bytecodes::Code bc = itr->code();
2439 switch(bc) {
2440 case Bytecodes::_aload_0:
2441 case Bytecodes::_aload_1:
2442 case Bytecodes::_aload_2:
2443 case Bytecodes::_aload_3:
2444 *index = bc - Bytecodes::_aload_0;
2445 return true;
2446
2447 case Bytecodes::_aload:
2448 *index = itr->get_index();
2449 return true;
2450
2451 default:
2452 return false;
2453 }
2454 }
2455
2456
2457 // Return true iff the top of the operand stack holds a return address at
2458 // the current instruction
2459 bool GenerateOopMap::stack_top_holds_ret_addr(int bci) {
2460 for(int i = 0; i < _ret_adr_tos->length(); i++) {
2461 if (_ret_adr_tos->at(i) == bci)
2462 return true;
2463 }
2464
2465 return false;
2466 }
2467
2468 void GenerateOopMap::compute_ret_adr_at_TOS() {
2469 assert(_ret_adr_tos != nullptr, "must be initialized");
2470 _ret_adr_tos->clear();
2471
2472 for (int i = 0; i < bb_count(); i++) {
2473 BasicBlock* bb = &_basic_blocks[i];
2474
2475 // Make sure to only check basicblocks that are reachable
2476 if (bb->is_reachable()) {
2477
2478 // For each Basic block we check all instructions
2479 BytecodeStream bcs(_method);
2480 bcs.set_interval(bb->_bci, next_bb_start_pc(bb));
2481
2482 restore_state(bb);
2483
2484 while (bcs.next()>=0 && !_got_error) {
2485 // TDT: should this be is_good_address() ?
2486 if (_stack_top > 0 && stack()[_stack_top-1].is_address()) {
2487 _ret_adr_tos->append(bcs.bci());
2488 log_debug(generateoopmap)("Ret_adr TOS at bci: %d", bcs.bci());
2489 }
2490 interp1(&bcs);
2491 }
2492 }
2493 }
2494 }
2495
2496 void GenerateOopMap::update_ret_adr_at_TOS(int bci, int delta) {
2497 for(int i = 0; i < _ret_adr_tos->length(); i++) {
2498 int v = _ret_adr_tos->at(i);
2499 if (v > bci) _ret_adr_tos->at_put(i, v + delta);
2500 }
2501 }
2502
2503 // ===================================================================
2504
2505 #ifndef PRODUCT
2506 int ResolveOopMapConflicts::_nof_invocations = 0;
2507 int ResolveOopMapConflicts::_nof_rewrites = 0;
2508 int ResolveOopMapConflicts::_nof_relocations = 0;
2509 #endif
2510
2511 methodHandle ResolveOopMapConflicts::do_potential_rewrite(TRAPS) {
2512 if (!compute_map(THREAD)) {
2513 THROW_HANDLE_(exception(), methodHandle());
2514 }
2515
2516 #ifndef PRODUCT
2517 // Tracking and statistics
2518 if (PrintRewrites) {
2519 _nof_invocations++;
2520 if (did_rewriting()) {
2521 _nof_rewrites++;
2522 if (did_relocation()) _nof_relocations++;
2523 tty->print("Method was rewritten %s: ", (did_relocation()) ? "and relocated" : "");
2524 method()->print_value(); tty->cr();
2525 tty->print_cr("Cand.: %d rewrts: %d (%d%%) reloc.: %d (%d%%)",
2526 _nof_invocations,
2527 _nof_rewrites, (_nof_rewrites * 100) / _nof_invocations,
2528 _nof_relocations, (_nof_relocations * 100) / _nof_invocations);
2529 }
2530 }
2531 #endif
2532 return methodHandle(THREAD, method());
2533 }