idealKit.hpp revision 3718:b9a9ed0f8eeb 
1/*
2 * Copyright (c) 2005, 2012, 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
79class IdealKit;
80
81// Variable definition for IdealKit
82class 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
93class 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) IfTrueNode(iff)); }
179  Node* IfFalse(IfNode* iff) { return transform(new (C) 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) AddINode(l, r)); }
186  Node* SubI(Node* l, Node* r) { return transform(new (C) SubINode(l, r)); }
187  Node* AndI(Node* l, Node* r) { return transform(new (C) AndINode(l, r)); }
188  Node* MaxI(Node* l, Node* r) { return transform(new (C) MaxINode(l, r)); }
189  Node* LShiftI(Node* l, Node* r) { return transform(new (C) LShiftINode(l, r)); }
190  Node* CmpI(Node* l, Node* r) { return transform(new (C) CmpINode(l, r)); }
191  Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new (C) 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) CmpLNode(l, r)); }
196
197  // TLS
198  Node* thread()  {  return gvn().transform(new (C) ThreadLocalNode()); }
199
200  // Pointers
201  Node* AddP(Node *base, Node *ptr, Node *off) { return transform(new (C) AddPNode(base, ptr, off)); }
202  Node* CmpP(Node* l, Node* r) { return transform(new (C) CmpPNode(l, r)); }
203#ifdef _LP64
204  Node* XorX(Node* l, Node* r) { return transform(new (C) XorLNode(l, r)); }
205#else // _LP64
206  Node* XorX(Node* l, Node* r) { return transform(new (C) XorINode(l, r)); }
207#endif // _LP64
208  Node* URShiftX(Node* l, Node* r) { return transform(new (C) URShiftXNode(l, r)); }
209  Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
210  Node* CastPX(Node* ctl, Node* p) { return transform(new (C) 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
262