1 /*

     2  * Copyright (c) 1999, 2007, 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 "incls/_precompiled.incl"

    27 #include "incls/_sharkInliner.cpp.incl"

    28 

    29 using namespace llvm;

    30 

    31 class SharkInlineBlock : public SharkBlock {

    32  public:

    33   SharkInlineBlock(ciMethod* target, SharkState* state)

    34     : SharkBlock(state, target),

    35       _outer_state(state),

    36       _entry_state(new SharkState(this)) {

    37     for (int i = target->max_locals() - 1; i >= 0; i--) {

    38       SharkValue *value = NULL;

    39       if (i < target->arg_size())

    40         value = outer_state()->pop();

    41       entry_state()->set_local(i, value);

    42     }

    43   }

    44 

    45  private:

    46   SharkState* _outer_state;

    47   SharkState* _entry_state;

    48 

    49  private:

    50   SharkState* outer_state() {

    51     return _outer_state;

    52   }

    53   SharkState* entry_state() {

    54     return _entry_state;

    55   }

    56 

    57  public:

    58   void emit_IR() {

    59     parse_bytecode(0, target()->code_size());

    60   }

    61 

    62  private:

    63   void do_return(BasicType type) {

    64     if (type != T_VOID) {

    65       SharkValue *result = pop_result(type);

    66       outer_state()->push(result);

    67       if (result->is_two_word())

    68         outer_state()->push(NULL);

    69     }

    70   }

    71 };

    72 

    73 class SharkInlinerHelper : public StackObj {

    74  public:

    75   SharkInlinerHelper(ciMethod* target, SharkState* entry_state)

    76     : _target(target),

    77       _entry_state(entry_state),

    78       _iter(target) {}

    79 

    80  private:

    81   ciBytecodeStream _iter;

    82   SharkState*      _entry_state;

    83   ciMethod*        _target;

    84 

    85  public:

    86   ciBytecodeStream* iter() {

    87     return &_iter;

    88   }

    89   SharkState* entry_state() const {

    90     return _entry_state;

    91   }

    92   ciMethod* target() const {

    93     return _target;

    94   }

    95 

    96  public:

    97   Bytecodes::Code bc() {

    98     return iter()->cur_bc();

    99   }

   100   int max_locals() const {

   101     return target()->max_locals();

   102   }

   103   int max_stack() const {

   104     return target()->max_stack();

   105   }

   106 

   107   // Inlinability check

   108  public:

   109   bool is_inlinable();

   110 

   111  private:

   112   void initialize_for_check();

   113 

   114   bool do_getstatic() {

   115     return do_field_access(true, false);

   116   }

   117   bool do_getfield() {

   118     return do_field_access(true, true);

   119   }

   120   bool do_putfield() {

   121     return do_field_access(false, true);

   122   }

   123   bool do_field_access(bool is_get, bool is_field);

   124 

   125   // Local variables for inlinability check

   126  private:

   127   bool* _locals;

   128 

   129  public:

   130   bool* local_addr(int index) const {

   131     assert(index >= 0 && index < max_locals(), "bad local variable index");

   132     return &_locals[index];

   133   }

   134   bool local(int index) const {

   135     return *local_addr(index);

   136   }

   137   void set_local(int index, bool value) {

   138     *local_addr(index) = value;

   139   }

   140 

   141   // Expression stack for inlinability check

   142  private:

   143   bool* _stack;

   144   bool* _sp;

   145 

   146  public:

   147   int stack_depth() const {

   148     return _sp - _stack;

   149   }

   150   bool* stack_addr(int slot) const {

   151     assert(slot >= 0 && slot < stack_depth(), "bad stack slot");

   152     return &_sp[-(slot + 1)];

   153   }

   154   void push(bool value) {

   155     assert(stack_depth() < max_stack(), "stack overrun");

   156     *(_sp++) = value;

   157   }

   158   bool pop() {

   159     assert(stack_depth() > 0, "stack underrun");

   160     return *(--_sp);

   161   }

   162 

   163   // Methods for two-word locals

   164  public:

   165   void push_pair_local(int index) {

   166     push(local(index));

   167     push(local(index + 1));

   168   }

   169   void pop_pair_local(int index) {

   170     set_local(index + 1, pop());

   171     set_local(index, pop());

   172   }

   173 

   174   // Code generation

   175  public:

   176   void do_inline() {

   177     (new SharkInlineBlock(target(), entry_state()))->emit_IR();

   178   }

   179 };

   180 

   181 // Quick checks so we can bail out before doing too much

   182 bool SharkInliner::may_be_inlinable(ciMethod *target) {

   183   // We can't inline native methods

   184   if (target->is_native())

   185     return false;

   186 

   187   // Not much point inlining abstract ones, and in any

   188   // case we'd need a stack frame to throw the exception

   189   if (target->is_abstract())

   190     return false;

   191 

   192   // Don't inline anything huge

   193   if (target->code_size() > SharkMaxInlineSize)

   194     return false;

   195 

   196   // Monitors aren't allowed without a frame to put them in

   197   if (target->is_synchronized() || target->has_monitor_bytecodes())

   198     return false;

   199 

   200   // We don't do control flow

   201   if (target->has_exception_handlers() || target->has_jsrs())

   202     return false;

   203 

   204   // Don't try to inline constructors, as they must

   205   // eventually call Object.<init> which we can't inline.

   206   // Note that this catches <clinit> too, but why would

   207   // we be compiling that?

   208   if (target->is_initializer())

   209     return false;

   210 

   211   // Mustn't inline Object.<init>

   212   // Should be caught by the above, but just in case...

   213   if (target->intrinsic_id() == vmIntrinsics::_Object_init)

   214     return false;

   215 

   216   return true;

   217 }

   218 

   219 // Full-on detailed check, for methods that pass the quick checks

   220 // Inlined methods have no stack frame, so we can't do anything

   221 // that would require one.  This means no safepoints (and hence

   222 // no loops) and no VM calls.  No VM calls means, amongst other

   223 // things, that no exceptions can be created, which means no null

   224 // checks or divide-by-zero checks are allowed.  The lack of null

   225 // checks in particular would eliminate practically everything,

   226 // but we can get around that restriction by relying on the zero-

   227 // check eliminator to strip the checks.  To do that, we need to

   228 // walk through the method, tracking which values are and are not

   229 // zero-checked.

   230 bool SharkInlinerHelper::is_inlinable() {

   231   ResourceMark rm;

   232   initialize_for_check();

   233 

   234   SharkConstant *sc;

   235   bool a, b, c, d;

   236 

   237   iter()->reset_to_bci(0);

   238   while (iter()->next() != ciBytecodeStream::EOBC()) {

   239     switch (bc()) {

   240     case Bytecodes::_nop:

   241       break;

   242 

   243     case Bytecodes::_aconst_null:

   244       push(false);

   245       break;

   246 

   247     case Bytecodes::_iconst_0:

   248       push(false);

   249       break;

   250     case Bytecodes::_iconst_m1:

   251     case Bytecodes::_iconst_1:

   252     case Bytecodes::_iconst_2:

   253     case Bytecodes::_iconst_3:

   254     case Bytecodes::_iconst_4:

   255     case Bytecodes::_iconst_5:

   256       push(true);

   257       break;

   258 

   259     case Bytecodes::_lconst_0:

   260       push(false);

   261       push(false);

   262       break;

   263     case Bytecodes::_lconst_1:

   264       push(true);

   265       push(false);

   266       break;

   267 

   268     case Bytecodes::_fconst_0:

   269     case Bytecodes::_fconst_1:

   270     case Bytecodes::_fconst_2:

   271       push(false);

   272       break;

   273 

   274     case Bytecodes::_dconst_0:

   275     case Bytecodes::_dconst_1:

   276       push(false);

   277       push(false);

   278       break;

   279 

   280     case Bytecodes::_bipush:

   281       push(iter()->get_constant_u1() != 0);

   282       break;

   283     case Bytecodes::_sipush:

   284       push(iter()->get_constant_u2() != 0);

   285       break;

   286 

   287     case Bytecodes::_ldc:

   288     case Bytecodes::_ldc_w:

   289     case Bytecodes::_ldc2_w:

   290       sc = SharkConstant::for_ldc(iter());

   291       if (!sc->is_loaded())

   292         return false;

   293       push(sc->is_nonzero());

   294       if (sc->is_two_word())

   295         push(false);

   296       break;

   297 

   298     case Bytecodes::_iload_0:

   299     case Bytecodes::_fload_0:

   300     case Bytecodes::_aload_0:

   301       push(local(0));

   302       break;

   303     case Bytecodes::_lload_0:

   304     case Bytecodes::_dload_0:

   305       push_pair_local(0);

   306       break;

   307 

   308     case Bytecodes::_iload_1:

   309     case Bytecodes::_fload_1:

   310     case Bytecodes::_aload_1:

   311       push(local(1));

   312       break;

   313     case Bytecodes::_lload_1:

   314     case Bytecodes::_dload_1:

   315       push_pair_local(1);

   316       break;

   317 

   318     case Bytecodes::_iload_2:

   319     case Bytecodes::_fload_2:

   320     case Bytecodes::_aload_2:

   321       push(local(2));

   322       break;

   323     case Bytecodes::_lload_2:

   324     case Bytecodes::_dload_2:

   325       push_pair_local(2);

   326       break;

   327 

   328     case Bytecodes::_iload_3:

   329     case Bytecodes::_fload_3:

   330     case Bytecodes::_aload_3:

   331       push(local(3));

   332       break;

   333     case Bytecodes::_lload_3:

   334     case Bytecodes::_dload_3:

   335       push_pair_local(3);

   336       break;

   337 

   338     case Bytecodes::_iload:

   339     case Bytecodes::_fload:

   340     case Bytecodes::_aload:

   341       push(local(iter()->get_index()));

   342       break;

   343     case Bytecodes::_lload:

   344     case Bytecodes::_dload:

   345       push_pair_local(iter()->get_index());

   346       break;

   347 

   348     case Bytecodes::_istore_0:

   349     case Bytecodes::_fstore_0:

   350     case Bytecodes::_astore_0:

   351       set_local(0, pop());

   352       break;

   353     case Bytecodes::_lstore_0:

   354     case Bytecodes::_dstore_0:

   355       pop_pair_local(0);

   356       break;

   357 

   358     case Bytecodes::_istore_1:

   359     case Bytecodes::_fstore_1:

   360     case Bytecodes::_astore_1:

   361       set_local(1, pop());

   362       break;

   363     case Bytecodes::_lstore_1:

   364     case Bytecodes::_dstore_1:

   365       pop_pair_local(1);

   366       break;

   367 

   368     case Bytecodes::_istore_2:

   369     case Bytecodes::_fstore_2:

   370     case Bytecodes::_astore_2:

   371       set_local(2, pop());

   372       break;

   373     case Bytecodes::_lstore_2:

   374     case Bytecodes::_dstore_2:

   375       pop_pair_local(2);

   376       break;

   377 

   378     case Bytecodes::_istore_3:

   379     case Bytecodes::_fstore_3:

   380     case Bytecodes::_astore_3:

   381       set_local(3, pop());

   382       break;

   383     case Bytecodes::_lstore_3:

   384     case Bytecodes::_dstore_3:

   385       pop_pair_local(3);

   386       break;

   387 

   388     case Bytecodes::_istore:

   389     case Bytecodes::_fstore:

   390     case Bytecodes::_astore:

   391       set_local(iter()->get_index(), pop());

   392       break;

   393     case Bytecodes::_lstore:

   394     case Bytecodes::_dstore:

   395       pop_pair_local(iter()->get_index());

   396       break;

   397 

   398     case Bytecodes::_pop:

   399       pop();

   400       break;

   401     case Bytecodes::_pop2:

   402       pop();

   403       pop();

   404       break;

   405     case Bytecodes::_swap:

   406       a = pop();

   407       b = pop();

   408       push(a);

   409       push(b);

   410       break;

   411     case Bytecodes::_dup:

   412       a = pop();

   413       push(a);

   414       push(a);

   415       break;

   416     case Bytecodes::_dup_x1:

   417       a = pop();

   418       b = pop();

   419       push(a);

   420       push(b);

   421       push(a);

   422       break;

   423     case Bytecodes::_dup_x2:

   424       a = pop();

   425       b = pop();

   426       c = pop();

   427       push(a);

   428       push(c);

   429       push(b);

   430       push(a);

   431       break;

   432     case Bytecodes::_dup2:

   433       a = pop();

   434       b = pop();

   435       push(b);

   436       push(a);

   437       push(b);

   438       push(a);

   439       break;

   440     case Bytecodes::_dup2_x1:

   441       a = pop();

   442       b = pop();

   443       c = pop();

   444       push(b);

   445       push(a);

   446       push(c);

   447       push(b);

   448       push(a);

   449       break;

   450     case Bytecodes::_dup2_x2:

   451       a = pop();

   452       b = pop();

   453       c = pop();

   454       d = pop();

   455       push(b);

   456       push(a);

   457       push(d);

   458       push(c);

   459       push(b);

   460       push(a);

   461       break;

   462 

   463     case Bytecodes::_getfield:

   464       if (!do_getfield())

   465         return false;

   466       break;

   467     case Bytecodes::_getstatic:

   468       if (!do_getstatic())

   469         return false;

   470       break;

   471     case Bytecodes::_putfield:

   472       if (!do_putfield())

   473         return false;

   474       break;

   475 

   476     case Bytecodes::_iadd:

   477     case Bytecodes::_isub:

   478     case Bytecodes::_imul:

   479     case Bytecodes::_iand:

   480     case Bytecodes::_ixor:

   481     case Bytecodes::_ishl:

   482     case Bytecodes::_ishr:

   483     case Bytecodes::_iushr:

   484       pop();

   485       pop();

   486       push(false);

   487       break;

   488     case Bytecodes::_ior:

   489       a = pop();

   490       b = pop();

   491       push(a && b);

   492       break;

   493     case Bytecodes::_idiv:

   494     case Bytecodes::_irem:

   495       if (!pop())

   496         return false;

   497       pop();

   498       push(false);

   499       break;

   500     case Bytecodes::_ineg:

   501       break;

   502 

   503     case Bytecodes::_ladd:

   504     case Bytecodes::_lsub:

   505     case Bytecodes::_lmul:

   506     case Bytecodes::_land:

   507     case Bytecodes::_lxor:

   508       pop();

   509       pop();

   510       pop();

   511       pop();

   512       push(false);

   513       push(false);

   514       break;

   515     case Bytecodes::_lor:

   516       a = pop();

   517       b = pop();

   518       push(a && b);

   519       break;

   520     case Bytecodes::_ldiv:

   521     case Bytecodes::_lrem:

   522       pop();

   523       if (!pop())

   524         return false;

   525       pop();

   526       pop();

   527       push(false);

   528       push(false);

   529       break;

   530     case Bytecodes::_lneg:

   531       break;

   532     case Bytecodes::_lshl:

   533     case Bytecodes::_lshr:

   534     case Bytecodes::_lushr:

   535       pop();

   536       pop();

   537       pop();

   538       push(false);

   539       push(false);

   540       break;

   541 

   542     case Bytecodes::_fadd:

   543     case Bytecodes::_fsub:

   544     case Bytecodes::_fmul:

   545     case Bytecodes::_fdiv:

   546     case Bytecodes::_frem:

   547       pop();

   548       pop();

   549       push(false);

   550       break;

   551     case Bytecodes::_fneg:

   552       break;

   553 

   554     case Bytecodes::_dadd:

   555     case Bytecodes::_dsub:

   556     case Bytecodes::_dmul:

   557     case Bytecodes::_ddiv:

   558     case Bytecodes::_drem:

   559       pop();

   560       pop();

   561       pop();

   562       pop();

   563       push(false);

   564       push(false);

   565       break;

   566     case Bytecodes::_dneg:

   567       break;

   568 

   569     case Bytecodes::_iinc:

   570       set_local(iter()->get_index(), false);

   571       break;

   572 

   573     case Bytecodes::_lcmp:

   574       pop();

   575       pop();

   576       pop();

   577       pop();

   578       push(false);

   579       break;

   580 

   581     case Bytecodes::_fcmpl:

   582     case Bytecodes::_fcmpg:

   583       pop();

   584       pop();

   585       push(false);

   586       break;

   587 

   588     case Bytecodes::_dcmpl:

   589     case Bytecodes::_dcmpg:

   590       pop();

   591       pop();

   592       pop();

   593       pop();

   594       push(false);

   595       break;

   596 

   597     case Bytecodes::_i2l:

   598       push(false);

   599       break;

   600     case Bytecodes::_i2f:

   601       pop();

   602       push(false);

   603       break;

   604     case Bytecodes::_i2d:

   605       pop();

   606       push(false);

   607       push(false);

   608       break;

   609 

   610     case Bytecodes::_l2i:

   611     case Bytecodes::_l2f:

   612       pop();

   613       pop();

   614       push(false);

   615       break;

   616     case Bytecodes::_l2d:

   617       pop();

   618       pop();

   619       push(false);

   620       push(false);

   621       break;

   622 

   623     case Bytecodes::_f2i:

   624       pop();

   625       push(false);

   626       break;

   627     case Bytecodes::_f2l:

   628     case Bytecodes::_f2d:

   629       pop();

   630       push(false);

   631       push(false);

   632       break;

   633 

   634     case Bytecodes::_d2i:

   635     case Bytecodes::_d2f:

   636       pop();

   637       pop();

   638       push(false);

   639       break;

   640     case Bytecodes::_d2l:

   641       pop();

   642       pop();

   643       push(false);

   644       push(false);

   645       break;

   646 

   647     case Bytecodes::_i2b:

   648     case Bytecodes::_i2c:

   649     case Bytecodes::_i2s:

   650       pop();

   651       push(false);

   652       break;

   653 

   654     case Bytecodes::_return:

   655     case Bytecodes::_ireturn:

   656     case Bytecodes::_lreturn:

   657     case Bytecodes::_freturn:

   658     case Bytecodes::_dreturn:

   659     case Bytecodes::_areturn:

   660       break;

   661 

   662     default:

   663       return false;

   664     }

   665   }

   666 

   667   return true;

   668 }

   669 

   670 void SharkInlinerHelper::initialize_for_check() {

   671   _locals = NEW_RESOURCE_ARRAY(bool, max_locals());

   672   _stack = NEW_RESOURCE_ARRAY(bool, max_stack());

   673 

   674   memset(_locals, 0, max_locals() * sizeof(bool));

   675   for (int i = 0; i < target()->arg_size(); i++) {

   676     SharkValue *arg = entry_state()->stack(target()->arg_size() - 1 - i);

   677     if (arg && arg->zero_checked())

   678       set_local(i, true);

   679   }

   680 

   681   _sp = _stack;

   682 }

   683 

   684 bool SharkInlinerHelper::do_field_access(bool is_get, bool is_field) {

   685   assert(is_get || is_field, "can't inline putstatic");

   686 

   687   // If the holder isn't linked then there isn't a lot we can do

   688   if (!target()->holder()->is_linked())

   689     return false;

   690 

   691   // Get the field

   692   bool will_link;

   693   ciField *field = iter()->get_field(will_link);

   694   if (!will_link)

   695     return false;

   696 

   697   // If the field is mismatched then an exception needs throwing

   698   if (is_field == field->is_static())

   699     return false;

   700 

   701   // Pop the value off the stack if necessary

   702   if (!is_get) {

   703     pop();

   704     if (field->type()->is_two_word())

   705       pop();

   706   }

   707 

   708   // Pop and null-check the receiver if necessary

   709   if (is_field) {

   710     if (!pop())

   711       return false;

   712   }

   713 

   714   // Push the result if necessary

   715   if (is_get) {

   716     bool result_pushed = false;

   717     if (field->is_constant()) {

   718       SharkConstant *sc = SharkConstant::for_field(iter());

   719       if (sc->is_loaded()) {

   720         push(sc->is_nonzero());

   721         result_pushed = true;

   722       }

   723     }

   724 

   725     if (!result_pushed)

   726       push(false);

   727 

   728     if (field->type()->is_two_word())

   729       push(false);

   730   }

   731 

   732   return true;

   733 }

   734 

   735 bool SharkInliner::attempt_inline(ciMethod *target, SharkState *state) {

   736   if (SharkIntrinsics::is_intrinsic(target)) {

   737     SharkIntrinsics::inline_intrinsic(target, state);

   738     return true;

   739   }

   740 

   741   if (may_be_inlinable(target)) {

   742     SharkInlinerHelper inliner(target, state);

   743     if (inliner.is_inlinable()) {

   744       inliner.do_inline();

   745       return true;

   746     }

   747   }

   748   return false;

   749 }