1 /*
2 * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2009 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "ci/ciField.hpp"
28 #include "ci/ciMethod.hpp"
29 #include "ci/ciStreams.hpp"
30 #include "interpreter/bytecodes.hpp"
31 #include "memory/allocation.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "shark/sharkBlock.hpp"
34 #include "shark/sharkConstant.hpp"
35 #include "shark/sharkInliner.hpp"
36 #include "shark/sharkIntrinsics.hpp"
37 #include "shark/sharkState.hpp"
38 #include "shark/sharkValue.hpp"
39 #include "shark/shark_globals.hpp"
40
41 using namespace llvm;
42
43 class SharkInlineBlock : public SharkBlock {
44 public:
45 SharkInlineBlock(ciMethod* target, SharkState* state)
46 : SharkBlock(state, target),
47 _outer_state(state),
48 _entry_state(new SharkState(this)) {
49 for (int i = target->max_locals() - 1; i >= 0; i--) {
50 SharkValue *value = NULL;
51 if (i < target->arg_size())
52 value = outer_state()->pop();
53 entry_state()->set_local(i, value);
54 }
55 }
56
57 private:
58 SharkState* _outer_state;
59 SharkState* _entry_state;
60
61 private:
62 SharkState* outer_state() {
63 return _outer_state;
64 }
65 SharkState* entry_state() {
66 return _entry_state;
67 }
68
69 public:
70 void emit_IR() {
71 parse_bytecode(0, target()->code_size());
72 }
73
74 private:
75 void do_return(BasicType type) {
76 if (type != T_VOID) {
77 SharkValue *result = pop_result(type);
78 outer_state()->push(result);
79 if (result->is_two_word())
80 outer_state()->push(NULL);
81 }
82 }
83 };
84
85 class SharkInlinerHelper : public StackObj {
86 public:
87 SharkInlinerHelper(ciMethod* target, SharkState* entry_state)
88 : _target(target),
89 _entry_state(entry_state),
90 _iter(target) {}
91
92 private:
93 ciBytecodeStream _iter;
94 SharkState* _entry_state;
95 ciMethod* _target;
96
97 public:
98 ciBytecodeStream* iter() {
99 return &_iter;
100 }
101 SharkState* entry_state() const {
102 return _entry_state;
103 }
104 ciMethod* target() const {
105 return _target;
106 }
107
108 public:
109 Bytecodes::Code bc() {
110 return iter()->cur_bc();
111 }
112 int max_locals() const {
113 return target()->max_locals();
114 }
115 int max_stack() const {
116 return target()->max_stack();
117 }
118
119 // Inlinability check
120 public:
121 bool is_inlinable();
122
123 private:
124 void initialize_for_check();
125
126 bool do_getstatic() {
127 return do_field_access(true, false);
128 }
129 bool do_getfield() {
130 return do_field_access(true, true);
131 }
132 bool do_putfield() {
133 return do_field_access(false, true);
134 }
135 bool do_field_access(bool is_get, bool is_field);
136
137 // Local variables for inlinability check
138 private:
139 bool* _locals;
140
141 public:
142 bool* local_addr(int index) const {
143 assert(index >= 0 && index < max_locals(), "bad local variable index");
144 return &_locals[index];
145 }
146 bool local(int index) const {
147 return *local_addr(index);
148 }
149 void set_local(int index, bool value) {
150 *local_addr(index) = value;
151 }
152
153 // Expression stack for inlinability check
154 private:
155 bool* _stack;
156 bool* _sp;
157
158 public:
159 int stack_depth() const {
160 return _sp - _stack;
161 }
162 bool* stack_addr(int slot) const {
163 assert(slot >= 0 && slot < stack_depth(), "bad stack slot");
164 return &_sp[-(slot + 1)];
165 }
166 void push(bool value) {
167 assert(stack_depth() < max_stack(), "stack overrun");
168 *(_sp++) = value;
169 }
170 bool pop() {
171 assert(stack_depth() > 0, "stack underrun");
172 return *(--_sp);
173 }
174
175 // Methods for two-word locals
176 public:
177 void push_pair_local(int index) {
178 push(local(index));
179 push(local(index + 1));
180 }
181 void pop_pair_local(int index) {
182 set_local(index + 1, pop());
183 set_local(index, pop());
184 }
185
186 // Code generation
187 public:
188 void do_inline() {
189 (new SharkInlineBlock(target(), entry_state()))->emit_IR();
190 }
191 };
192
193 // Quick checks so we can bail out before doing too much
194 bool SharkInliner::may_be_inlinable(ciMethod *target) {
195 // We can't inline native methods
196 if (target->is_native())
197 return false;
198
199 // Not much point inlining abstract ones, and in any
200 // case we'd need a stack frame to throw the exception
201 if (target->is_abstract())
202 return false;
203
204 // Don't inline anything huge
205 if (target->code_size() > SharkMaxInlineSize)
206 return false;
207
208 // Monitors aren't allowed without a frame to put them in
209 if (target->is_synchronized() || target->has_monitor_bytecodes())
210 return false;
211
212 // We don't do control flow
213 if (target->has_exception_handlers() || target->has_jsrs())
214 return false;
215
216 // Don't try to inline constructors, as they must
217 // eventually call Object.<init> which we can't inline.
218 // Note that this catches <clinit> too, but why would
219 // we be compiling that?
220 if (target->is_initializer())
221 return false;
222
223 // Mustn't inline Object.<init>
224 // Should be caught by the above, but just in case...
225 if (target->intrinsic_id() == vmIntrinsics::_Object_init)
226 return false;
227
228 return true;
229 }
230
231 // Full-on detailed check, for methods that pass the quick checks
232 // Inlined methods have no stack frame, so we can't do anything
233 // that would require one. This means no safepoints (and hence
234 // no loops) and no VM calls. No VM calls means, amongst other
235 // things, that no exceptions can be created, which means no null
236 // checks or divide-by-zero checks are allowed. The lack of null
237 // checks in particular would eliminate practically everything,
238 // but we can get around that restriction by relying on the zero-
239 // check eliminator to strip the checks. To do that, we need to
240 // walk through the method, tracking which values are and are not
241 // zero-checked.
242 bool SharkInlinerHelper::is_inlinable() {
243 ResourceMark rm;
244 initialize_for_check();
245
246 SharkConstant *sc;
247 bool a, b, c, d;
248
249 iter()->reset_to_bci(0);
250 while (iter()->next() != ciBytecodeStream::EOBC()) {
251 switch (bc()) {
252 case Bytecodes::_nop:
253 break;
254
255 case Bytecodes::_aconst_null:
256 push(false);
257 break;
258
259 case Bytecodes::_iconst_0:
260 push(false);
261 break;
262 case Bytecodes::_iconst_m1:
263 case Bytecodes::_iconst_1:
264 case Bytecodes::_iconst_2:
265 case Bytecodes::_iconst_3:
266 case Bytecodes::_iconst_4:
267 case Bytecodes::_iconst_5:
268 push(true);
269 break;
270
271 case Bytecodes::_lconst_0:
272 push(false);
273 push(false);
274 break;
275 case Bytecodes::_lconst_1:
276 push(true);
277 push(false);
278 break;
279
280 case Bytecodes::_fconst_0:
281 case Bytecodes::_fconst_1:
282 case Bytecodes::_fconst_2:
283 push(false);
284 break;
285
286 case Bytecodes::_dconst_0:
287 case Bytecodes::_dconst_1:
288 push(false);
289 push(false);
290 break;
291
292 case Bytecodes::_bipush:
293 push(iter()->get_constant_u1() != 0);
294 break;
295 case Bytecodes::_sipush:
296 push(iter()->get_constant_u2() != 0);
297 break;
298
299 case Bytecodes::_ldc:
300 case Bytecodes::_ldc_w:
301 case Bytecodes::_ldc2_w:
302 sc = SharkConstant::for_ldc(iter());
303 if (!sc->is_loaded())
304 return false;
305 push(sc->is_nonzero());
306 if (sc->is_two_word())
307 push(false);
308 break;
309
310 case Bytecodes::_iload_0:
311 case Bytecodes::_fload_0:
312 case Bytecodes::_aload_0:
313 push(local(0));
314 break;
315 case Bytecodes::_lload_0:
316 case Bytecodes::_dload_0:
317 push_pair_local(0);
318 break;
319
320 case Bytecodes::_iload_1:
321 case Bytecodes::_fload_1:
322 case Bytecodes::_aload_1:
323 push(local(1));
324 break;
325 case Bytecodes::_lload_1:
326 case Bytecodes::_dload_1:
327 push_pair_local(1);
328 break;
329
330 case Bytecodes::_iload_2:
331 case Bytecodes::_fload_2:
332 case Bytecodes::_aload_2:
333 push(local(2));
334 break;
335 case Bytecodes::_lload_2:
336 case Bytecodes::_dload_2:
337 push_pair_local(2);
338 break;
339
340 case Bytecodes::_iload_3:
341 case Bytecodes::_fload_3:
342 case Bytecodes::_aload_3:
343 push(local(3));
344 break;
345 case Bytecodes::_lload_3:
346 case Bytecodes::_dload_3:
347 push_pair_local(3);
348 break;
349
350 case Bytecodes::_iload:
351 case Bytecodes::_fload:
352 case Bytecodes::_aload:
353 push(local(iter()->get_index()));
354 break;
355 case Bytecodes::_lload:
356 case Bytecodes::_dload:
357 push_pair_local(iter()->get_index());
358 break;
359
360 case Bytecodes::_istore_0:
361 case Bytecodes::_fstore_0:
362 case Bytecodes::_astore_0:
363 set_local(0, pop());
364 break;
365 case Bytecodes::_lstore_0:
366 case Bytecodes::_dstore_0:
367 pop_pair_local(0);
368 break;
369
370 case Bytecodes::_istore_1:
371 case Bytecodes::_fstore_1:
372 case Bytecodes::_astore_1:
373 set_local(1, pop());
374 break;
375 case Bytecodes::_lstore_1:
376 case Bytecodes::_dstore_1:
377 pop_pair_local(1);
378 break;
379
380 case Bytecodes::_istore_2:
381 case Bytecodes::_fstore_2:
382 case Bytecodes::_astore_2:
383 set_local(2, pop());
384 break;
385 case Bytecodes::_lstore_2:
386 case Bytecodes::_dstore_2:
387 pop_pair_local(2);
388 break;
389
390 case Bytecodes::_istore_3:
391 case Bytecodes::_fstore_3:
392 case Bytecodes::_astore_3:
393 set_local(3, pop());
394 break;
395 case Bytecodes::_lstore_3:
396 case Bytecodes::_dstore_3:
397 pop_pair_local(3);
398 break;
399
400 case Bytecodes::_istore:
401 case Bytecodes::_fstore:
402 case Bytecodes::_astore:
403 set_local(iter()->get_index(), pop());
404 break;
405 case Bytecodes::_lstore:
406 case Bytecodes::_dstore:
407 pop_pair_local(iter()->get_index());
408 break;
409
410 case Bytecodes::_pop:
411 pop();
412 break;
413 case Bytecodes::_pop2:
414 pop();
415 pop();
416 break;
417 case Bytecodes::_swap:
418 a = pop();
419 b = pop();
420 push(a);
421 push(b);
422 break;
423 case Bytecodes::_dup:
424 a = pop();
425 push(a);
426 push(a);
427 break;
428 case Bytecodes::_dup_x1:
429 a = pop();
430 b = pop();
431 push(a);
432 push(b);
433 push(a);
434 break;
435 case Bytecodes::_dup_x2:
436 a = pop();
437 b = pop();
438 c = pop();
439 push(a);
440 push(c);
441 push(b);
442 push(a);
443 break;
444 case Bytecodes::_dup2:
445 a = pop();
446 b = pop();
447 push(b);
448 push(a);
449 push(b);
450 push(a);
451 break;
452 case Bytecodes::_dup2_x1:
453 a = pop();
454 b = pop();
455 c = pop();
456 push(b);
457 push(a);
458 push(c);
459 push(b);
460 push(a);
461 break;
462 case Bytecodes::_dup2_x2:
463 a = pop();
464 b = pop();
465 c = pop();
466 d = pop();
467 push(b);
468 push(a);
469 push(d);
470 push(c);
471 push(b);
472 push(a);
473 break;
474
475 case Bytecodes::_getfield:
476 if (!do_getfield())
477 return false;
478 break;
479 case Bytecodes::_getstatic:
480 if (!do_getstatic())
481 return false;
482 break;
483 case Bytecodes::_putfield:
484 if (!do_putfield())
485 return false;
486 break;
487
488 case Bytecodes::_iadd:
489 case Bytecodes::_isub:
490 case Bytecodes::_imul:
491 case Bytecodes::_iand:
492 case Bytecodes::_ixor:
493 case Bytecodes::_ishl:
494 case Bytecodes::_ishr:
495 case Bytecodes::_iushr:
496 pop();
497 pop();
498 push(false);
499 break;
500 case Bytecodes::_ior:
501 a = pop();
502 b = pop();
503 push(a && b);
504 break;
505 case Bytecodes::_idiv:
506 case Bytecodes::_irem:
507 if (!pop())
508 return false;
509 pop();
510 push(false);
511 break;
512 case Bytecodes::_ineg:
513 break;
514
515 case Bytecodes::_ladd:
516 case Bytecodes::_lsub:
517 case Bytecodes::_lmul:
518 case Bytecodes::_land:
519 case Bytecodes::_lxor:
520 pop();
521 pop();
522 pop();
523 pop();
524 push(false);
525 push(false);
526 break;
527 case Bytecodes::_lor:
528 a = pop();
529 b = pop();
530 push(a && b);
531 break;
532 case Bytecodes::_ldiv:
533 case Bytecodes::_lrem:
534 pop();
535 if (!pop())
536 return false;
537 pop();
538 pop();
539 push(false);
540 push(false);
541 break;
542 case Bytecodes::_lneg:
543 break;
544 case Bytecodes::_lshl:
545 case Bytecodes::_lshr:
546 case Bytecodes::_lushr:
547 pop();
548 pop();
549 pop();
550 push(false);
551 push(false);
552 break;
553
554 case Bytecodes::_fadd:
555 case Bytecodes::_fsub:
556 case Bytecodes::_fmul:
557 case Bytecodes::_fdiv:
558 case Bytecodes::_frem:
559 pop();
560 pop();
561 push(false);
562 break;
563 case Bytecodes::_fneg:
564 break;
565
566 case Bytecodes::_dadd:
567 case Bytecodes::_dsub:
568 case Bytecodes::_dmul:
569 case Bytecodes::_ddiv:
570 case Bytecodes::_drem:
571 pop();
572 pop();
573 pop();
574 pop();
575 push(false);
576 push(false);
577 break;
578 case Bytecodes::_dneg:
579 break;
580
581 case Bytecodes::_iinc:
582 set_local(iter()->get_index(), false);
583 break;
584
585 case Bytecodes::_lcmp:
586 pop();
587 pop();
588 pop();
589 pop();
590 push(false);
591 break;
592
593 case Bytecodes::_fcmpl:
594 case Bytecodes::_fcmpg:
595 pop();
596 pop();
597 push(false);
598 break;
599
600 case Bytecodes::_dcmpl:
601 case Bytecodes::_dcmpg:
602 pop();
603 pop();
604 pop();
605 pop();
606 push(false);
607 break;
608
609 case Bytecodes::_i2l:
610 push(false);
611 break;
612 case Bytecodes::_i2f:
613 pop();
614 push(false);
615 break;
616 case Bytecodes::_i2d:
617 pop();
618 push(false);
619 push(false);
620 break;
621
622 case Bytecodes::_l2i:
623 case Bytecodes::_l2f:
624 pop();
625 pop();
626 push(false);
627 break;
628 case Bytecodes::_l2d:
629 pop();
630 pop();
631 push(false);
632 push(false);
633 break;
634
635 case Bytecodes::_f2i:
636 pop();
637 push(false);
638 break;
639 case Bytecodes::_f2l:
640 case Bytecodes::_f2d:
641 pop();
642 push(false);
643 push(false);
644 break;
645
646 case Bytecodes::_d2i:
647 case Bytecodes::_d2f:
648 pop();
649 pop();
650 push(false);
651 break;
652 case Bytecodes::_d2l:
653 pop();
654 pop();
655 push(false);
656 push(false);
657 break;
658
659 case Bytecodes::_i2b:
660 case Bytecodes::_i2c:
661 case Bytecodes::_i2s:
662 pop();
663 push(false);
664 break;
665
666 case Bytecodes::_return:
667 case Bytecodes::_ireturn:
668 case Bytecodes::_lreturn:
669 case Bytecodes::_freturn:
670 case Bytecodes::_dreturn:
671 case Bytecodes::_areturn:
672 break;
673
674 default:
675 return false;
676 }
677 }
678
679 return true;
680 }
681
682 void SharkInlinerHelper::initialize_for_check() {
683 _locals = NEW_RESOURCE_ARRAY(bool, max_locals());
684 _stack = NEW_RESOURCE_ARRAY(bool, max_stack());
685
686 memset(_locals, 0, max_locals() * sizeof(bool));
687 for (int i = 0; i < target()->arg_size(); i++) {
688 SharkValue *arg = entry_state()->stack(target()->arg_size() - 1 - i);
689 if (arg && arg->zero_checked())
690 set_local(i, true);
691 }
692
693 _sp = _stack;
694 }
695
696 bool SharkInlinerHelper::do_field_access(bool is_get, bool is_field) {
697 assert(is_get || is_field, "can't inline putstatic");
698
699 // If the holder isn't linked then there isn't a lot we can do
700 if (!target()->holder()->is_linked())
701 return false;
702
703 // Get the field
704 bool will_link;
705 ciField *field = iter()->get_field(will_link);
706 if (!will_link)
707 return false;
708
709 // If the field is mismatched then an exception needs throwing
710 if (is_field == field->is_static())
711 return false;
712
713 // Pop the value off the stack if necessary
714 if (!is_get) {
715 pop();
716 if (field->type()->is_two_word())
717 pop();
718 }
719
720 // Pop and null-check the receiver if necessary
721 if (is_field) {
722 if (!pop())
723 return false;
724 }
725
726 // Push the result if necessary
727 if (is_get) {
728 bool result_pushed = false;
729 if (field->is_constant() && field->is_static()) {
730 SharkConstant *sc = SharkConstant::for_field(iter());
731 if (sc->is_loaded()) {
732 push(sc->is_nonzero());
733 result_pushed = true;
734 }
735 }
736
737 if (!result_pushed)
738 push(false);
739
740 if (field->type()->is_two_word())
741 push(false);
742 }
743
744 return true;
745 }
746
747 bool SharkInliner::attempt_inline(ciMethod *target, SharkState *state) {
748 if (!Inline) {
749 return false;
750 }
751
752 if (SharkIntrinsics::is_intrinsic(target)) {
753 SharkIntrinsics::inline_intrinsic(target, state);
754 return true;
755 }
756
757 if (may_be_inlinable(target)) {
758 SharkInlinerHelper inliner(target, state);
759 if (inliner.is_inlinable()) {
760 inliner.do_inline();
761 return true;
762 }
763 }
764 return false;
765 }