Mercurial > hg > truffle
annotate src/share/vm/opto/idealKit.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | 6c97c830fb6f |
| children | e626685e9f6c |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2383
diff
changeset
|
2 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1000
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1000
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1000
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 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" | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
32 #include "opto/graphKit.hpp" |
| 1972 | 33 #include "opto/mulnode.hpp" |
| 34 #include "opto/phaseX.hpp" | |
| 35 #include "opto/subnode.hpp" | |
| 36 #include "opto/type.hpp" | |
| 37 | |
| 0 | 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); | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
0
diff
changeset
|
65 // declarations_done(); |
| 0 | 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 | |
|
2444
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
111 Node* _initial_i_o; // saves initial i_o until variables declared |
| 0 | 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: | |
|
2444
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
146 IdealKit(GraphKit* gkit, bool delay_all_transforms = false, bool has_declarations = false); |
| 0 | 147 ~IdealKit() { |
| 148 stop(); | |
| 149 drain_delay_transform(); | |
| 150 } | |
|
2444
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
151 void sync_kit(GraphKit* gkit); |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
152 |
| 0 | 153 // Control |
| 154 Node* ctrl() { return _cvstate->in(TypeFunc::Control); } | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
0
diff
changeset
|
155 void set_ctrl(Node* ctrl) { _cvstate->set_req(TypeFunc::Control, ctrl); } |
| 0 | 156 Node* top() { return C->top(); } |
| 157 MergeMemNode* merged_memory() { return _cvstate->in(TypeFunc::Memory)->as_MergeMem(); } | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
0
diff
changeset
|
158 void set_all_memory(Node* mem) { _cvstate->set_req(TypeFunc::Memory, mem); } |
|
2444
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
159 Node* i_o() { return _cvstate->in(TypeFunc::I_O); } |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
160 void set_i_o(Node* c) { _cvstate->set_req(TypeFunc::I_O, c); } |
| 0 | 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(); | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
1972
diff
changeset
|
169 void loop(GraphKit* gkit, int nargs, IdealVariable& iv, Node* init, BoolTest::mask cmp, Node* limit, |
| 0 | 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); | |
|
851
fc4be448891f
6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents:
0
diff
changeset
|
175 void declarations_done(); |
| 0 | 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, | |
|
985
685e959d09ea
6877254: Server vm crashes with no branches off of store slice" when run with CMS and UseSuperWord(default)
cfang
parents:
851
diff
changeset
|
237 int oop_adr_idx, |
| 0 | 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, | |
|
2444
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
247 Node* parm2 = NULL, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
248 Node* parm3 = NULL); |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
249 |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
250 void make_leaf_call_no_fp(const TypeFunc *slow_call_type, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
251 address slow_call, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
252 const char *leaf_name, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
253 const TypePtr* adr_type, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
254 Node* parm0, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
255 Node* parm1, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
256 Node* parm2, |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
257 Node* parm3); |
|
07acc51c1d2a
7032314: Allow to generate CallLeafNoFPNode in IdealKit
kvn
parents:
2383
diff
changeset
|
258 |
| 0 | 259 }; |
| 1972 | 260 |
| 261 #endif // SHARE_VM_OPTO_IDEALKIT_HPP |