1 /*
   2  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_OPTO_IDEALKIT_HPP
  26 #define SHARE_VM_OPTO_IDEALKIT_HPP
  27 
  28 #include "opto/addnode.hpp"
  29 #include "opto/cfgnode.hpp"
  30 #include "opto/connode.hpp"
  31 #include "opto/divnode.hpp"
  32 #include "opto/graphKit.hpp"
  33 #include "opto/mulnode.hpp"
  34 #include "opto/phaseX.hpp"
  35 #include "opto/subnode.hpp"
  36 #include "opto/type.hpp"
  37 
  38 //-----------------------------------------------------------------------------
  39 //----------------------------IdealKit-----------------------------------------
  40 // Set of utilities for creating control flow and scalar SSA data flow.
  41 // Control:
  42 //    if_then(left, relop, right)
  43 //    else_ (optional)
  44 //    end_if
  45 //    loop(iv variable, initial, relop, limit)
  46 //       - sets iv to initial for first trip
  47 //       - exits when relation on limit is true
  48 //       - the values of initial and limit should be loop invariant
  49 //       - no increment, must be explicitly coded
  50 //       - final value of iv is available after end_loop (until dead())
  51 //    end_loop
  52 //    make_label(number of gotos)
  53 //    goto_(label)
  54 //    bind(label)
  55 // Data:
  56 //    ConI(integer constant)     - create an integer constant
  57 //    set(variable, value)       - assignment
  58 //    value(variable)            - reference value
  59 //    dead(variable)             - variable's value is no longer live
  60 //    increment(variable, value) - increment variable by value
  61 //    simple operations: AddI, SubI, AndI, LShiftI, etc.
  62 // Example:
  63 //    Node* limit = ??
  64 //    IdealVariable i(kit), j(kit);
  65 //    declarations_done();
  66 //    Node* exit = make_label(1); // 1 goto
  67 //    set(j, ConI(0));
  68 //    loop(i, ConI(0), BoolTest::lt, limit); {
  69 //       if_then(value(i), BoolTest::gt, ConI(5)) {
  70 //         set(j, ConI(1));
  71 //         goto_(exit); dead(i);
  72 //       } end_if();
  73 //       increment(i, ConI(1));
  74 //    } end_loop(); dead(i);
  75 //    bind(exit);
  76 //
  77 // See string_indexOf for a more complete example.
  78 
  79 class IdealKit;
  80 
  81 // Variable definition for IdealKit
  82 class IdealVariable: public StackObj {
  83  friend class IdealKit;
  84  private:
  85   int _id;
  86   void set_id(int id) { _id = id; }
  87  public:
  88   IdealVariable(IdealKit &k);
  89   int id() { assert(has_id(),"uninitialized id"); return _id; }
  90   bool has_id() { return _id >= 0; }
  91 };
  92 
  93 class IdealKit: public StackObj {
  94  friend class IdealVariable;
  95   // The main state (called a cvstate for Control and Variables)
  96   // contains both the current values of the variables and the
  97   // current set of predecessor control edges.  The variable values
  98   // are managed via a Node [in(1)..in(_var_ct)], and the predecessor
  99   // control edges managed via a RegionNode. The in(0) of the Node
 100   // for variables points to the RegionNode for the control edges.
 101  protected:
 102   Compile * const C;
 103   PhaseGVN &_gvn;
 104   GrowableArray<Node*>* _pending_cvstates; // stack of cvstates
 105   GrowableArray<Node*>* _delay_transform;  // delay invoking gvn.transform until drain
 106   Node* _cvstate;                          // current cvstate (control, memory and variables)
 107   uint _var_ct;                            // number of variables
 108   bool _delay_all_transforms;              // flag forcing all transforms to be delayed
 109   Node* _initial_ctrl;                     // saves initial control until variables declared
 110   Node* _initial_memory;                   // saves initial memory  until variables declared
 111   Node* _initial_i_o;                      // saves initial i_o  until variables declared
 112 
 113   PhaseGVN& gvn() const { return _gvn; }
 114   // Create a new cvstate filled with nulls
 115   Node* new_cvstate();                     // Create a new cvstate
 116   Node* cvstate() { return _cvstate; }     // current cvstate
 117   Node* copy_cvstate();                    // copy current cvstate
 118 
 119   void set_memory(Node* mem, uint alias_idx );
 120   void do_memory_merge(Node* merging, Node* join);
 121   void clear(Node* m);                     // clear a cvstate
 122   void stop() { clear(_cvstate); }         // clear current cvstate
 123   Node* delay_transform(Node* n);
 124   Node* transform(Node* n);                // gvn.transform or push node on delay list
 125   Node* promote_to_phi(Node* n, Node* reg);// Promote "n" to a phi on region "reg"
 126   bool was_promoted_to_phi(Node* n, Node* reg) {
 127     return (n->is_Phi() && n->in(0) == reg);
 128   }
 129   void declare(IdealVariable* v) { v->set_id(_var_ct++); }
 130   // This declares the position where vars are kept in the cvstate
 131   // For some degree of consistency we use the TypeFunc enum to
 132   // soak up spots in the inputs even though we only use early Control
 133   // and Memory slots. (So far.)
 134   static const uint first_var; // = TypeFunc::Parms + 1;
 135 
 136 #ifdef ASSERT
 137   enum State { NullS=0, BlockS=1, LoopS=2, IfThenS=4, ElseS=8, EndifS= 16 };
 138   GrowableArray<int>* _state;
 139   State state() { return (State)(_state->top()); }
 140 #endif
 141 
 142   // Users should not care about slices only MergedMem so no access for them.
 143   Node* memory(uint alias_idx);
 144 
 145  public:
 146   IdealKit(GraphKit* gkit, bool delay_all_transforms = false, bool has_declarations = false);
 147   ~IdealKit() {
 148     stop();
 149     drain_delay_transform();
 150   }
 151   void sync_kit(GraphKit* gkit);
 152 
 153   // Control
 154   Node* ctrl()                          { return _cvstate->in(TypeFunc::Control); }
 155   void set_ctrl(Node* ctrl)             { _cvstate->set_req(TypeFunc::Control, ctrl); }
 156   Node* top()                           { return C->top(); }
 157   MergeMemNode* merged_memory()         { return _cvstate->in(TypeFunc::Memory)->as_MergeMem(); }
 158   void set_all_memory(Node* mem)        { _cvstate->set_req(TypeFunc::Memory, mem); }
 159   Node* i_o()                           { return _cvstate->in(TypeFunc::I_O); }
 160   void set_i_o(Node* c)                 { _cvstate->set_req(TypeFunc::I_O, c); }
 161   void set(IdealVariable& v, Node* rhs) { _cvstate->set_req(first_var + v.id(), rhs); }
 162   Node* value(IdealVariable& v)         { return _cvstate->in(first_var + v.id()); }
 163   void dead(IdealVariable& v)           { set(v, (Node*)NULL); }
 164   void if_then(Node* left, BoolTest::mask relop, Node* right,
 165                float prob = PROB_FAIR, float cnt = COUNT_UNKNOWN,
 166                bool push_new_state = true);
 167   void else_();
 168   void end_if();
 169   void loop(GraphKit* gkit, int nargs, IdealVariable& iv, Node* init, BoolTest::mask cmp, Node* limit,
 170             float prob = PROB_LIKELY(0.9), float cnt = COUNT_UNKNOWN);
 171   void end_loop();
 172   Node* make_label(int goto_ct);
 173   void bind(Node* lab);
 174   void goto_(Node* lab, bool bind = false);
 175   void declarations_done();
 176   void drain_delay_transform();
 177 
 178   Node* IfTrue(IfNode* iff)  { return transform(new (C,1) IfTrueNode(iff)); }
 179   Node* IfFalse(IfNode* iff) { return transform(new (C,1) IfFalseNode(iff)); }
 180 
 181   // Data
 182   Node* ConI(jint k) { return (Node*)gvn().intcon(k); }
 183   Node* makecon(const Type *t)  const { return _gvn.makecon(t); }
 184 
 185   Node* AddI(Node* l, Node* r) { return transform(new (C,3) AddINode(l, r)); }
 186   Node* SubI(Node* l, Node* r) { return transform(new (C,3) SubINode(l, r)); }
 187   Node* AndI(Node* l, Node* r) { return transform(new (C,3) AndINode(l, r)); }
 188   Node* MaxI(Node* l, Node* r) { return transform(new (C,3) MaxINode(l, r)); }
 189   Node* LShiftI(Node* l, Node* r) { return transform(new (C,3) LShiftINode(l, r)); }
 190   Node* CmpI(Node* l, Node* r) { return transform(new (C,3) CmpINode(l, r)); }
 191   Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new (C,2) BoolNode(cmp, relop)); }
 192   void  increment(IdealVariable& v, Node* j)  { set(v, AddI(value(v), j)); }
 193   void  decrement(IdealVariable& v, Node* j)  { set(v, SubI(value(v), j)); }
 194 
 195   Node* CmpL(Node* l, Node* r) { return transform(new (C,3) CmpLNode(l, r)); }
 196 
 197   // TLS
 198   Node* thread()  {  return gvn().transform(new (C, 1) ThreadLocalNode()); }
 199 
 200   // Pointers
 201   Node* AddP(Node *base, Node *ptr, Node *off) { return transform(new (C,4) AddPNode(base, ptr, off)); }
 202   Node* CmpP(Node* l, Node* r) { return transform(new (C,3) CmpPNode(l, r)); }
 203 #ifdef _LP64
 204   Node* XorX(Node* l, Node* r) { return transform(new (C,3) XorLNode(l, r)); }
 205 #else // _LP64
 206   Node* XorX(Node* l, Node* r) { return transform(new (C,3) XorINode(l, r)); }
 207 #endif // _LP64
 208   Node* URShiftX(Node* l, Node* r) { return transform(new (C,3) URShiftXNode(l, r)); }
 209   Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
 210   Node* CastPX(Node* ctl, Node* p) { return transform(new (C,2) CastP2XNode(ctl, p)); }
 211   // Add a fixed offset to a pointer
 212   Node* basic_plus_adr(Node* base, Node* ptr, intptr_t offset);
 213 
 214   // Memory operations
 215 
 216   // This is the base version which is given an alias index.
 217   Node* load(Node* ctl,
 218              Node* adr,
 219              const Type* t,
 220              BasicType bt,
 221              int adr_idx,
 222              bool require_atomic_access = false);
 223 
 224   // Return the new StoreXNode
 225   Node* store(Node* ctl,
 226               Node* adr,
 227               Node* val,
 228               BasicType bt,
 229               int adr_idx,
 230               bool require_atomic_access = false);
 231 
 232   // Store a card mark ordered after store_oop
 233   Node* storeCM(Node* ctl,
 234                 Node* adr,
 235                 Node* val,
 236                 Node* oop_store,
 237                 int oop_adr_idx,
 238                 BasicType bt,
 239                 int adr_idx);
 240 
 241   // Trivial call
 242   void make_leaf_call(const TypeFunc *slow_call_type,
 243                       address slow_call,
 244                       const char *leaf_name,
 245                       Node* parm0,
 246                       Node* parm1 = NULL,
 247                       Node* parm2 = NULL,
 248                       Node* parm3 = NULL);
 249 
 250   void make_leaf_call_no_fp(const TypeFunc *slow_call_type,
 251                             address slow_call,
 252                             const char *leaf_name,
 253                             const TypePtr* adr_type,
 254                             Node* parm0,
 255                             Node* parm1,
 256                             Node* parm2,
 257                             Node* parm3);
 258 
 259 };
 260 
 261 #endif // SHARE_VM_OPTO_IDEALKIT_HPP