jdk8-mips64-public/hotspot: src/share/vm/shark/sharkInliner.cpp@01522ca68fc7

8015237: Parallelize string table scanning during strong root processing
Summary: Parallelize the scanning of the intern string table by having each GC worker claim a given number of buckets. Changes were also reviewed by Per Liden <per.liden@oracle.com>.
Reviewed-by: tschatzl, stefank, twisti

     1 /*

     2  * Copyright (c) 1999, 2010, 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  */

    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 "shark/sharkBlock.hpp"

    33 #include "shark/sharkConstant.hpp"

    34 #include "shark/sharkInliner.hpp"

    35 #include "shark/sharkIntrinsics.hpp"

    36 #include "shark/sharkState.hpp"

    37 #include "shark/sharkValue.hpp"

    38 #include "shark/shark_globals.hpp"

    40 using namespace llvm;

    42 class SharkInlineBlock : public SharkBlock {

    43  public:

    44   SharkInlineBlock(ciMethod* target, SharkState* state)

    45     : SharkBlock(state, target),

    46       _outer_state(state),

    47       _entry_state(new SharkState(this)) {

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

    49       SharkValue *value = NULL;

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

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

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

    53     }

    54   }

    56  private:

    57   SharkState* _outer_state;

    58   SharkState* _entry_state;

    60  private:

    61   SharkState* outer_state() {

    62     return _outer_state;

    63   }

    64   SharkState* entry_state() {

    65     return _entry_state;

    66   }

    68  public:

    69   void emit_IR() {

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

    71   }

    73  private:

    74   void do_return(BasicType type) {

    75     if (type != T_VOID) {

    76       SharkValue *result = pop_result(type);

    77       outer_state()->push(result);

    78       if (result->is_two_word())

    79         outer_state()->push(NULL);

    80     }

    81   }

    82 };

    84 class SharkInlinerHelper : public StackObj {

    85  public:

    86   SharkInlinerHelper(ciMethod* target, SharkState* entry_state)

    87     : _target(target),

    88       _entry_state(entry_state),

    89       _iter(target) {}

    91  private:

    92   ciBytecodeStream _iter;

    93   SharkState*      _entry_state;

    94   ciMethod*        _target;

    96  public:

    97   ciBytecodeStream* iter() {

    98     return &_iter;

    99   }

   100   SharkState* entry_state() const {

   101     return _entry_state;

   102   }

   103   ciMethod* target() const {

   104     return _target;

   105   }

   107  public:

   108   Bytecodes::Code bc() {

   109     return iter()->cur_bc();

   110   }

   111   int max_locals() const {

   112     return target()->max_locals();

   113   }

   114   int max_stack() const {

   115     return target()->max_stack();

   116   }

   118   // Inlinability check

   119  public:

   120   bool is_inlinable();

   122  private:

   123   void initialize_for_check();

   125   bool do_getstatic() {

   126     return do_field_access(true, false);

   127   }

   128   bool do_getfield() {

   129     return do_field_access(true, true);

   130   }

   131   bool do_putfield() {

   132     return do_field_access(false, true);

   133   }

   134   bool do_field_access(bool is_get, bool is_field);

   136   // Local variables for inlinability check

   137  private:

   138   bool* _locals;

   140  public:

   141   bool* local_addr(int index) const {

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

   143     return &_locals[index];

   144   }

   145   bool local(int index) const {

   146     return *local_addr(index);

   147   }

   148   void set_local(int index, bool value) {

   149     *local_addr(index) = value;

   150   }

   152   // Expression stack for inlinability check

   153  private:

   154   bool* _stack;

   155   bool* _sp;

   157  public:

   158   int stack_depth() const {

   159     return _sp - _stack;

   160   }

   161   bool* stack_addr(int slot) const {

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

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

   164   }

   165   void push(bool value) {

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

   167     *(_sp++) = value;

   168   }

   169   bool pop() {

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

   171     return *(--_sp);

   172   }

   174   // Methods for two-word locals

   175  public:

   176   void push_pair_local(int index) {

   177     push(local(index));

   178     push(local(index + 1));

   179   }

   180   void pop_pair_local(int index) {

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

   182     set_local(index, pop());

   183   }

   185   // Code generation

   186  public:

   187   void do_inline() {

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

   189   }

   190 };

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

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

   194   // We can't inline native methods

   195   if (target->is_native())

   196     return false;

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

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

   200   if (target->is_abstract())

   201     return false;

   203   // Don't inline anything huge

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

   205     return false;

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

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

   209     return false;

   211   // We don't do control flow

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

   213     return false;

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

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

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

   218   // we be compiling that?

   219   if (target->is_initializer())

   220     return false;

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

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

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

   225     return false;

   227   return true;

   228 }

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

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

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

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

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

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

   236 // checks in particular would eliminate practically everything,

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

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

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

   240 // zero-checked.

   241 bool SharkInlinerHelper::is_inlinable() {

   242   ResourceMark rm;

   243   initialize_for_check();

   245   SharkConstant *sc;

   246   bool a, b, c, d;

   248   iter()->reset_to_bci(0);

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

   250     switch (bc()) {

   251     case Bytecodes::_nop:

   252       break;

   254     case Bytecodes::_aconst_null:

   255       push(false);

   256       break;

   258     case Bytecodes::_iconst_0:

   259       push(false);

   260       break;

   261     case Bytecodes::_iconst_m1:

   262     case Bytecodes::_iconst_1:

   263     case Bytecodes::_iconst_2:

   264     case Bytecodes::_iconst_3:

   265     case Bytecodes::_iconst_4:

   266     case Bytecodes::_iconst_5:

   267       push(true);

   268       break;

   270     case Bytecodes::_lconst_0:

   271       push(false);

   272       push(false);

   273       break;

   274     case Bytecodes::_lconst_1:

   275       push(true);

   276       push(false);

   277       break;

   279     case Bytecodes::_fconst_0:

   280     case Bytecodes::_fconst_1:

   281     case Bytecodes::_fconst_2:

   282       push(false);

   283       break;

   285     case Bytecodes::_dconst_0:

   286     case Bytecodes::_dconst_1:

   287       push(false);

   288       push(false);

   289       break;

   291     case Bytecodes::_bipush:

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

   293       break;

   294     case Bytecodes::_sipush:

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

   296       break;

   298     case Bytecodes::_ldc:

   299     case Bytecodes::_ldc_w:

   300     case Bytecodes::_ldc2_w:

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

   302       if (!sc->is_loaded())

   303         return false;

   304       push(sc->is_nonzero());

   305       if (sc->is_two_word())

   306         push(false);

   307       break;

   309     case Bytecodes::_iload_0:

   310     case Bytecodes::_fload_0:

   311     case Bytecodes::_aload_0:

   312       push(local(0));

   313       break;

   314     case Bytecodes::_lload_0:

   315     case Bytecodes::_dload_0:

   316       push_pair_local(0);

   317       break;

   319     case Bytecodes::_iload_1:

   320     case Bytecodes::_fload_1:

   321     case Bytecodes::_aload_1:

   322       push(local(1));

   323       break;

   324     case Bytecodes::_lload_1:

   325     case Bytecodes::_dload_1:

   326       push_pair_local(1);

   327       break;

   329     case Bytecodes::_iload_2:

   330     case Bytecodes::_fload_2:

   331     case Bytecodes::_aload_2:

   332       push(local(2));

   333       break;

   334     case Bytecodes::_lload_2:

   335     case Bytecodes::_dload_2:

   336       push_pair_local(2);

   337       break;

   339     case Bytecodes::_iload_3:

   340     case Bytecodes::_fload_3:

   341     case Bytecodes::_aload_3:

   342       push(local(3));

   343       break;

   344     case Bytecodes::_lload_3:

   345     case Bytecodes::_dload_3:

   346       push_pair_local(3);

   347       break;

   349     case Bytecodes::_iload:

   350     case Bytecodes::_fload:

   351     case Bytecodes::_aload:

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

   353       break;

   354     case Bytecodes::_lload:

   355     case Bytecodes::_dload:

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

   357       break;

   359     case Bytecodes::_istore_0:

   360     case Bytecodes::_fstore_0:

   361     case Bytecodes::_astore_0:

   362       set_local(0, pop());

   363       break;

   364     case Bytecodes::_lstore_0:

   365     case Bytecodes::_dstore_0:

   366       pop_pair_local(0);

   367       break;

   369     case Bytecodes::_istore_1:

   370     case Bytecodes::_fstore_1:

   371     case Bytecodes::_astore_1:

   372       set_local(1, pop());

   373       break;

   374     case Bytecodes::_lstore_1:

   375     case Bytecodes::_dstore_1:

   376       pop_pair_local(1);

   377       break;

   379     case Bytecodes::_istore_2:

   380     case Bytecodes::_fstore_2:

   381     case Bytecodes::_astore_2:

   382       set_local(2, pop());

   383       break;

   384     case Bytecodes::_lstore_2:

   385     case Bytecodes::_dstore_2:

   386       pop_pair_local(2);

   387       break;

   389     case Bytecodes::_istore_3:

   390     case Bytecodes::_fstore_3:

   391     case Bytecodes::_astore_3:

   392       set_local(3, pop());

   393       break;

   394     case Bytecodes::_lstore_3:

   395     case Bytecodes::_dstore_3:

   396       pop_pair_local(3);

   397       break;

   399     case Bytecodes::_istore:

   400     case Bytecodes::_fstore:

   401     case Bytecodes::_astore:

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

   403       break;

   404     case Bytecodes::_lstore:

   405     case Bytecodes::_dstore:

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

   407       break;

   409     case Bytecodes::_pop:

   410       pop();

   411       break;

   412     case Bytecodes::_pop2:

   413       pop();

   414       pop();

   415       break;

   416     case Bytecodes::_swap:

   417       a = pop();

   418       b = pop();

   419       push(a);

   420       push(b);

   421       break;

   422     case Bytecodes::_dup:

   423       a = pop();

   424       push(a);

   425       push(a);

   426       break;

   427     case Bytecodes::_dup_x1:

   428       a = pop();

   429       b = pop();

   430       push(a);

   431       push(b);

   432       push(a);

   433       break;

   434     case Bytecodes::_dup_x2:

   435       a = pop();

   436       b = pop();

   437       c = pop();

   438       push(a);

   439       push(c);

   440       push(b);

   441       push(a);

   442       break;

   443     case Bytecodes::_dup2:

   444       a = pop();

   445       b = pop();

   446       push(b);

   447       push(a);

   448       push(b);

   449       push(a);

   450       break;

   451     case Bytecodes::_dup2_x1:

   452       a = pop();

   453       b = pop();

   454       c = pop();

   455       push(b);

   456       push(a);

   457       push(c);

   458       push(b);

   459       push(a);

   460       break;

   461     case Bytecodes::_dup2_x2:

   462       a = pop();

   463       b = pop();

   464       c = pop();

   465       d = pop();

   466       push(b);

   467       push(a);

   468       push(d);

   469       push(c);

   470       push(b);

   471       push(a);

   472       break;

   474     case Bytecodes::_getfield:

   475       if (!do_getfield())

   476         return false;

   477       break;

   478     case Bytecodes::_getstatic:

   479       if (!do_getstatic())

   480         return false;

   481       break;

   482     case Bytecodes::_putfield:

   483       if (!do_putfield())

   484         return false;

   485       break;

   487     case Bytecodes::_iadd:

   488     case Bytecodes::_isub:

   489     case Bytecodes::_imul:

   490     case Bytecodes::_iand:

   491     case Bytecodes::_ixor:

   492     case Bytecodes::_ishl:

   493     case Bytecodes::_ishr:

   494     case Bytecodes::_iushr:

   495       pop();

   496       pop();

   497       push(false);

   498       break;

   499     case Bytecodes::_ior:

   500       a = pop();

   501       b = pop();

   502       push(a && b);

   503       break;

   504     case Bytecodes::_idiv:

   505     case Bytecodes::_irem:

   506       if (!pop())

   507         return false;

   508       pop();

   509       push(false);

   510       break;

   511     case Bytecodes::_ineg:

   512       break;

   514     case Bytecodes::_ladd:

   515     case Bytecodes::_lsub:

   516     case Bytecodes::_lmul:

   517     case Bytecodes::_land:

   518     case Bytecodes::_lxor:

   519       pop();

   520       pop();

   521       pop();

   522       pop();

   523       push(false);

   524       push(false);

   525       break;

   526     case Bytecodes::_lor:

   527       a = pop();

   528       b = pop();

   529       push(a && b);

   530       break;

   531     case Bytecodes::_ldiv:

   532     case Bytecodes::_lrem:

   533       pop();

   534       if (!pop())

   535         return false;

   536       pop();

   537       pop();

   538       push(false);

   539       push(false);

   540       break;

   541     case Bytecodes::_lneg:

   542       break;

   543     case Bytecodes::_lshl:

   544     case Bytecodes::_lshr:

   545     case Bytecodes::_lushr:

   546       pop();

   547       pop();

   548       pop();

   549       push(false);

   550       push(false);

   551       break;

   553     case Bytecodes::_fadd:

   554     case Bytecodes::_fsub:

   555     case Bytecodes::_fmul:

   556     case Bytecodes::_fdiv:

   557     case Bytecodes::_frem:

   558       pop();

   559       pop();

   560       push(false);

   561       break;

   562     case Bytecodes::_fneg:

   563       break;

   565     case Bytecodes::_dadd:

   566     case Bytecodes::_dsub:

   567     case Bytecodes::_dmul:

   568     case Bytecodes::_ddiv:

   569     case Bytecodes::_drem:

   570       pop();

   571       pop();

   572       pop();

   573       pop();

   574       push(false);

   575       push(false);

   576       break;

   577     case Bytecodes::_dneg:

   578       break;

   580     case Bytecodes::_iinc:

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

   582       break;

   584     case Bytecodes::_lcmp:

   585       pop();

   586       pop();

   587       pop();

   588       pop();

   589       push(false);

   590       break;

   592     case Bytecodes::_fcmpl:

   593     case Bytecodes::_fcmpg:

   594       pop();

   595       pop();

   596       push(false);

   597       break;

   599     case Bytecodes::_dcmpl:

   600     case Bytecodes::_dcmpg:

   601       pop();

   602       pop();

   603       pop();

   604       pop();

   605       push(false);

   606       break;

   608     case Bytecodes::_i2l:

   609       push(false);

   610       break;

   611     case Bytecodes::_i2f:

   612       pop();

   613       push(false);

   614       break;

   615     case Bytecodes::_i2d:

   616       pop();

   617       push(false);

   618       push(false);

   619       break;

   621     case Bytecodes::_l2i:

   622     case Bytecodes::_l2f:

   623       pop();

   624       pop();

   625       push(false);

   626       break;

   627     case Bytecodes::_l2d:

   628       pop();

   629       pop();

   630       push(false);

   631       push(false);

   632       break;

   634     case Bytecodes::_f2i:

   635       pop();

   636       push(false);

   637       break;

   638     case Bytecodes::_f2l:

   639     case Bytecodes::_f2d:

   640       pop();

   641       push(false);

   642       push(false);

   643       break;

   645     case Bytecodes::_d2i:

   646     case Bytecodes::_d2f:

   647       pop();

   648       pop();

   649       push(false);

   650       break;

   651     case Bytecodes::_d2l:

   652       pop();

   653       pop();

   654       push(false);

   655       push(false);

   656       break;

   658     case Bytecodes::_i2b:

   659     case Bytecodes::_i2c:

   660     case Bytecodes::_i2s:

   661       pop();

   662       push(false);

   663       break;

   665     case Bytecodes::_return:

   666     case Bytecodes::_ireturn:

   667     case Bytecodes::_lreturn:

   668     case Bytecodes::_freturn:

   669     case Bytecodes::_dreturn:

   670     case Bytecodes::_areturn:

   671       break;

   673     default:

   674       return false;

   675     }

   676   }

   678   return true;

   679 }

   681 void SharkInlinerHelper::initialize_for_check() {

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

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

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

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

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

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

   689       set_local(i, true);

   690   }

   692   _sp = _stack;

   693 }

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

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

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

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

   700     return false;

   702   // Get the field

   703   bool will_link;

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

   705   if (!will_link)

   706     return false;

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

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

   710     return false;

   712   // Pop the value off the stack if necessary

   713   if (!is_get) {

   714     pop();

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

   716       pop();

   717   }

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

   720   if (is_field) {

   721     if (!pop())

   722       return false;

   723   }

   725   // Push the result if necessary

   726   if (is_get) {

   727     bool result_pushed = false;

   728     if (field->is_constant() && field->is_static()) {

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

   730       if (sc->is_loaded()) {

   731         push(sc->is_nonzero());

   732         result_pushed = true;

   733       }

   734     }

   736     if (!result_pushed)

   737       push(false);

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

   740       push(false);

   741   }

   743   return true;

   744 }

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

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

   748     SharkIntrinsics::inline_intrinsic(target, state);

   749     return true;

   750   }

   752   if (may_be_inlinable(target)) {

   753     SharkInlinerHelper inliner(target, state);

   754     if (inliner.is_inlinable()) {

   755       inliner.do_inline();

   756       return true;

   757     }

   758   }

   759   return false;

   760 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/shark/sharkInliner.cpp@01522ca68fc7

src/share/vm/shark/sharkInliner.cpp