1 /*

     2  * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2008, 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 class SharkState;

    27 

    28 class SharkBlock : public SharkTargetInvariants {

    29  protected:

    30   SharkBlock(const SharkTargetInvariants* parent)

    31     : SharkTargetInvariants(parent),

    32       _iter(target()),

    33       _current_state(NULL) {}

    34 

    35   SharkBlock(const SharkCompileInvariants* parent, ciMethod* target)

    36     : SharkTargetInvariants(parent, target),

    37       _iter(target),

    38       _current_state(NULL) {}

    39 

    40  private:

    41   ciBytecodeStream _iter;

    42   SharkState*      _current_state;

    43 

    44  public:

    45   ciBytecodeStream* iter() {

    46     return &_iter;

    47   }

    48   Bytecodes::Code bc() {

    49     return iter()->cur_bc();

    50   }

    51   int bci() {

    52     return iter()->cur_bci();

    53   }

    54 

    55   // Entry state

    56  protected:

    57   virtual SharkState* entry_state();

    58 

    59   // Current state

    60  private:

    61   SharkState* initial_current_state();

    62 

    63  public:

    64   SharkState* current_state() {

    65     if (_current_state == NULL)

    66       set_current_state(initial_current_state());

    67     return _current_state;

    68   }

    69 

    70  protected:

    71   void set_current_state(SharkState* current_state) {

    72     _current_state = current_state;

    73   }

    74 

    75   // Local variables

    76  protected:

    77   SharkValue* local(int index) {

    78     SharkValue *value = current_state()->local(index);

    79     assert(value != NULL, "shouldn't be");

    80     assert(value->is_one_word() ||

    81            (index + 1 < max_locals() &&

    82             current_state()->local(index + 1) == NULL), "should be");

    83     return value;

    84   }

    85   void set_local(int index, SharkValue* value) {

    86     assert(value != NULL, "shouldn't be");

    87     current_state()->set_local(index, value);

    88     if (value->is_two_word())

    89       current_state()->set_local(index + 1, NULL);

    90   }

    91 

    92   // Expression stack (raw)

    93  protected:

    94   void xpush(SharkValue* value) {

    95     current_state()->push(value);

    96   }

    97   SharkValue* xpop() {

    98     return current_state()->pop();

    99   }

   100   SharkValue* xstack(int slot) {

   101     SharkValue *value = current_state()->stack(slot);

   102     assert(value != NULL, "shouldn't be");

   103     assert(value->is_one_word() ||

   104            (slot > 0 &&

   105             current_state()->stack(slot - 1) == NULL), "should be");

   106     return value;

   107   }

   108   int xstack_depth() {

   109     return current_state()->stack_depth();

   110   }

   111 

   112   // Expression stack (cooked)

   113  protected:

   114   void push(SharkValue* value) {

   115     assert(value != NULL, "shouldn't be");

   116     xpush(value);

   117     if (value->is_two_word())

   118       xpush(NULL);

   119   }

   120   SharkValue* pop() {

   121     int size = current_state()->stack(0) == NULL ? 2 : 1;

   122     if (size == 2)

   123       xpop();

   124     SharkValue *value = xpop();

   125     assert(value && value->size() == size, "should be");

   126     return value;

   127   }

   128   SharkValue* pop_result(BasicType type) {

   129     SharkValue *result = pop();

   130 

   131 #ifdef ASSERT

   132     switch (result->basic_type()) {

   133     case T_BOOLEAN:

   134     case T_BYTE:

   135     case T_CHAR:

   136     case T_SHORT:

   137       assert(type == T_INT, "type mismatch");

   138       break;

   139 

   140     case T_ARRAY:

   141       assert(type == T_OBJECT, "type mismatch");

   142       break;

   143 

   144     default:

   145       assert(result->basic_type() == type, "type mismatch");

   146     }

   147 #endif // ASSERT

   148 

   149     return result;

   150   }

   151 

   152   // Code generation

   153  public:

   154   virtual void emit_IR();

   155 

   156  protected:

   157   void parse_bytecode(int start, int limit);

   158 

   159   // Helpers

   160  protected:

   161   virtual void do_zero_check(SharkValue* value);

   162 

   163   // Zero checking

   164  protected:

   165   void check_null(SharkValue* object) {

   166     zero_check(object);

   167   }

   168   void check_divide_by_zero(SharkValue* value) {

   169     zero_check(value);

   170   }

   171  private:

   172   void zero_check(SharkValue* value) {

   173     if (!value->zero_checked())

   174       do_zero_check(value);

   175   }

   176 

   177   // Safepoints

   178  protected:

   179   virtual void maybe_add_backedge_safepoint();

   180 

   181   // Traps

   182  protected:

   183   virtual bool has_trap();

   184   virtual int  trap_request();

   185   virtual int  trap_bci();

   186   virtual void do_trap(int trap_request);

   187 

   188   // arraylength

   189  protected:

   190   virtual void do_arraylength();

   191 

   192   // *aload and *astore

   193  protected:

   194   virtual void do_aload(BasicType basic_type);

   195   virtual void do_astore(BasicType basic_type);

   196 

   197   // *div and *rem

   198  private:

   199   void do_idiv() {

   200     do_div_or_rem(false, false);

   201   }

   202   void do_irem() {

   203     do_div_or_rem(false, true);

   204   }

   205   void do_ldiv() {

   206     do_div_or_rem(true, false);

   207   }

   208   void do_lrem() {

   209     do_div_or_rem(true, true);

   210   }

   211   void do_div_or_rem(bool is_long, bool is_rem);

   212 

   213   // get* and put*

   214  private:

   215   void do_getstatic() {

   216     do_field_access(true, false);

   217   }

   218   void do_getfield() {

   219     do_field_access(true, true);

   220   }

   221   void do_putstatic() {

   222     do_field_access(false, false);

   223   }

   224   void do_putfield() {

   225     do_field_access(false, true);

   226   }

   227   void do_field_access(bool is_get, bool is_field);

   228 

   229   // lcmp and [fd]cmp[lg]

   230  private:

   231   void do_lcmp();

   232   void do_fcmp(bool is_double, bool unordered_is_greater);

   233 

   234   // *return and athrow

   235  protected:

   236   virtual void do_return(BasicType type);

   237   virtual void do_athrow();

   238 

   239   // goto*

   240  protected:

   241   virtual void do_goto();

   242 

   243   // jsr* and ret

   244  protected:

   245   virtual void do_jsr();

   246   virtual void do_ret();

   247 

   248   // if*

   249  protected:

   250   virtual void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);

   251 

   252   // *switch

   253  protected:

   254   int switch_default_dest();

   255   int switch_table_length();

   256   int switch_key(int i);

   257   int switch_dest(int i);

   258 

   259   virtual void do_switch();

   260 

   261   // invoke*

   262  protected:

   263   virtual void do_call();

   264 

   265   // checkcast and instanceof

   266  protected:

   267   virtual void do_instance_check();

   268   virtual bool maybe_do_instanceof_if();

   269 

   270   // new and *newarray

   271  protected:

   272   virtual void do_new();

   273   virtual void do_newarray();

   274   virtual void do_anewarray();

   275   virtual void do_multianewarray();

   276 

   277   // monitorenter and monitorexit

   278  protected:

   279   virtual void do_monitorenter();

   280   virtual void do_monitorexit();

   281 };