1 /*

     2  * Copyright 1999-2006 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 // Predefined classes

    26 class ciField;

    27 class ValueStack;

    28 class InstructionPrinter;

    29 class IRScope;

    30 class LIR_OprDesc;

    31 typedef LIR_OprDesc* LIR_Opr;

    32 

    33 

    34 // Instruction class hierarchy

    35 //

    36 // All leaf classes in the class hierarchy are concrete classes

    37 // (i.e., are instantiated). All other classes are abstract and

    38 // serve factoring.

    39 

    40 class Instruction;

    41 class   HiWord;

    42 class   Phi;

    43 class   Local;

    44 class   Constant;

    45 class   AccessField;

    46 class     LoadField;

    47 class     StoreField;

    48 class   AccessArray;

    49 class     ArrayLength;

    50 class     AccessIndexed;

    51 class       LoadIndexed;

    52 class       StoreIndexed;

    53 class   NegateOp;

    54 class   Op2;

    55 class     ArithmeticOp;

    56 class     ShiftOp;

    57 class     LogicOp;

    58 class     CompareOp;

    59 class     IfOp;

    60 class   Convert;

    61 class   NullCheck;

    62 class   OsrEntry;

    63 class   ExceptionObject;

    64 class   StateSplit;

    65 class     Invoke;

    66 class     NewInstance;

    67 class     NewArray;

    68 class       NewTypeArray;

    69 class       NewObjectArray;

    70 class       NewMultiArray;

    71 class     TypeCheck;

    72 class       CheckCast;

    73 class       InstanceOf;

    74 class     AccessMonitor;

    75 class       MonitorEnter;

    76 class       MonitorExit;

    77 class     Intrinsic;

    78 class     BlockBegin;

    79 class     BlockEnd;

    80 class       Goto;

    81 class       If;

    82 class       IfInstanceOf;

    83 class       Switch;

    84 class         TableSwitch;

    85 class         LookupSwitch;

    86 class       Return;

    87 class       Throw;

    88 class       Base;

    89 class   RoundFP;

    90 class   UnsafeOp;

    91 class     UnsafeRawOp;

    92 class       UnsafeGetRaw;

    93 class       UnsafePutRaw;

    94 class     UnsafeObjectOp;

    95 class       UnsafeGetObject;

    96 class       UnsafePutObject;

    97 class       UnsafePrefetch;

    98 class         UnsafePrefetchRead;

    99 class         UnsafePrefetchWrite;

   100 class   ProfileCall;

   101 class   ProfileCounter;

   102 

   103 // A Value is a reference to the instruction creating the value

   104 typedef Instruction* Value;

   105 define_array(ValueArray, Value)

   106 define_stack(Values, ValueArray)

   107 

   108 define_array(ValueStackArray, ValueStack*)

   109 define_stack(ValueStackStack, ValueStackArray)

   110 

   111 // BlockClosure is the base class for block traversal/iteration.

   112 

   113 class BlockClosure: public CompilationResourceObj {

   114  public:

   115   virtual void block_do(BlockBegin* block)       = 0;

   116 };

   117 

   118 

   119 // Some array and list classes

   120 define_array(BlockBeginArray, BlockBegin*)

   121 define_stack(_BlockList, BlockBeginArray)

   122 

   123 class BlockList: public _BlockList {

   124  public:

   125   BlockList(): _BlockList() {}

   126   BlockList(const int size): _BlockList(size) {}

   127   BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}

   128 

   129   void iterate_forward(BlockClosure* closure);

   130   void iterate_backward(BlockClosure* closure);

   131   void blocks_do(void f(BlockBegin*));

   132   void values_do(void f(Value*));

   133   void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;

   134 };

   135 

   136 

   137 // InstructionVisitors provide type-based dispatch for instructions.

   138 // For each concrete Instruction class X, a virtual function do_X is

   139 // provided. Functionality that needs to be implemented for all classes

   140 // (e.g., printing, code generation) is factored out into a specialised

   141 // visitor instead of added to the Instruction classes itself.

   142 

   143 class InstructionVisitor: public StackObj {

   144  public:

   145           void do_HiWord         (HiWord*          x) { ShouldNotReachHere(); }

   146   virtual void do_Phi            (Phi*             x) = 0;

   147   virtual void do_Local          (Local*           x) = 0;

   148   virtual void do_Constant       (Constant*        x) = 0;

   149   virtual void do_LoadField      (LoadField*       x) = 0;

   150   virtual void do_StoreField     (StoreField*      x) = 0;

   151   virtual void do_ArrayLength    (ArrayLength*     x) = 0;

   152   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;

   153   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;

   154   virtual void do_NegateOp       (NegateOp*        x) = 0;

   155   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;

   156   virtual void do_ShiftOp        (ShiftOp*         x) = 0;

   157   virtual void do_LogicOp        (LogicOp*         x) = 0;

   158   virtual void do_CompareOp      (CompareOp*       x) = 0;

   159   virtual void do_IfOp           (IfOp*            x) = 0;

   160   virtual void do_Convert        (Convert*         x) = 0;

   161   virtual void do_NullCheck      (NullCheck*       x) = 0;

   162   virtual void do_Invoke         (Invoke*          x) = 0;

   163   virtual void do_NewInstance    (NewInstance*     x) = 0;

   164   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;

   165   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;

   166   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;

   167   virtual void do_CheckCast      (CheckCast*       x) = 0;

   168   virtual void do_InstanceOf     (InstanceOf*      x) = 0;

   169   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;

   170   virtual void do_MonitorExit    (MonitorExit*     x) = 0;

   171   virtual void do_Intrinsic      (Intrinsic*       x) = 0;

   172   virtual void do_BlockBegin     (BlockBegin*      x) = 0;

   173   virtual void do_Goto           (Goto*            x) = 0;

   174   virtual void do_If             (If*              x) = 0;

   175   virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;

   176   virtual void do_TableSwitch    (TableSwitch*     x) = 0;

   177   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;

   178   virtual void do_Return         (Return*          x) = 0;

   179   virtual void do_Throw          (Throw*           x) = 0;

   180   virtual void do_Base           (Base*            x) = 0;

   181   virtual void do_OsrEntry       (OsrEntry*        x) = 0;

   182   virtual void do_ExceptionObject(ExceptionObject* x) = 0;

   183   virtual void do_RoundFP        (RoundFP*         x) = 0;

   184   virtual void do_UnsafeGetRaw   (UnsafeGetRaw*    x) = 0;

   185   virtual void do_UnsafePutRaw   (UnsafePutRaw*    x) = 0;

   186   virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;

   187   virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;

   188   virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) = 0;

   189   virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;

   190   virtual void do_ProfileCall    (ProfileCall*     x) = 0;

   191   virtual void do_ProfileCounter (ProfileCounter*  x) = 0;

   192 };

   193 

   194 

   195 // Hashing support

   196 //

   197 // Note: This hash functions affect the performance

   198 //       of ValueMap - make changes carefully!

   199 

   200 #define HASH1(x1            )                    ((intx)(x1))

   201 #define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))

   202 #define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2    ) << 7) ^ HASH1(x3))

   203 #define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))

   204 

   205 

   206 // The following macros are used to implement instruction-specific hashing.

   207 // By default, each instruction implements hash() and is_equal(Value), used

   208 // for value numbering/common subexpression elimination. The default imple-

   209 // mentation disables value numbering. Each instruction which can be value-

   210 // numbered, should define corresponding hash() and is_equal(Value) functions

   211 // via the macros below. The f arguments specify all the values/op codes, etc.

   212 // that need to be identical for two instructions to be identical.

   213 //

   214 // Note: The default implementation of hash() returns 0 in order to indicate

   215 //       that the instruction should not be considered for value numbering.

   216 //       The currently used hash functions do not guarantee that never a 0

   217 //       is produced. While this is still correct, it may be a performance

   218 //       bug (no value numbering for that node). However, this situation is

   219 //       so unlikely, that we are not going to handle it specially.

   220 

   221 #define HASHING1(class_name, enabled, f1)             \

   222   virtual intx hash() const {                         \

   223     return (enabled) ? HASH2(name(), f1) : 0;         \

   224   }                                                   \

   225   virtual bool is_equal(Value v) const {              \

   226     if (!(enabled)  ) return false;                   \

   227     class_name* _v = v->as_##class_name();            \

   228     if (_v == NULL  ) return false;                   \

   229     if (f1 != _v->f1) return false;                   \

   230     return true;                                      \

   231   }                                                   \

   232 

   233 

   234 #define HASHING2(class_name, enabled, f1, f2)         \

   235   virtual intx hash() const {                         \

   236     return (enabled) ? HASH3(name(), f1, f2) : 0;     \

   237   }                                                   \

   238   virtual bool is_equal(Value v) const {              \

   239     if (!(enabled)  ) return false;                   \

   240     class_name* _v = v->as_##class_name();            \

   241     if (_v == NULL  ) return false;                   \

   242     if (f1 != _v->f1) return false;                   \

   243     if (f2 != _v->f2) return false;                   \

   244     return true;                                      \

   245   }                                                   \

   246 

   247 

   248 #define HASHING3(class_name, enabled, f1, f2, f3)     \

   249   virtual intx hash() const {                          \

   250     return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \

   251   }                                                   \

   252   virtual bool is_equal(Value v) const {              \

   253     if (!(enabled)  ) return false;                   \

   254     class_name* _v = v->as_##class_name();            \

   255     if (_v == NULL  ) return false;                   \

   256     if (f1 != _v->f1) return false;                   \

   257     if (f2 != _v->f2) return false;                   \

   258     if (f3 != _v->f3) return false;                   \

   259     return true;                                      \

   260   }                                                   \

   261 

   262 

   263 // The mother of all instructions...

   264 

   265 class Instruction: public CompilationResourceObj {

   266  private:

   267   static int   _next_id;                         // the node counter

   268 

   269   int          _id;                              // the unique instruction id

   270   int          _bci;                             // the instruction bci

   271   int          _use_count;                       // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1

   272   int          _pin_state;                       // set of PinReason describing the reason for pinning

   273   ValueType*   _type;                            // the instruction value type

   274   Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)

   275   Instruction* _subst;                           // the substitution instruction if any

   276   LIR_Opr      _operand;                         // LIR specific information

   277   unsigned int _flags;                           // Flag bits

   278 

   279   XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction

   280 

   281 #ifdef ASSERT

   282   HiWord*      _hi_word;

   283 #endif

   284 

   285   friend class UseCountComputer;

   286 

   287  protected:

   288   void set_bci(int bci)                          { assert(bci == SynchronizationEntryBCI || bci >= 0, "illegal bci"); _bci = bci; }

   289   void set_type(ValueType* type) {

   290     assert(type != NULL, "type must exist");

   291     _type = type;

   292   }

   293 

   294  public:

   295   enum InstructionFlag {

   296     NeedsNullCheckFlag = 0,

   297     CanTrapFlag,

   298     DirectCompareFlag,

   299     IsEliminatedFlag,

   300     IsInitializedFlag,

   301     IsLoadedFlag,

   302     IsSafepointFlag,

   303     IsStaticFlag,

   304     IsStrictfpFlag,

   305     NeedsStoreCheckFlag,

   306     NeedsWriteBarrierFlag,

   307     PreservesStateFlag,

   308     TargetIsFinalFlag,

   309     TargetIsLoadedFlag,

   310     TargetIsStrictfpFlag,

   311     UnorderedIsTrueFlag,

   312     NeedsPatchingFlag,

   313     ThrowIncompatibleClassChangeErrorFlag,

   314     ProfileMDOFlag,

   315     InstructionLastFlag

   316   };

   317 

   318  public:

   319   bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }

   320   void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };

   321 

   322   // 'globally' used condition values

   323   enum Condition {

   324     eql, neq, lss, leq, gtr, geq

   325   };

   326 

   327   // Instructions may be pinned for many reasons and under certain conditions

   328   // with enough knowledge it's possible to safely unpin them.

   329   enum PinReason {

   330       PinUnknown           = 1 << 0

   331     , PinExplicitNullCheck = 1 << 3

   332     , PinStackForStateSplit= 1 << 12

   333     , PinStateSplitConstructor= 1 << 13

   334     , PinGlobalValueNumbering= 1 << 14

   335   };

   336 

   337   static Condition mirror(Condition cond);

   338   static Condition negate(Condition cond);

   339 

   340   // initialization

   341   static void initialize()                       { _next_id = 0; }

   342   static int number_of_instructions()            { return _next_id; }

   343 

   344   // creation

   345   Instruction(ValueType* type, bool type_is_constant = false, bool create_hi = true)

   346   : _id(_next_id++)

   347   , _bci(-99)

   348   , _use_count(0)

   349   , _pin_state(0)

   350   , _type(type)

   351   , _next(NULL)

   352   , _subst(NULL)

   353   , _flags(0)

   354   , _operand(LIR_OprFact::illegalOpr)

   355   , _exception_handlers(NULL)

   356 #ifdef ASSERT

   357   , _hi_word(NULL)

   358 #endif

   359   {

   360     assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");

   361 #ifdef ASSERT

   362     if (create_hi && type->is_double_word()) {

   363       create_hi_word();

   364     }

   365 #endif

   366   }

   367 

   368   // accessors

   369   int id() const                                 { return _id; }

   370   int bci() const                                { return _bci; }

   371   int use_count() const                          { return _use_count; }

   372   int pin_state() const                          { return _pin_state; }

   373   bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }

   374   ValueType* type() const                        { return _type; }

   375   Instruction* prev(BlockBegin* block);          // use carefully, expensive operation

   376   Instruction* next() const                      { return _next; }

   377   bool has_subst() const                         { return _subst != NULL; }

   378   Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }

   379   LIR_Opr operand() const                        { return _operand; }

   380 

   381   void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }

   382   bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }

   383 

   384   bool has_uses() const                          { return use_count() > 0; }

   385   bool is_root() const                           { return is_pinned() || use_count() > 1; }

   386   XHandlers* exception_handlers() const          { return _exception_handlers; }

   387 

   388   // manipulation

   389   void pin(PinReason reason)                     { _pin_state |= reason; }

   390   void pin()                                     { _pin_state |= PinUnknown; }

   391   // DANGEROUS: only used by EliminateStores

   392   void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }

   393   virtual void set_lock_stack(ValueStack* l)     { /* do nothing*/ }

   394   virtual ValueStack* lock_stack() const         { return NULL; }

   395 

   396   Instruction* set_next(Instruction* next, int bci) {

   397     if (next != NULL) {

   398       assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");

   399       assert(next->as_Phi() == NULL && next->as_Local() == NULL, "shouldn't link these instructions into list");

   400       next->set_bci(bci);

   401     }

   402     _next = next;

   403     return next;

   404   }

   405 

   406   void set_subst(Instruction* subst)             {

   407     assert(subst == NULL ||

   408            type()->base() == subst->type()->base() ||

   409            subst->type()->base() == illegalType, "type can't change");

   410     _subst = subst;

   411   }

   412   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }

   413 

   414 #ifdef ASSERT

   415   // HiWord is used for debugging and is allocated early to avoid

   416   // allocation at inconvenient points

   417   HiWord* hi_word() { return _hi_word; }

   418   void create_hi_word();

   419 #endif

   420 

   421 

   422   // machine-specifics

   423   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }

   424   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }

   425 

   426   // generic

   427   virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro

   428   virtual HiWord*           as_HiWord()          { return NULL; }

   429   virtual Phi*           as_Phi()          { return NULL; }

   430   virtual Local*            as_Local()           { return NULL; }

   431   virtual Constant*         as_Constant()        { return NULL; }

   432   virtual AccessField*      as_AccessField()     { return NULL; }

   433   virtual LoadField*        as_LoadField()       { return NULL; }

   434   virtual StoreField*       as_StoreField()      { return NULL; }

   435   virtual AccessArray*      as_AccessArray()     { return NULL; }

   436   virtual ArrayLength*      as_ArrayLength()     { return NULL; }

   437   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }

   438   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }

   439   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }

   440   virtual NegateOp*         as_NegateOp()        { return NULL; }

   441   virtual Op2*              as_Op2()             { return NULL; }

   442   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }

   443   virtual ShiftOp*          as_ShiftOp()         { return NULL; }

   444   virtual LogicOp*          as_LogicOp()         { return NULL; }

   445   virtual CompareOp*        as_CompareOp()       { return NULL; }

   446   virtual IfOp*             as_IfOp()            { return NULL; }

   447   virtual Convert*          as_Convert()         { return NULL; }

   448   virtual NullCheck*        as_NullCheck()       { return NULL; }

   449   virtual OsrEntry*         as_OsrEntry()        { return NULL; }

   450   virtual StateSplit*       as_StateSplit()      { return NULL; }

   451   virtual Invoke*           as_Invoke()          { return NULL; }

   452   virtual NewInstance*      as_NewInstance()     { return NULL; }

   453   virtual NewArray*         as_NewArray()        { return NULL; }

   454   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }

   455   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }

   456   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }

   457   virtual TypeCheck*        as_TypeCheck()       { return NULL; }

   458   virtual CheckCast*        as_CheckCast()       { return NULL; }

   459   virtual InstanceOf*       as_InstanceOf()      { return NULL; }

   460   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }

   461   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }

   462   virtual MonitorExit*      as_MonitorExit()     { return NULL; }

   463   virtual Intrinsic*        as_Intrinsic()       { return NULL; }

   464   virtual BlockBegin*       as_BlockBegin()      { return NULL; }

   465   virtual BlockEnd*         as_BlockEnd()        { return NULL; }

   466   virtual Goto*             as_Goto()            { return NULL; }

   467   virtual If*               as_If()              { return NULL; }

   468   virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }

   469   virtual TableSwitch*      as_TableSwitch()     { return NULL; }

   470   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }

   471   virtual Return*           as_Return()          { return NULL; }

   472   virtual Throw*            as_Throw()           { return NULL; }

   473   virtual Base*             as_Base()            { return NULL; }

   474   virtual RoundFP*          as_RoundFP()         { return NULL; }

   475   virtual ExceptionObject*  as_ExceptionObject() { return NULL; }

   476   virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }

   477 

   478   virtual void visit(InstructionVisitor* v)      = 0;

   479 

   480   virtual bool can_trap() const                  { return false; }

   481 

   482   virtual void input_values_do(void f(Value*))   = 0;

   483   virtual void state_values_do(void f(Value*))   { /* usually no state - override on demand */ }

   484   virtual void other_values_do(void f(Value*))   { /* usually no other - override on demand */ }

   485           void       values_do(void f(Value*))   { input_values_do(f); state_values_do(f); other_values_do(f); }

   486 

   487   virtual ciType* exact_type() const             { return NULL; }

   488   virtual ciType* declared_type() const          { return NULL; }

   489 

   490   // hashing

   491   virtual const char* name() const               = 0;

   492   HASHING1(Instruction, false, id())             // hashing disabled by default

   493 

   494   // debugging

   495   void print()                                   PRODUCT_RETURN;

   496   void print_line()                              PRODUCT_RETURN;

   497   void print(InstructionPrinter& ip)             PRODUCT_RETURN;

   498 };

   499 

   500 

   501 // The following macros are used to define base (i.e., non-leaf)

   502 // and leaf instruction classes. They define class-name related

   503 // generic functionality in one place.

   504 

   505 #define BASE(class_name, super_class_name)       \

   506   class class_name: public super_class_name {    \

   507    public:                                       \

   508     virtual class_name* as_##class_name()        { return this; }              \

   509 

   510 

   511 #define LEAF(class_name, super_class_name)       \

   512   BASE(class_name, super_class_name)             \

   513    public:                                       \

   514     virtual const char* name() const             { return #class_name; }       \

   515     virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \

   516 

   517 

   518 // Debugging support

   519 

   520 #ifdef ASSERT

   521   static void assert_value(Value* x)             { assert((*x) != NULL, "value must exist"); }

   522   #define ASSERT_VALUES                          values_do(assert_value);

   523 #else

   524   #define ASSERT_VALUES

   525 #endif // ASSERT

   526 

   527 

   528 // A HiWord occupies the 'high word' of a 2-word

   529 // expression stack entry. Hi & lo words must be

   530 // paired on the expression stack (otherwise the

   531 // bytecode sequence is illegal). Note that 'hi'

   532 // refers to the IR expression stack format and

   533 // does *not* imply a machine word ordering. No

   534 // HiWords are used in optimized mode for speed,

   535 // but NULL pointers are used instead.

   536 

   537 LEAF(HiWord, Instruction)

   538  private:

   539   Value _lo_word;

   540 

   541  public:

   542   // creation

   543   HiWord(Value lo_word)

   544     : Instruction(illegalType, false, false),

   545       _lo_word(lo_word) {

   546     // hi-words are also allowed for illegal lo-words

   547     assert(lo_word->type()->is_double_word() || lo_word->type()->is_illegal(),

   548            "HiWord must be used for 2-word values only");

   549   }

   550 

   551   // accessors

   552   Value lo_word() const                          { return _lo_word->subst(); }

   553 

   554   // for invalidating of HiWords

   555   void make_illegal()                            { set_type(illegalType); }

   556 

   557   // generic

   558   virtual void input_values_do(void f(Value*))   { ShouldNotReachHere(); }

   559 };

   560 

   561 

   562 // A Phi is a phi function in the sense of SSA form. It stands for

   563 // the value of a local variable at the beginning of a join block.

   564 // A Phi consists of n operands, one for every incoming branch.

   565 

   566 LEAF(Phi, Instruction)

   567  private:

   568   BlockBegin* _block;    // the block to which the phi function belongs

   569   int         _pf_flags; // the flags of the phi function

   570   int         _index;    // to value on operand stack (index < 0) or to local

   571  public:

   572   // creation

   573   Phi(ValueType* type, BlockBegin* b, int index)

   574   : Instruction(type->base())

   575   , _pf_flags(0)

   576   , _block(b)

   577   , _index(index)

   578   {

   579     if (type->is_illegal()) {

   580       make_illegal();

   581     }

   582   }

   583 

   584   // flags

   585   enum Flag {

   586     no_flag         = 0,

   587     visited         = 1 << 0,

   588     cannot_simplify = 1 << 1

   589   };

   590 

   591   // accessors

   592   bool  is_local() const          { return _index >= 0; }

   593   bool  is_on_stack() const       { return !is_local(); }

   594   int   local_index() const       { assert(is_local(), ""); return _index; }

   595   int   stack_index() const       { assert(is_on_stack(), ""); return -(_index+1); }

   596 

   597   Value operand_at(int i) const;

   598   int   operand_count() const;

   599 

   600   BlockBegin* block() const       { return _block; }

   601 

   602   void   set(Flag f)              { _pf_flags |=  f; }

   603   void   clear(Flag f)            { _pf_flags &= ~f; }

   604   bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }

   605 

   606   // Invalidates phis corresponding to merges of locals of two different types

   607   // (these should never be referenced, otherwise the bytecodes are illegal)

   608   void   make_illegal() {

   609     set(cannot_simplify);

   610     set_type(illegalType);

   611   }

   612 

   613   bool is_illegal() const {

   614     return type()->is_illegal();

   615   }

   616 

   617   // generic

   618   virtual void input_values_do(void f(Value*)) {

   619   }

   620 };

   621 

   622 

   623 // A local is a placeholder for an incoming argument to a function call.

   624 LEAF(Local, Instruction)

   625  private:

   626   int      _java_index;                          // the local index within the method to which the local belongs

   627  public:

   628   // creation

   629   Local(ValueType* type, int index)

   630     : Instruction(type)

   631     , _java_index(index)

   632   {}

   633 

   634   // accessors

   635   int java_index() const                         { return _java_index; }

   636 

   637   // generic

   638   virtual void input_values_do(void f(Value*))   { /* no values */ }

   639 };

   640 

   641 

   642 LEAF(Constant, Instruction)

   643   ValueStack* _state;

   644 

   645  public:

   646   // creation

   647   Constant(ValueType* type):

   648       Instruction(type, true)

   649   , _state(NULL) {

   650     assert(type->is_constant(), "must be a constant");

   651   }

   652 

   653   Constant(ValueType* type, ValueStack* state):

   654     Instruction(type, true)

   655   , _state(state) {

   656     assert(state != NULL, "only used for constants which need patching");

   657     assert(type->is_constant(), "must be a constant");

   658     // since it's patching it needs to be pinned

   659     pin();

   660   }

   661 

   662   ValueStack* state() const               { return _state; }

   663 

   664   // generic

   665   virtual bool can_trap() const                  { return state() != NULL; }

   666   virtual void input_values_do(void f(Value*))   { /* no values */ }

   667   virtual void other_values_do(void f(Value*));

   668 

   669   virtual intx hash() const;

   670   virtual bool is_equal(Value v) const;

   671 

   672   virtual BlockBegin* compare(Instruction::Condition condition, Value right,

   673                               BlockBegin* true_sux, BlockBegin* false_sux);

   674 };

   675 

   676 

   677 BASE(AccessField, Instruction)

   678  private:

   679   Value       _obj;

   680   int         _offset;

   681   ciField*    _field;

   682   ValueStack* _state_before;                     // state is set only for unloaded or uninitialized fields

   683   ValueStack* _lock_stack;                       // contains lock and scope information

   684   NullCheck*  _explicit_null_check;              // For explicit null check elimination

   685 

   686  public:

   687   // creation

   688   AccessField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,

   689               ValueStack* state_before, bool is_loaded, bool is_initialized)

   690   : Instruction(as_ValueType(field->type()->basic_type()))

   691   , _obj(obj)

   692   , _offset(offset)

   693   , _field(field)

   694   , _lock_stack(lock_stack)

   695   , _state_before(state_before)

   696   , _explicit_null_check(NULL)

   697   {

   698     set_needs_null_check(!is_static);

   699     set_flag(IsLoadedFlag, is_loaded);

   700     set_flag(IsInitializedFlag, is_initialized);

   701     set_flag(IsStaticFlag, is_static);

   702     ASSERT_VALUES

   703       if (!is_loaded || (PatchALot && !field->is_volatile())) {

   704       // need to patch if the holder wasn't loaded or we're testing

   705       // using PatchALot.  Don't allow PatchALot for fields which are

   706       // known to be volatile they aren't patchable.

   707       set_flag(NeedsPatchingFlag, true);

   708     }

   709     // pin of all instructions with memory access

   710     pin();

   711   }

   712 

   713   // accessors

   714   Value obj() const                              { return _obj; }

   715   int offset() const                             { return _offset; }

   716   ciField* field() const                         { return _field; }

   717   BasicType field_type() const                   { return _field->type()->basic_type(); }

   718   bool is_static() const                         { return check_flag(IsStaticFlag); }

   719   bool is_loaded() const                         { return check_flag(IsLoadedFlag); }

   720   bool is_initialized() const                    { return check_flag(IsInitializedFlag); }

   721   ValueStack* state_before() const               { return _state_before; }

   722   ValueStack* lock_stack() const                 { return _lock_stack; }

   723   NullCheck* explicit_null_check() const         { return _explicit_null_check; }

   724   bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }

   725 

   726   // manipulation

   727   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }

   728   // Under certain circumstances, if a previous NullCheck instruction

   729   // proved the target object non-null, we can eliminate the explicit

   730   // null check and do an implicit one, simply specifying the debug

   731   // information from the NullCheck. This field should only be consulted

   732   // if needs_null_check() is true.

   733   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

   734 

   735   // generic

   736   virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }

   737   virtual void input_values_do(void f(Value*))   { f(&_obj); }

   738   virtual void other_values_do(void f(Value*));

   739 };

   740 

   741 

   742 LEAF(LoadField, AccessField)

   743  public:

   744   // creation

   745   LoadField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,

   746             ValueStack* state_before, bool is_loaded, bool is_initialized)

   747   : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)

   748   {}

   749 

   750   ciType* declared_type() const;

   751   ciType* exact_type() const;

   752 

   753   // generic

   754   HASHING2(LoadField, is_loaded() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if not yet loaded or if volatile

   755 };

   756 

   757 

   758 LEAF(StoreField, AccessField)

   759  private:

   760   Value _value;

   761 

   762  public:

   763   // creation

   764   StoreField(Value obj, int offset, ciField* field, Value value, bool is_static, ValueStack* lock_stack,

   765              ValueStack* state_before, bool is_loaded, bool is_initialized)

   766   : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)

   767   , _value(value)

   768   {

   769     set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());

   770     ASSERT_VALUES

   771     pin();

   772   }

   773 

   774   // accessors

   775   Value value() const                            { return _value; }

   776   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }

   777 

   778   // generic

   779   virtual void input_values_do(void f(Value*))   { AccessField::input_values_do(f); f(&_value); }

   780 };

   781 

   782 

   783 BASE(AccessArray, Instruction)

   784  private:

   785   Value       _array;

   786   ValueStack* _lock_stack;

   787 

   788  public:

   789   // creation

   790   AccessArray(ValueType* type, Value array, ValueStack* lock_stack)

   791   : Instruction(type)

   792   , _array(array)

   793   , _lock_stack(lock_stack) {

   794     set_needs_null_check(true);

   795     ASSERT_VALUES

   796     pin(); // instruction with side effect (null exception or range check throwing)

   797   }

   798 

   799   Value array() const                            { return _array; }

   800   ValueStack* lock_stack() const                 { return _lock_stack; }

   801 

   802   // setters

   803   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }

   804 

   805   // generic

   806   virtual bool can_trap() const                  { return needs_null_check(); }

   807   virtual void input_values_do(void f(Value*))   { f(&_array); }

   808   virtual void other_values_do(void f(Value*));

   809 };

   810 

   811 

   812 LEAF(ArrayLength, AccessArray)

   813  private:

   814   NullCheck*  _explicit_null_check;              // For explicit null check elimination

   815 

   816  public:

   817   // creation

   818   ArrayLength(Value array, ValueStack* lock_stack)

   819   : AccessArray(intType, array, lock_stack)

   820   , _explicit_null_check(NULL) {}

   821 

   822   // accessors

   823   NullCheck* explicit_null_check() const         { return _explicit_null_check; }

   824 

   825   // setters

   826   // See LoadField::set_explicit_null_check for documentation

   827   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

   828 

   829   // generic

   830   HASHING1(ArrayLength, true, array()->subst())

   831 };

   832 

   833 

   834 BASE(AccessIndexed, AccessArray)

   835  private:

   836   Value     _index;

   837   Value     _length;

   838   BasicType _elt_type;

   839 

   840  public:

   841   // creation

   842   AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)

   843   : AccessArray(as_ValueType(elt_type), array, lock_stack)

   844   , _index(index)

   845   , _length(length)

   846   , _elt_type(elt_type)

   847   {

   848     ASSERT_VALUES

   849   }

   850 

   851   // accessors

   852   Value index() const                            { return _index; }

   853   Value length() const                           { return _length; }

   854   BasicType elt_type() const                     { return _elt_type; }

   855 

   856   // perform elimination of range checks involving constants

   857   bool compute_needs_range_check();

   858 

   859   // generic

   860   virtual void input_values_do(void f(Value*))   { AccessArray::input_values_do(f); f(&_index); if (_length != NULL) f(&_length); }

   861 };

   862 

   863 

   864 LEAF(LoadIndexed, AccessIndexed)

   865  private:

   866   NullCheck*  _explicit_null_check;              // For explicit null check elimination

   867 

   868  public:

   869   // creation

   870   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)

   871   : AccessIndexed(array, index, length, elt_type, lock_stack)

   872   , _explicit_null_check(NULL) {}

   873 

   874   // accessors

   875   NullCheck* explicit_null_check() const         { return _explicit_null_check; }

   876 

   877   // setters

   878   // See LoadField::set_explicit_null_check for documentation

   879   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }

   880 

   881   ciType* exact_type() const;

   882   ciType* declared_type() const;

   883 

   884   // generic

   885   HASHING2(LoadIndexed, true, array()->subst(), index()->subst())

   886 };

   887 

   888 

   889 LEAF(StoreIndexed, AccessIndexed)

   890  private:

   891   Value       _value;

   892 

   893  public:

   894   // creation

   895   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* lock_stack)

   896   : AccessIndexed(array, index, length, elt_type, lock_stack)

   897   , _value(value)

   898   {

   899     set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));

   900     set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));

   901     ASSERT_VALUES

   902     pin();

   903   }

   904 

   905   // accessors

   906   Value value() const                            { return _value; }

   907   IRScope* scope() const;                        // the state's scope

   908   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }

   909   bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }

   910 

   911   // generic

   912   virtual void input_values_do(void f(Value*))   { AccessIndexed::input_values_do(f); f(&_value); }

   913 };

   914 

   915 

   916 LEAF(NegateOp, Instruction)

   917  private:

   918   Value _x;

   919 

   920  public:

   921   // creation

   922   NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {

   923     ASSERT_VALUES

   924   }

   925 

   926   // accessors

   927   Value x() const                                { return _x; }

   928 

   929   // generic

   930   virtual void input_values_do(void f(Value*))   { f(&_x); }

   931 };

   932 

   933 

   934 BASE(Op2, Instruction)

   935  private:

   936   Bytecodes::Code _op;

   937   Value           _x;

   938   Value           _y;

   939 

   940  public:

   941   // creation

   942   Op2(ValueType* type, Bytecodes::Code op, Value x, Value y) : Instruction(type), _op(op), _x(x), _y(y) {

   943     ASSERT_VALUES

   944   }

   945 

   946   // accessors

   947   Bytecodes::Code op() const                     { return _op; }

   948   Value x() const                                { return _x; }

   949   Value y() const                                { return _y; }

   950 

   951   // manipulators

   952   void swap_operands() {

   953     assert(is_commutative(), "operation must be commutative");

   954     Value t = _x; _x = _y; _y = t;

   955   }

   956 

   957   // generic

   958   virtual bool is_commutative() const            { return false; }

   959   virtual void input_values_do(void f(Value*))   { f(&_x); f(&_y); }

   960 };

   961 

   962 

   963 LEAF(ArithmeticOp, Op2)

   964  private:

   965   ValueStack* _lock_stack;                       // used only for division operations

   966  public:

   967   // creation

   968   ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* lock_stack)

   969   : Op2(x->type()->meet(y->type()), op, x, y)

   970   ,  _lock_stack(lock_stack) {

   971     set_flag(IsStrictfpFlag, is_strictfp);

   972     if (can_trap()) pin();

   973   }

   974 

   975   // accessors

   976   ValueStack* lock_stack() const                 { return _lock_stack; }

   977   bool        is_strictfp() const                { return check_flag(IsStrictfpFlag); }

   978 

   979   // setters

   980   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }

   981 

   982   // generic

   983   virtual bool is_commutative() const;

   984   virtual bool can_trap() const;

   985   virtual void other_values_do(void f(Value*));

   986   HASHING3(Op2, true, op(), x()->subst(), y()->subst())

   987 };

   988 

   989 

   990 LEAF(ShiftOp, Op2)

   991  public:

   992   // creation

   993   ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}

   994 

   995   // generic

   996   HASHING3(Op2, true, op(), x()->subst(), y()->subst())

   997 };

   998 

   999 

  1000 LEAF(LogicOp, Op2)

  1001  public:

  1002   // creation

  1003   LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}

  1004 

  1005   // generic

  1006   virtual bool is_commutative() const;

  1007   HASHING3(Op2, true, op(), x()->subst(), y()->subst())

  1008 };

  1009 

  1010 

  1011 LEAF(CompareOp, Op2)

  1012  private:

  1013   ValueStack* _state_before;                     // for deoptimization, when canonicalizing

  1014  public:

  1015   // creation

  1016   CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)

  1017   : Op2(intType, op, x, y)

  1018   , _state_before(state_before)

  1019   {}

  1020 

  1021   // accessors

  1022   ValueStack* state_before() const               { return _state_before; }

  1023 

  1024   // generic

  1025   HASHING3(Op2, true, op(), x()->subst(), y()->subst())

  1026   virtual void other_values_do(void f(Value*));

  1027 };

  1028 

  1029 

  1030 LEAF(IfOp, Op2)

  1031  private:

  1032   Value _tval;

  1033   Value _fval;

  1034 

  1035  public:

  1036   // creation

  1037   IfOp(Value x, Condition cond, Value y, Value tval, Value fval)

  1038   : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)

  1039   , _tval(tval)

  1040   , _fval(fval)

  1041   {

  1042     ASSERT_VALUES

  1043     assert(tval->type()->tag() == fval->type()->tag(), "types must match");

  1044   }

  1045 

  1046   // accessors

  1047   virtual bool is_commutative() const;

  1048   Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }

  1049   Condition cond() const                         { return (Condition)Op2::op(); }

  1050   Value tval() const                             { return _tval; }

  1051   Value fval() const                             { return _fval; }

  1052 

  1053   // generic

  1054   virtual void input_values_do(void f(Value*))   { Op2::input_values_do(f); f(&_tval); f(&_fval); }

  1055 };

  1056 

  1057 

  1058 LEAF(Convert, Instruction)

  1059  private:

  1060   Bytecodes::Code _op;

  1061   Value           _value;

  1062 

  1063  public:

  1064   // creation

  1065   Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {

  1066     ASSERT_VALUES

  1067   }

  1068 

  1069   // accessors

  1070   Bytecodes::Code op() const                     { return _op; }

  1071   Value value() const                            { return _value; }

  1072 

  1073   // generic

  1074   virtual void input_values_do(void f(Value*))   { f(&_value); }

  1075   HASHING2(Convert, true, op(), value()->subst())

  1076 };

  1077 

  1078 

  1079 LEAF(NullCheck, Instruction)

  1080  private:

  1081   Value       _obj;

  1082   ValueStack* _lock_stack;

  1083 

  1084  public:

  1085   // creation

  1086   NullCheck(Value obj, ValueStack* lock_stack) : Instruction(obj->type()->base()), _obj(obj), _lock_stack(lock_stack) {

  1087     ASSERT_VALUES

  1088     set_can_trap(true);

  1089     assert(_obj->type()->is_object(), "null check must be applied to objects only");

  1090     pin(Instruction::PinExplicitNullCheck);

  1091   }

  1092 

  1093   // accessors

  1094   Value obj() const                              { return _obj; }

  1095   ValueStack* lock_stack() const                 { return _lock_stack; }

  1096 

  1097   // setters

  1098   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }

  1099   void set_can_trap(bool can_trap)               { set_flag(CanTrapFlag, can_trap); }

  1100 

  1101   // generic

  1102   virtual bool can_trap() const                  { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }

  1103   virtual void input_values_do(void f(Value*))   { f(&_obj); }

  1104   virtual void other_values_do(void f(Value*));

  1105   HASHING1(NullCheck, true, obj()->subst())

  1106 };

  1107 

  1108 

  1109 BASE(StateSplit, Instruction)

  1110  private:

  1111   ValueStack* _state;

  1112 

  1113  protected:

  1114   static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);

  1115 

  1116  public:

  1117   // creation

  1118   StateSplit(ValueType* type) : Instruction(type), _state(NULL) {

  1119     pin(PinStateSplitConstructor);

  1120   }

  1121 

  1122   // accessors

  1123   ValueStack* state() const                      { return _state; }

  1124   IRScope* scope() const;                        // the state's scope

  1125 

  1126   // manipulation

  1127   void set_state(ValueStack* state)              { _state = state; }

  1128 

  1129   // generic

  1130   virtual void input_values_do(void f(Value*))   { /* no values */ }

  1131   virtual void state_values_do(void f(Value*));

  1132 };

  1133 

  1134 

  1135 LEAF(Invoke, StateSplit)