Mercurial > hg > truffle
annotate src/share/vm/opto/mulnode.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 | c7b60b601eb4 |
| children | 8c92982cbbc4 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, 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:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
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:
196
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_MULNODE_HPP |
| 26 #define SHARE_VM_OPTO_MULNODE_HPP | |
| 27 | |
| 28 #include "opto/node.hpp" | |
| 29 #include "opto/opcodes.hpp" | |
| 30 #include "opto/type.hpp" | |
| 31 | |
| 0 | 32 // Portions of code courtesy of Clifford Click |
| 33 | |
| 34 class PhaseTransform; | |
| 35 | |
| 36 //------------------------------MulNode---------------------------------------- | |
| 37 // Classic MULTIPLY functionality. This covers all the usual 'multiply' | |
| 38 // behaviors for an algebraic ring. Multiply-integer, multiply-float, | |
| 39 // multiply-double, and binary-and are all inherited from this class. The | |
| 40 // various identity values are supplied by virtual functions. | |
| 41 class MulNode : public Node { | |
| 42 virtual uint hash() const; | |
| 43 public: | |
| 3842 | 44 MulNode( Node *in1, Node *in2 ): Node(0,in1,in2) {} |
| 0 | 45 |
| 46 // Handle algebraic identities here. If we have an identity, return the Node | |
| 47 // we are equivalent to. We look for "add of zero" as an identity. | |
| 48 virtual Node *Identity( PhaseTransform *phase ); | |
| 49 | |
| 50 // We also canonicalize the Node, moving constants to the right input, | |
| 51 // and flatten expressions (so that 1+x+2 becomes x+3). | |
| 52 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 53 | |
| 54 // Compute a new Type for this node. Basically we just do the pre-check, | |
| 55 // then call the virtual add() to set the type. | |
| 56 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 57 | |
| 58 // Supplied function returns the product of the inputs. | |
| 59 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 60 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check. | |
| 61 // This call recognizes the multiplicative zero type. | |
| 62 virtual const Type *mul_ring( const Type *, const Type * ) const = 0; | |
| 63 | |
| 64 // Supplied function to return the multiplicative identity type | |
| 65 virtual const Type *mul_id() const = 0; | |
| 66 | |
| 67 // Supplied function to return the additive identity type | |
| 68 virtual const Type *add_id() const = 0; | |
| 69 | |
| 70 // Supplied function to return the additive opcode | |
| 71 virtual int add_opcode() const = 0; | |
| 72 | |
| 73 // Supplied function to return the multiplicative opcode | |
| 74 virtual int mul_opcode() const = 0; | |
| 75 | |
| 76 }; | |
| 77 | |
| 78 //------------------------------MulINode--------------------------------------- | |
| 79 // Multiply 2 integers | |
| 80 class MulINode : public MulNode { | |
| 81 public: | |
| 82 MulINode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} | |
| 83 virtual int Opcode() const; | |
| 84 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 85 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 86 const Type *mul_id() const { return TypeInt::ONE; } | |
| 87 const Type *add_id() const { return TypeInt::ZERO; } | |
| 88 int add_opcode() const { return Op_AddI; } | |
| 89 int mul_opcode() const { return Op_MulI; } | |
| 90 const Type *bottom_type() const { return TypeInt::INT; } | |
| 91 virtual uint ideal_reg() const { return Op_RegI; } | |
| 92 }; | |
| 93 | |
| 94 //------------------------------MulLNode--------------------------------------- | |
| 95 // Multiply 2 longs | |
| 96 class MulLNode : public MulNode { | |
| 97 public: | |
| 98 MulLNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} | |
| 99 virtual int Opcode() const; | |
| 100 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 101 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 102 const Type *mul_id() const { return TypeLong::ONE; } | |
| 103 const Type *add_id() const { return TypeLong::ZERO; } | |
| 104 int add_opcode() const { return Op_AddL; } | |
| 105 int mul_opcode() const { return Op_MulL; } | |
| 106 const Type *bottom_type() const { return TypeLong::LONG; } | |
| 107 virtual uint ideal_reg() const { return Op_RegL; } | |
| 108 }; | |
| 109 | |
| 110 | |
| 111 //------------------------------MulFNode--------------------------------------- | |
| 112 // Multiply 2 floats | |
| 113 class MulFNode : public MulNode { | |
| 114 public: | |
| 115 MulFNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} | |
| 116 virtual int Opcode() const; | |
| 117 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 118 const Type *mul_id() const { return TypeF::ONE; } | |
| 119 const Type *add_id() const { return TypeF::ZERO; } | |
| 120 int add_opcode() const { return Op_AddF; } | |
| 121 int mul_opcode() const { return Op_MulF; } | |
| 122 const Type *bottom_type() const { return Type::FLOAT; } | |
| 123 virtual uint ideal_reg() const { return Op_RegF; } | |
| 124 }; | |
| 125 | |
| 126 //------------------------------MulDNode--------------------------------------- | |
| 127 // Multiply 2 doubles | |
| 128 class MulDNode : public MulNode { | |
| 129 public: | |
| 130 MulDNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} | |
| 131 virtual int Opcode() const; | |
| 132 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 133 const Type *mul_id() const { return TypeD::ONE; } | |
| 134 const Type *add_id() const { return TypeD::ZERO; } | |
| 135 int add_opcode() const { return Op_AddD; } | |
| 136 int mul_opcode() const { return Op_MulD; } | |
| 137 const Type *bottom_type() const { return Type::DOUBLE; } | |
| 138 virtual uint ideal_reg() const { return Op_RegD; } | |
| 139 }; | |
| 140 | |
| 145 | 141 //-------------------------------MulHiLNode------------------------------------ |
| 142 // Upper 64 bits of a 64 bit by 64 bit multiply | |
| 143 class MulHiLNode : public Node { | |
| 144 public: | |
| 145 MulHiLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 146 virtual int Opcode() const; | |
| 147 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 148 const Type *bottom_type() const { return TypeLong::LONG; } | |
| 149 virtual uint ideal_reg() const { return Op_RegL; } | |
| 150 }; | |
| 0 | 151 |
| 152 //------------------------------AndINode--------------------------------------- | |
| 153 // Logically AND 2 integers. Included with the MUL nodes because it inherits | |
| 154 // all the behavior of multiplication on a ring. | |
| 155 class AndINode : public MulINode { | |
| 156 public: | |
| 157 AndINode( Node *in1, Node *in2 ) : MulINode(in1,in2) {} | |
| 158 virtual int Opcode() const; | |
| 159 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 160 virtual Node *Identity( PhaseTransform *phase ); | |
| 161 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 162 const Type *mul_id() const { return TypeInt::MINUS_1; } | |
| 163 const Type *add_id() const { return TypeInt::ZERO; } | |
| 164 int add_opcode() const { return Op_OrI; } | |
| 165 int mul_opcode() const { return Op_AndI; } | |
| 166 virtual uint ideal_reg() const { return Op_RegI; } | |
| 167 }; | |
| 168 | |
| 169 //------------------------------AndINode--------------------------------------- | |
| 170 // Logically AND 2 longs. Included with the MUL nodes because it inherits | |
| 171 // all the behavior of multiplication on a ring. | |
| 172 class AndLNode : public MulLNode { | |
| 173 public: | |
| 174 AndLNode( Node *in1, Node *in2 ) : MulLNode(in1,in2) {} | |
| 175 virtual int Opcode() const; | |
| 176 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 177 virtual Node *Identity( PhaseTransform *phase ); | |
| 178 virtual const Type *mul_ring( const Type *, const Type * ) const; | |
| 179 const Type *mul_id() const { return TypeLong::MINUS_1; } | |
| 180 const Type *add_id() const { return TypeLong::ZERO; } | |
| 181 int add_opcode() const { return Op_OrL; } | |
| 182 int mul_opcode() const { return Op_AndL; } | |
| 183 virtual uint ideal_reg() const { return Op_RegL; } | |
| 184 }; | |
| 185 | |
| 186 //------------------------------LShiftINode------------------------------------ | |
| 187 // Logical shift left | |
| 188 class LShiftINode : public Node { | |
| 189 public: | |
| 190 LShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 191 virtual int Opcode() const; | |
| 192 virtual Node *Identity( PhaseTransform *phase ); | |
| 193 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 194 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 195 const Type *bottom_type() const { return TypeInt::INT; } | |
| 196 virtual uint ideal_reg() const { return Op_RegI; } | |
| 197 }; | |
| 198 | |
| 199 //------------------------------LShiftLNode------------------------------------ | |
| 200 // Logical shift left | |
| 201 class LShiftLNode : public Node { | |
| 202 public: | |
| 203 LShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 204 virtual int Opcode() const; | |
| 205 virtual Node *Identity( PhaseTransform *phase ); | |
| 206 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 207 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 208 const Type *bottom_type() const { return TypeLong::LONG; } | |
| 209 virtual uint ideal_reg() const { return Op_RegL; } | |
| 210 }; | |
| 211 | |
| 212 //------------------------------RShiftINode------------------------------------ | |
| 213 // Signed shift right | |
| 214 class RShiftINode : public Node { | |
| 215 public: | |
| 216 RShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 217 virtual int Opcode() const; | |
| 218 virtual Node *Identity( PhaseTransform *phase ); | |
| 219 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 220 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 221 const Type *bottom_type() const { return TypeInt::INT; } | |
| 222 virtual uint ideal_reg() const { return Op_RegI; } | |
| 223 }; | |
| 224 | |
| 225 //------------------------------RShiftLNode------------------------------------ | |
| 226 // Signed shift right | |
| 227 class RShiftLNode : public Node { | |
| 228 public: | |
| 229 RShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 230 virtual int Opcode() const; | |
| 231 virtual Node *Identity( PhaseTransform *phase ); | |
| 232 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 233 const Type *bottom_type() const { return TypeLong::LONG; } | |
| 234 virtual uint ideal_reg() const { return Op_RegL; } | |
| 235 }; | |
| 236 | |
| 237 | |
| 238 //------------------------------URShiftINode----------------------------------- | |
| 239 // Logical shift right | |
| 240 class URShiftINode : public Node { | |
| 241 public: | |
| 242 URShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 243 virtual int Opcode() const; | |
| 244 virtual Node *Identity( PhaseTransform *phase ); | |
| 245 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 246 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 247 const Type *bottom_type() const { return TypeInt::INT; } | |
| 248 virtual uint ideal_reg() const { return Op_RegI; } | |
| 249 }; | |
| 250 | |
| 251 //------------------------------URShiftLNode----------------------------------- | |
| 252 // Logical shift right | |
| 253 class URShiftLNode : public Node { | |
| 254 public: | |
| 255 URShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} | |
| 256 virtual int Opcode() const; | |
| 257 virtual Node *Identity( PhaseTransform *phase ); | |
| 258 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 259 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 260 const Type *bottom_type() const { return TypeLong::LONG; } | |
| 261 virtual uint ideal_reg() const { return Op_RegL; } | |
| 262 }; | |
| 1972 | 263 |
| 264 #endif // SHARE_VM_OPTO_MULNODE_HPP |