Mercurial > hg > truffle
annotate src/share/vm/opto/connode.hpp @ 20680:5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
Summary: dead backbranch in main loop results in erroneous array access
Reviewed-by: kvn, iveresov
| author | roland |
|---|---|
| date | Mon, 01 Dec 2014 22:27:00 +0100 |
| parents | 606acabe7b5c |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6804
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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:
775
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
775
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:
775
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_CONNODE_HPP |
| 26 #define SHARE_VM_OPTO_CONNODE_HPP | |
| 27 | |
| 28 #include "opto/node.hpp" | |
| 29 #include "opto/opcodes.hpp" | |
| 30 #include "opto/type.hpp" | |
| 31 | |
| 0 | 32 class PhaseTransform; |
| 33 class MachNode; | |
| 34 | |
| 35 //------------------------------ConNode---------------------------------------- | |
| 36 // Simple constants | |
| 37 class ConNode : public TypeNode { | |
| 38 public: | |
|
17671
de95063c0e34
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
6853
diff
changeset
|
39 ConNode( const Type *t ) : TypeNode(t->remove_speculative(),1) { |
| 0 | 40 init_req(0, (Node*)Compile::current()->root()); |
| 41 init_flags(Flag_is_Con); | |
| 42 } | |
| 43 virtual int Opcode() const; | |
| 44 virtual uint hash() const; | |
| 45 virtual const RegMask &out_RegMask() const { return RegMask::Empty; } | |
| 46 virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; } | |
| 47 | |
| 48 // Polymorphic factory method: | |
| 49 static ConNode* make( Compile* C, const Type *t ); | |
| 50 }; | |
| 51 | |
| 52 //------------------------------ConINode--------------------------------------- | |
| 53 // Simple integer constants | |
| 54 class ConINode : public ConNode { | |
| 55 public: | |
| 56 ConINode( const TypeInt *t ) : ConNode(t) {} | |
| 57 virtual int Opcode() const; | |
| 58 | |
| 59 // Factory method: | |
| 60 static ConINode* make( Compile* C, int con ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
61 return new (C) ConINode( TypeInt::make(con) ); |
| 0 | 62 } |
| 63 | |
| 64 }; | |
| 65 | |
| 66 //------------------------------ConPNode--------------------------------------- | |
| 67 // Simple pointer constants | |
| 68 class ConPNode : public ConNode { | |
| 69 public: | |
| 70 ConPNode( const TypePtr *t ) : ConNode(t) {} | |
| 71 virtual int Opcode() const; | |
| 72 | |
| 73 // Factory methods: | |
| 74 static ConPNode* make( Compile *C ,address con ) { | |
| 75 if (con == NULL) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
76 return new (C) ConPNode( TypePtr::NULL_PTR ) ; |
| 0 | 77 else |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
78 return new (C) ConPNode( TypeRawPtr::make(con) ); |
| 0 | 79 } |
| 80 }; | |
| 81 | |
| 82 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
83 //------------------------------ConNNode-------------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
84 // Simple narrow oop constants |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
85 class ConNNode : public ConNode { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
86 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
87 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {} |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
88 virtual int Opcode() const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
89 }; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
90 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
91 //------------------------------ConNKlassNode--------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
92 // Simple narrow klass constants |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
93 class ConNKlassNode : public ConNode { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
94 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
95 ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {} |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
96 virtual int Opcode() const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
97 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
98 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
99 |
| 0 | 100 //------------------------------ConLNode--------------------------------------- |
| 101 // Simple long constants | |
| 102 class ConLNode : public ConNode { | |
| 103 public: | |
| 104 ConLNode( const TypeLong *t ) : ConNode(t) {} | |
| 105 virtual int Opcode() const; | |
| 106 | |
| 107 // Factory method: | |
| 108 static ConLNode* make( Compile *C ,jlong con ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
109 return new (C) ConLNode( TypeLong::make(con) ); |
| 0 | 110 } |
| 111 | |
| 112 }; | |
| 113 | |
| 114 //------------------------------ConFNode--------------------------------------- | |
| 115 // Simple float constants | |
| 116 class ConFNode : public ConNode { | |
| 117 public: | |
| 118 ConFNode( const TypeF *t ) : ConNode(t) {} | |
| 119 virtual int Opcode() const; | |
| 120 | |
| 121 // Factory method: | |
| 122 static ConFNode* make( Compile *C, float con ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
123 return new (C) ConFNode( TypeF::make(con) ); |
| 0 | 124 } |
| 125 | |
| 126 }; | |
| 127 | |
| 128 //------------------------------ConDNode--------------------------------------- | |
| 129 // Simple double constants | |
| 130 class ConDNode : public ConNode { | |
| 131 public: | |
| 132 ConDNode( const TypeD *t ) : ConNode(t) {} | |
| 133 virtual int Opcode() const; | |
| 134 | |
| 135 // Factory method: | |
| 136 static ConDNode* make( Compile *C, double con ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
3899
diff
changeset
|
137 return new (C) ConDNode( TypeD::make(con) ); |
| 0 | 138 } |
| 139 | |
| 140 }; | |
| 141 | |
| 142 //------------------------------BinaryNode------------------------------------- | |
| 143 // Place holder for the 2 conditional inputs to a CMove. CMove needs 4 | |
| 144 // inputs: the Bool (for the lt/gt/eq/ne bits), the flags (result of some | |
| 145 // compare), and the 2 values to select between. The Matcher requires a | |
| 146 // binary tree so we break it down like this: | |
| 147 // (CMove (Binary bol cmp) (Binary src1 src2)) | |
| 148 class BinaryNode : public Node { | |
| 149 public: | |
| 150 BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { } | |
| 151 virtual int Opcode() const; | |
| 152 virtual uint ideal_reg() const { return 0; } | |
| 153 }; | |
| 154 | |
| 155 //------------------------------CMoveNode-------------------------------------- | |
| 156 // Conditional move | |
| 157 class CMoveNode : public TypeNode { | |
| 158 public: | |
| 159 enum { Control, // When is it safe to do this cmove? | |
| 160 Condition, // Condition controlling the cmove | |
| 161 IfFalse, // Value if condition is false | |
| 162 IfTrue }; // Value if condition is true | |
| 163 CMoveNode( Node *bol, Node *left, Node *right, const Type *t ) : TypeNode(t,4) | |
| 164 { | |
| 165 init_class_id(Class_CMove); | |
| 166 // all inputs are nullified in Node::Node(int) | |
| 167 // init_req(Control,NULL); | |
| 168 init_req(Condition,bol); | |
| 169 init_req(IfFalse,left); | |
| 170 init_req(IfTrue,right); | |
| 171 } | |
| 172 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 173 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 174 virtual Node *Identity( PhaseTransform *phase ); | |
| 175 static CMoveNode *make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ); | |
| 176 // Helper function to spot cmove graph shapes | |
| 177 static Node *is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ); | |
| 178 }; | |
| 179 | |
| 180 //------------------------------CMoveDNode------------------------------------- | |
| 181 class CMoveDNode : public CMoveNode { | |
| 182 public: | |
| 183 CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){} | |
| 184 virtual int Opcode() const; | |
| 185 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 186 }; | |
| 187 | |
| 188 //------------------------------CMoveFNode------------------------------------- | |
| 189 class CMoveFNode : public CMoveNode { | |
| 190 public: | |
| 191 CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {} | |
| 192 virtual int Opcode() const; | |
| 193 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 194 }; | |
| 195 | |
| 196 //------------------------------CMoveINode------------------------------------- | |
| 197 class CMoveINode : public CMoveNode { | |
| 198 public: | |
| 199 CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){} | |
| 200 virtual int Opcode() const; | |
| 201 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 202 }; | |
| 203 | |
| 204 //------------------------------CMoveLNode------------------------------------- | |
| 205 class CMoveLNode : public CMoveNode { | |
| 206 public: | |
| 207 CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){} | |
| 208 virtual int Opcode() const; | |
| 209 }; | |
| 210 | |
| 211 //------------------------------CMovePNode------------------------------------- | |
| 212 class CMovePNode : public CMoveNode { | |
| 213 public: | |
| 214 CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); } | |
| 215 virtual int Opcode() const; | |
| 216 }; | |
| 217 | |
|
164
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
218 //------------------------------CMoveNNode------------------------------------- |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
219 class CMoveNNode : public CMoveNode { |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
220 public: |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
221 CMoveNNode( Node *c, Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); } |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
222 virtual int Opcode() const; |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
223 }; |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
224 |
|
c436414a719e
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
163
diff
changeset
|
225 //------------------------------ConstraintCastNode----------------------------- |
| 0 | 226 // cast to a different range |
| 227 class ConstraintCastNode: public TypeNode { | |
| 228 public: | |
| 229 ConstraintCastNode (Node *n, const Type *t ): TypeNode(t,2) { | |
| 230 init_class_id(Class_ConstraintCast); | |
| 231 init_req(1, n); | |
| 232 } | |
| 233 virtual Node *Identity( PhaseTransform *phase ); | |
| 234 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 235 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 236 virtual int Opcode() const; | |
| 237 virtual uint ideal_reg() const = 0; | |
| 238 virtual Node *Ideal_DU_postCCP( PhaseCCP * ); | |
| 239 }; | |
| 240 | |
| 241 //------------------------------CastIINode------------------------------------- | |
| 242 // cast integer to integer (different range) | |
| 243 class CastIINode: public ConstraintCastNode { | |
|
20680
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
244 private: |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
245 // Can this node be removed post CCP or does it carry a required dependency? |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
246 const bool _carry_dependency; |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
247 |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
248 protected: |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
249 virtual uint cmp( const Node &n ) const; |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
250 virtual uint size_of() const; |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
251 |
| 0 | 252 public: |
|
20680
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
253 CastIINode(Node *n, const Type *t, bool carry_dependency = false) |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
254 : ConstraintCastNode(n,t), _carry_dependency(carry_dependency) {} |
| 0 | 255 virtual int Opcode() const; |
| 256 virtual uint ideal_reg() const { return Op_RegI; } | |
|
20680
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
257 virtual Node *Identity( PhaseTransform *phase ); |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
258 virtual const Type *Value( PhaseTransform *phase ) const; |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
259 virtual Node *Ideal_DU_postCCP( PhaseCCP * ); |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
260 #ifndef PRODUCT |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
261 virtual void dump_spec(outputStream *st) const; |
|
5b8e0f84f00f
8054478: C2: Incorrectly compiled char[] array access crashes JVM
roland
parents:
17780
diff
changeset
|
262 #endif |
| 0 | 263 }; |
| 264 | |
| 265 //------------------------------CastPPNode------------------------------------- | |
| 266 // cast pointer to pointer (different type) | |
| 267 class CastPPNode: public ConstraintCastNode { | |
| 268 public: | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
124
diff
changeset
|
269 CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {} |
| 0 | 270 virtual int Opcode() const; |
| 271 virtual uint ideal_reg() const { return Op_RegP; } | |
| 272 virtual Node *Ideal_DU_postCCP( PhaseCCP * ); | |
| 273 }; | |
| 274 | |
| 275 //------------------------------CheckCastPPNode-------------------------------- | |
| 276 // for _checkcast, cast pointer to pointer (different type), without JOIN, | |
| 277 class CheckCastPPNode: public TypeNode { | |
| 278 public: | |
| 279 CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) { | |
| 280 init_class_id(Class_CheckCastPP); | |
| 281 init_req(0, c); | |
| 282 init_req(1, n); | |
| 283 } | |
|
126
72f4a668df19
6625997: CastPP, CheckCastPP and Proj nodes are not dead loop safe
kvn
parents:
124
diff
changeset
|
284 |
| 0 | 285 virtual Node *Identity( PhaseTransform *phase ); |
| 286 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 287 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 288 virtual int Opcode() const; | |
| 289 virtual uint ideal_reg() const { return Op_RegP; } | |
| 290 // No longer remove CheckCast after CCP as it gives me a place to hang | |
| 291 // the proper address type - which is required to compute anti-deps. | |
| 292 //virtual Node *Ideal_DU_postCCP( PhaseCCP * ); | |
| 293 }; | |
| 294 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
295 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
296 //------------------------------EncodeNarrowPtr-------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
297 class EncodeNarrowPtrNode : public TypeNode { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
298 protected: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
299 EncodeNarrowPtrNode(Node* value, const Type* type): |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
300 TypeNode(type, 2) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
301 init_class_id(Class_EncodeNarrowPtr); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
302 init_req(0, NULL); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
303 init_req(1, value); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
304 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
305 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
306 virtual uint ideal_reg() const { return Op_RegN; } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
307 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp ); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
308 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
309 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
310 //------------------------------EncodeP-------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
311 // Encodes an oop pointers into its compressed form |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
312 // Takes an extra argument which is the real heap base as a long which |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
313 // may be useful for code generation in the backend. |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
314 class EncodePNode : public EncodeNarrowPtrNode { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
315 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
316 EncodePNode(Node* value, const Type* type): |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
317 EncodeNarrowPtrNode(value, type) { |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
164
diff
changeset
|
318 init_class_id(Class_EncodeP); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
319 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
320 virtual int Opcode() const; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
321 virtual Node *Identity( PhaseTransform *phase ); |
|
124
b130b98db9cf
6689060: Escape Analysis does not work with Compressed Oops
kvn
parents:
113
diff
changeset
|
322 virtual const Type *Value( PhaseTransform *phase ) const; |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
323 }; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
324 |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
325 //------------------------------EncodePKlass-------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
326 // Encodes a klass pointer into its compressed form |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
327 // Takes an extra argument which is the real heap base as a long which |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
328 // may be useful for code generation in the backend. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
329 class EncodePKlassNode : public EncodeNarrowPtrNode { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
330 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
331 EncodePKlassNode(Node* value, const Type* type): |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
332 EncodeNarrowPtrNode(value, type) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
333 init_class_id(Class_EncodePKlass); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
334 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
335 virtual int Opcode() const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
336 virtual Node *Identity( PhaseTransform *phase ); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
337 virtual const Type *Value( PhaseTransform *phase ) const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
338 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
339 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
340 //------------------------------DecodeNarrowPtr-------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
341 class DecodeNarrowPtrNode : public TypeNode { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
342 protected: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
343 DecodeNarrowPtrNode(Node* value, const Type* type): |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
344 TypeNode(type, 2) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
345 init_class_id(Class_DecodeNarrowPtr); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
346 init_req(0, NULL); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
347 init_req(1, value); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
348 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
349 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
350 virtual uint ideal_reg() const { return Op_RegP; } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
351 }; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
352 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
353 //------------------------------DecodeN-------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
354 // Converts a narrow oop into a real oop ptr. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
355 // Takes an extra argument which is the real heap base as a long which |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
356 // may be useful for code generation in the backend. |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
357 class DecodeNNode : public DecodeNarrowPtrNode { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
358 public: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
359 DecodeNNode(Node* value, const Type* type): |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
360 DecodeNarrowPtrNode(value, type) { |
|
168
7793bd37a336
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
164
diff
changeset
|
361 init_class_id(Class_DecodeN); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
362 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
363 virtual int Opcode() const; |
|
124
b130b98db9cf
6689060: Escape Analysis does not work with Compressed Oops
kvn
parents:
113
diff
changeset
|
364 virtual const Type *Value( PhaseTransform *phase ) const; |
|
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
365 virtual Node *Identity( PhaseTransform *phase ); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
366 }; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
367 |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
368 //------------------------------DecodeNKlass-------------------------------- |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
369 // Converts a narrow klass pointer into a real klass ptr. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
370 // Takes an extra argument which is the real heap base as a long which |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
371 // may be useful for code generation in the backend. |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
372 class DecodeNKlassNode : public DecodeNarrowPtrNode { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
373 public: |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
374 DecodeNKlassNode(Node* value, const Type* type): |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
375 DecodeNarrowPtrNode(value, type) { |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
376 init_class_id(Class_DecodeNKlass); |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
377 } |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
378 virtual int Opcode() const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
379 virtual const Type *Value( PhaseTransform *phase ) const; |
|
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6804
diff
changeset
|
380 virtual Node *Identity( PhaseTransform *phase ); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
381 }; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
382 |
| 0 | 383 //------------------------------Conv2BNode------------------------------------- |
| 384 // Convert int/pointer to a Boolean. Map zero to zero, all else to 1. | |
| 385 class Conv2BNode : public Node { | |
| 386 public: | |
| 387 Conv2BNode( Node *i ) : Node(0,i) {} | |
| 388 virtual int Opcode() const; | |
| 389 virtual const Type *bottom_type() const { return TypeInt::BOOL; } | |
| 390 virtual Node *Identity( PhaseTransform *phase ); | |
| 391 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 392 virtual uint ideal_reg() const { return Op_RegI; } | |
| 393 }; | |
| 394 | |
| 395 // The conversions operations are all Alpha sorted. Please keep it that way! | |
| 396 //------------------------------ConvD2FNode------------------------------------ | |
| 397 // Convert double to float | |
| 398 class ConvD2FNode : public Node { | |
| 399 public: | |
| 400 ConvD2FNode( Node *in1 ) : Node(0,in1) {} | |
| 401 virtual int Opcode() const; | |
| 402 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 403 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 404 virtual Node *Identity( PhaseTransform *phase ); | |
| 405 virtual uint ideal_reg() const { return Op_RegF; } | |
| 406 }; | |
| 407 | |
| 408 //------------------------------ConvD2INode------------------------------------ | |
| 409 // Convert Double to Integer | |
| 410 class ConvD2INode : public Node { | |
| 411 public: | |
| 412 ConvD2INode( Node *in1 ) : Node(0,in1) {} | |
| 413 virtual int Opcode() const; | |
| 414 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 415 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 416 virtual Node *Identity( PhaseTransform *phase ); | |
| 417 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 418 virtual uint ideal_reg() const { return Op_RegI; } | |
| 419 }; | |
| 420 | |
| 421 //------------------------------ConvD2LNode------------------------------------ | |
| 422 // Convert Double to Long | |
| 423 class ConvD2LNode : public Node { | |
| 424 public: | |
| 425 ConvD2LNode( Node *dbl ) : Node(0,dbl) {} | |
| 426 virtual int Opcode() const; | |
| 427 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 428 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 429 virtual Node *Identity( PhaseTransform *phase ); | |
| 430 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 431 virtual uint ideal_reg() const { return Op_RegL; } | |
| 432 }; | |
| 433 | |
| 434 //------------------------------ConvF2DNode------------------------------------ | |
| 435 // Convert Float to a Double. | |
| 436 class ConvF2DNode : public Node { | |
| 437 public: | |
| 438 ConvF2DNode( Node *in1 ) : Node(0,in1) {} | |
| 439 virtual int Opcode() const; | |
| 440 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 441 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 442 virtual uint ideal_reg() const { return Op_RegD; } | |
| 443 }; | |
| 444 | |
| 445 //------------------------------ConvF2INode------------------------------------ | |
| 446 // Convert float to integer | |
| 447 class ConvF2INode : public Node { | |
| 448 public: | |
| 449 ConvF2INode( Node *in1 ) : Node(0,in1) {} | |
| 450 virtual int Opcode() const; | |
| 451 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 452 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 453 virtual Node *Identity( PhaseTransform *phase ); | |
| 454 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 455 virtual uint ideal_reg() const { return Op_RegI; } | |
| 456 }; | |
| 457 | |
| 458 //------------------------------ConvF2LNode------------------------------------ | |
| 459 // Convert float to long | |
| 460 class ConvF2LNode : public Node { | |
| 461 public: | |
| 462 ConvF2LNode( Node *in1 ) : Node(0,in1) {} | |
| 463 virtual int Opcode() const; | |
| 464 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 465 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 466 virtual Node *Identity( PhaseTransform *phase ); | |
| 467 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 468 virtual uint ideal_reg() const { return Op_RegL; } | |
| 469 }; | |
| 470 | |
| 471 //------------------------------ConvI2DNode------------------------------------ | |
| 472 // Convert Integer to Double | |
| 473 class ConvI2DNode : public Node { | |
| 474 public: | |
| 475 ConvI2DNode( Node *in1 ) : Node(0,in1) {} | |
| 476 virtual int Opcode() const; | |
| 477 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 478 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 479 virtual uint ideal_reg() const { return Op_RegD; } | |
| 480 }; | |
| 481 | |
| 482 //------------------------------ConvI2FNode------------------------------------ | |
| 483 // Convert Integer to Float | |
| 484 class ConvI2FNode : public Node { | |
| 485 public: | |
| 486 ConvI2FNode( Node *in1 ) : Node(0,in1) {} | |
| 487 virtual int Opcode() const; | |
| 488 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 489 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 490 virtual Node *Identity( PhaseTransform *phase ); | |
| 491 virtual uint ideal_reg() const { return Op_RegF; } | |
| 492 }; | |
| 493 | |
| 494 //------------------------------ConvI2LNode------------------------------------ | |
| 495 // Convert integer to long | |
| 496 class ConvI2LNode : public TypeNode { | |
| 497 public: | |
| 498 ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT) | |
| 499 : TypeNode(t, 2) | |
| 500 { init_req(1, in1); } | |
| 501 virtual int Opcode() const; | |
| 502 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 503 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 504 virtual uint ideal_reg() const { return Op_RegL; } | |
| 505 }; | |
| 506 | |
| 507 //------------------------------ConvL2DNode------------------------------------ | |
| 508 // Convert Long to Double | |
| 509 class ConvL2DNode : public Node { | |
| 510 public: | |
| 511 ConvL2DNode( Node *in1 ) : Node(0,in1) {} | |
| 512 virtual int Opcode() const; | |
| 513 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 514 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 515 virtual uint ideal_reg() const { return Op_RegD; } | |
| 516 }; | |
| 517 | |
| 518 //------------------------------ConvL2FNode------------------------------------ | |
| 519 // Convert Long to Float | |
| 520 class ConvL2FNode : public Node { | |
| 521 public: | |
| 522 ConvL2FNode( Node *in1 ) : Node(0,in1) {} | |
| 523 virtual int Opcode() const; | |
| 524 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 525 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 526 virtual uint ideal_reg() const { return Op_RegF; } | |
| 527 }; | |
| 528 | |
| 529 //------------------------------ConvL2INode------------------------------------ | |
| 530 // Convert long to integer | |
| 531 class ConvL2INode : public Node { | |
| 532 public: | |
| 533 ConvL2INode( Node *in1 ) : Node(0,in1) {} | |
| 534 virtual int Opcode() const; | |
| 535 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 536 virtual Node *Identity( PhaseTransform *phase ); | |
| 537 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 538 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 539 virtual uint ideal_reg() const { return Op_RegI; } | |
| 540 }; | |
| 541 | |
| 542 //------------------------------CastX2PNode------------------------------------- | |
| 543 // convert a machine-pointer-sized integer to a raw pointer | |
| 544 class CastX2PNode : public Node { | |
| 545 public: | |
| 546 CastX2PNode( Node *n ) : Node(NULL, n) {} | |
| 547 virtual int Opcode() const; | |
| 548 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 549 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 550 virtual Node *Identity( PhaseTransform *phase ); | |
| 551 virtual uint ideal_reg() const { return Op_RegP; } | |
| 552 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; } | |
| 553 }; | |
| 554 | |
| 555 //------------------------------CastP2XNode------------------------------------- | |
| 556 // Used in both 32-bit and 64-bit land. | |
| 557 // Used for card-marks and unsafe pointer math. | |
| 558 class CastP2XNode : public Node { | |
| 559 public: | |
| 560 CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {} | |
| 561 virtual int Opcode() const; | |
| 562 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 563 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 564 virtual Node *Identity( PhaseTransform *phase ); | |
| 565 virtual uint ideal_reg() const { return Op_RegX; } | |
| 566 virtual const Type *bottom_type() const { return TypeX_X; } | |
| 567 // Return false to keep node from moving away from an associated card mark. | |
| 568 virtual bool depends_only_on_test() const { return false; } | |
| 569 }; | |
| 570 | |
| 571 //------------------------------ThreadLocalNode-------------------------------- | |
| 572 // Ideal Node which returns the base of ThreadLocalStorage. | |
| 573 class ThreadLocalNode : public Node { | |
| 574 public: | |
| 575 ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {} | |
| 576 virtual int Opcode() const; | |
| 577 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;} | |
| 578 virtual uint ideal_reg() const { return Op_RegP; } | |
| 579 }; | |
| 580 | |
| 581 //------------------------------LoadReturnPCNode------------------------------- | |
| 582 class LoadReturnPCNode: public Node { | |
| 583 public: | |
| 584 LoadReturnPCNode(Node *c) : Node(c) { } | |
| 585 virtual int Opcode() const; | |
| 586 virtual uint ideal_reg() const { return Op_RegP; } | |
| 587 }; | |
| 588 | |
| 589 | |
| 590 //-----------------------------RoundFloatNode---------------------------------- | |
| 591 class RoundFloatNode: public Node { | |
| 592 public: | |
| 593 RoundFloatNode(Node* c, Node *in1): Node(c, in1) {} | |
| 594 virtual int Opcode() const; | |
| 595 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 596 virtual uint ideal_reg() const { return Op_RegF; } | |
| 597 virtual Node *Identity( PhaseTransform *phase ); | |
| 598 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 599 }; | |
| 600 | |
| 601 | |
| 602 //-----------------------------RoundDoubleNode--------------------------------- | |
| 603 class RoundDoubleNode: public Node { | |
| 604 public: | |
| 605 RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {} | |
| 606 virtual int Opcode() const; | |
| 607 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 608 virtual uint ideal_reg() const { return Op_RegD; } | |
| 609 virtual Node *Identity( PhaseTransform *phase ); | |
| 610 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 611 }; | |
| 612 | |
| 613 //------------------------------Opaque1Node------------------------------------ | |
| 614 // A node to prevent unwanted optimizations. Allows constant folding. | |
| 615 // Stops value-numbering, Ideal calls or Identity functions. | |
| 616 class Opaque1Node : public Node { | |
| 617 virtual uint hash() const ; // { return NO_HASH; } | |
| 618 virtual uint cmp( const Node &n ) const; | |
| 619 public: | |
|
216
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
620 Opaque1Node( Compile* C, Node *n ) : Node(0,n) { |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
621 // Put it on the Macro nodes list to removed during macro nodes expansion. |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
622 init_flags(Flag_is_macro); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
623 C->add_macro_node(this); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
624 } |
| 0 | 625 // Special version for the pre-loop to hold the original loop limit |
| 626 // which is consumed by range check elimination. | |
|
216
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
627 Opaque1Node( Compile* C, Node *n, Node* orig_limit ) : Node(0,n,orig_limit) { |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
628 // Put it on the Macro nodes list to removed during macro nodes expansion. |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
629 init_flags(Flag_is_macro); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
630 C->add_macro_node(this); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
631 } |
| 0 | 632 Node* original_loop_limit() { return req()==3 ? in(2) : NULL; } |
| 633 virtual int Opcode() const; | |
| 634 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 635 virtual Node *Identity( PhaseTransform *phase ); | |
| 636 }; | |
| 637 | |
| 638 //------------------------------Opaque2Node------------------------------------ | |
| 639 // A node to prevent unwanted optimizations. Allows constant folding. Stops | |
| 640 // value-numbering, most Ideal calls or Identity functions. This Node is | |
| 641 // specifically designed to prevent the pre-increment value of a loop trip | |
| 642 // counter from being live out of the bottom of the loop (hence causing the | |
| 643 // pre- and post-increment values both being live and thus requiring an extra | |
| 644 // temp register and an extra move). If we "accidentally" optimize through | |
| 645 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus | |
| 646 // it's OK to be slightly sloppy on optimizations here. | |
| 647 class Opaque2Node : public Node { | |
| 648 virtual uint hash() const ; // { return NO_HASH; } | |
| 649 virtual uint cmp( const Node &n ) const; | |
| 650 public: | |
|
216
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
651 Opaque2Node( Compile* C, Node *n ) : Node(0,n) { |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
652 // Put it on the Macro nodes list to removed during macro nodes expansion. |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
653 init_flags(Flag_is_macro); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
654 C->add_macro_node(this); |
|
8d191a7697e2
6715633: when matching a memory node the adr_type should not change
kvn
parents:
168
diff
changeset
|
655 } |
| 0 | 656 virtual int Opcode() const; |
| 657 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 658 }; | |
| 659 | |
| 17780 | 660 //------------------------------Opaque3Node------------------------------------ |
| 661 // A node to prevent unwanted optimizations. Will be optimized only during | |
| 662 // macro nodes expansion. | |
| 663 class Opaque3Node : public Opaque2Node { | |
| 664 int _opt; // what optimization it was used for | |
| 665 public: | |
| 666 enum { RTM_OPT }; | |
| 667 Opaque3Node(Compile* C, Node *n, int opt) : Opaque2Node(C, n), _opt(opt) {} | |
| 668 virtual int Opcode() const; | |
| 669 bool rtm_opt() const { return (_opt == RTM_OPT); } | |
| 670 }; | |
| 671 | |
| 672 | |
| 0 | 673 //----------------------PartialSubtypeCheckNode-------------------------------- |
| 674 // The 2nd slow-half of a subtype check. Scan the subklass's 2ndary superklass | |
| 675 // array for an instance of the superklass. Set a hidden internal cache on a | |
| 676 // hit (cache is checked with exposed code in gen_subtype_check()). Return | |
| 677 // not zero for a miss or zero for a hit. | |
| 678 class PartialSubtypeCheckNode : public Node { | |
| 679 public: | |
| 680 PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {} | |
| 681 virtual int Opcode() const; | |
| 682 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; } | |
| 683 virtual uint ideal_reg() const { return Op_RegP; } | |
| 684 }; | |
| 685 | |
| 686 // | |
| 687 class MoveI2FNode : public Node { | |
| 688 public: | |
| 689 MoveI2FNode( Node *value ) : Node(0,value) {} | |
| 690 virtual int Opcode() const; | |
| 691 virtual const Type *bottom_type() const { return Type::FLOAT; } | |
| 692 virtual uint ideal_reg() const { return Op_RegF; } | |
| 693 virtual const Type* Value( PhaseTransform *phase ) const; | |
| 694 }; | |
| 695 | |
| 696 class MoveL2DNode : public Node { | |
| 697 public: | |
| 698 MoveL2DNode( Node *value ) : Node(0,value) {} | |
| 699 virtual int Opcode() const; | |
| 700 virtual const Type *bottom_type() const { return Type::DOUBLE; } | |
| 701 virtual uint ideal_reg() const { return Op_RegD; } | |
| 702 virtual const Type* Value( PhaseTransform *phase ) const; | |
| 703 }; | |
| 704 | |
| 705 class MoveF2INode : public Node { | |
| 706 public: | |
| 707 MoveF2INode( Node *value ) : Node(0,value) {} | |
| 708 virtual int Opcode() const; | |
| 709 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 710 virtual uint ideal_reg() const { return Op_RegI; } | |
| 711 virtual const Type* Value( PhaseTransform *phase ) const; | |
| 712 }; | |
| 713 | |
| 714 class MoveD2LNode : public Node { | |
| 715 public: | |
| 716 MoveD2LNode( Node *value ) : Node(0,value) {} | |
| 717 virtual int Opcode() const; | |
| 718 virtual const Type *bottom_type() const { return TypeLong::LONG; } | |
| 719 virtual uint ideal_reg() const { return Op_RegL; } | |
| 720 virtual const Type* Value( PhaseTransform *phase ) const; | |
| 721 }; | |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
722 |
|
775
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
723 //---------- CountBitsNode ----------------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
724 class CountBitsNode : public Node { |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
725 public: |
|
775
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
726 CountBitsNode(Node* in1) : Node(0, in1) {} |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
727 const Type* bottom_type() const { return TypeInt::INT; } |
|
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
728 virtual uint ideal_reg() const { return Op_RegI; } |
|
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
729 }; |
|
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
730 |
|
775
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
731 //---------- CountLeadingZerosINode -------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
732 // Count leading zeros (0-bit count starting from MSB) of an integer. |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
733 class CountLeadingZerosINode : public CountBitsNode { |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
734 public: |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
735 CountLeadingZerosINode(Node* in1) : CountBitsNode(in1) {} |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
736 virtual int Opcode() const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
737 virtual const Type* Value(PhaseTransform* phase) const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
738 }; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
739 |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
740 //---------- CountLeadingZerosLNode -------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
741 // Count leading zeros (0-bit count starting from MSB) of a long. |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
742 class CountLeadingZerosLNode : public CountBitsNode { |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
743 public: |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
744 CountLeadingZerosLNode(Node* in1) : CountBitsNode(in1) {} |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
745 virtual int Opcode() const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
746 virtual const Type* Value(PhaseTransform* phase) const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
747 }; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
748 |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
749 //---------- CountTrailingZerosINode ------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
750 // Count trailing zeros (0-bit count starting from LSB) of an integer. |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
751 class CountTrailingZerosINode : public CountBitsNode { |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
752 public: |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
753 CountTrailingZerosINode(Node* in1) : CountBitsNode(in1) {} |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
754 virtual int Opcode() const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
755 virtual const Type* Value(PhaseTransform* phase) const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
756 }; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
757 |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
758 //---------- CountTrailingZerosLNode ------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
759 // Count trailing zeros (0-bit count starting from LSB) of a long. |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
760 class CountTrailingZerosLNode : public CountBitsNode { |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
761 public: |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
762 CountTrailingZerosLNode(Node* in1) : CountBitsNode(in1) {} |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
763 virtual int Opcode() const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
764 virtual const Type* Value(PhaseTransform* phase) const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
765 }; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
766 |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
767 //---------- PopCountINode ----------------------------------------------------- |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
768 // Population count (bit count) of an integer. |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
769 class PopCountINode : public CountBitsNode { |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
770 public: |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
771 PopCountINode(Node* in1) : CountBitsNode(in1) {} |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
772 virtual int Opcode() const; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
773 }; |
|
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
774 |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
775 //---------- PopCountLNode ----------------------------------------------------- |
|
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
776 // Population count (bit count) of a long. |
|
775
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
777 class PopCountLNode : public CountBitsNode { |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
778 public: |
|
775
93c14e5562c4
6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents:
643
diff
changeset
|
779 PopCountLNode(Node* in1) : CountBitsNode(in1) {} |
|
643
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
780 virtual int Opcode() const; |
|
c771b7f43bbf
6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents:
235
diff
changeset
|
781 }; |
| 1972 | 782 |
| 783 #endif // SHARE_VM_OPTO_CONNODE_HPP |