1 /* 2 * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_OPTO_SUBNODE_HPP 26 #define SHARE_OPTO_SUBNODE_HPP 27 28 #include "opto/node.hpp" 29 #include "opto/opcodes.hpp" 30 #include "opto/type.hpp" 31 32 // Portions of code courtesy of Clifford Click 33 34 //------------------------------SUBNode---------------------------------------- 35 // Class SUBTRACTION functionality. This covers all the usual 'subtract' 36 // behaviors. Subtract-integer, -float, -double, binary xor, compare-integer, 37 // -float, and -double are all inherited from this class. The compare 38 // functions behave like subtract functions, except that all negative answers 39 // are compressed into -1, and all positive answers compressed to 1. 40 class SubNode : public Node { 41 public: 42 SubNode( Node *in1, Node *in2 ) : Node(0,in1,in2) { 43 init_class_id(Class_Sub); 44 } 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(PhaseGVN* phase); 49 50 // Compute a new Type for this node. Basically we just do the pre-check, 51 // then call the virtual add() to set the type. 52 virtual const Type* Value(PhaseGVN* phase) const; 53 const Type* Value_common( PhaseTransform *phase ) const; 54 55 // Supplied function returns the subtractend of the inputs. 56 // This also type-checks the inputs for sanity. Guaranteed never to 57 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check. 58 virtual const Type *sub( const Type *, const Type * ) const = 0; 59 60 // Supplied function to return the additive identity type. 61 // This is returned whenever the subtracts inputs are the same. 62 virtual const Type *add_id() const = 0; 63 64 static SubNode* make(Node* in1, Node* in2, BasicType bt); 65 }; 66 67 68 // NOTE: SubINode should be taken away and replaced by add and negate 69 //------------------------------SubINode--------------------------------------- 70 // Subtract 2 integers 71 class SubINode : public SubNode { 72 public: 73 SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 74 virtual int Opcode() const; 75 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 76 virtual const Type *sub( const Type *, const Type * ) const; 77 const Type *add_id() const { return TypeInt::ZERO; } 78 const Type *bottom_type() const { return TypeInt::INT; } 79 virtual uint ideal_reg() const { return Op_RegI; } 80 }; 81 82 //------------------------------SubLNode--------------------------------------- 83 // Subtract 2 integers 84 class SubLNode : public SubNode { 85 public: 86 SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 87 virtual int Opcode() const; 88 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 89 virtual const Type *sub( const Type *, const Type * ) const; 90 const Type *add_id() const { return TypeLong::ZERO; } 91 const Type *bottom_type() const { return TypeLong::LONG; } 92 virtual uint ideal_reg() const { return Op_RegL; } 93 }; 94 95 // NOTE: SubFPNode should be taken away and replaced by add and negate 96 //------------------------------SubFPNode-------------------------------------- 97 // Subtract 2 floats or doubles 98 class SubFPNode : public SubNode { 99 protected: 100 SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 101 public: 102 const Type* Value(PhaseGVN* phase) const; 103 }; 104 105 // NOTE: SubFNode should be taken away and replaced by add and negate 106 //------------------------------SubFNode--------------------------------------- 107 // Subtract 2 doubles 108 class SubFNode : public SubFPNode { 109 public: 110 SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} 111 virtual int Opcode() const; 112 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 113 virtual const Type *sub( const Type *, const Type * ) const; 114 const Type *add_id() const { return TypeF::ZERO; } 115 const Type *bottom_type() const { return Type::FLOAT; } 116 virtual uint ideal_reg() const { return Op_RegF; } 117 }; 118 119 // NOTE: SubDNode should be taken away and replaced by add and negate 120 //------------------------------SubDNode--------------------------------------- 121 // Subtract 2 doubles 122 class SubDNode : public SubFPNode { 123 public: 124 SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} 125 virtual int Opcode() const; 126 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 127 virtual const Type *sub( const Type *, const Type * ) const; 128 const Type *add_id() const { return TypeD::ZERO; } 129 const Type *bottom_type() const { return Type::DOUBLE; } 130 virtual uint ideal_reg() const { return Op_RegD; } 131 }; 132 133 //------------------------------CmpNode--------------------------------------- 134 // Compare 2 values, returning condition codes (-1, 0 or 1). 135 class CmpNode : public SubNode { 136 public: 137 CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) { 138 init_class_id(Class_Cmp); 139 } 140 virtual Node* Identity(PhaseGVN* phase); 141 const Type *add_id() const { return TypeInt::ZERO; } 142 const Type *bottom_type() const { return TypeInt::CC; } 143 virtual uint ideal_reg() const { return Op_RegFlags; } 144 145 static CmpNode *make(Node *in1, Node *in2, BasicType bt, bool unsigned_comp = false); 146 147 #ifndef PRODUCT 148 // CmpNode and subclasses include all data inputs (until hitting a control 149 // boundary) in their related node set, as well as all outputs until and 150 // including eventual control nodes and their projections. 151 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 152 #endif 153 }; 154 155 //------------------------------CmpINode--------------------------------------- 156 // Compare 2 signed values, returning condition codes (-1, 0 or 1). 157 class CmpINode : public CmpNode { 158 public: 159 CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 160 virtual int Opcode() const; 161 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 162 virtual const Type *sub( const Type *, const Type * ) const; 163 }; 164 165 //------------------------------CmpUNode--------------------------------------- 166 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1). 167 class CmpUNode : public CmpNode { 168 public: 169 CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 170 virtual int Opcode() const; 171 virtual const Type *sub( const Type *, const Type * ) const; 172 const Type* Value(PhaseGVN* phase) const; 173 bool is_index_range_check() const; 174 }; 175 176 //------------------------------CmpPNode--------------------------------------- 177 // Compare 2 pointer values, returning condition codes (-1, 0 or 1). 178 class CmpPNode : public CmpNode { 179 public: 180 CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 181 virtual int Opcode() const; 182 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 183 virtual const Type *sub( const Type *, const Type * ) const; 184 }; 185 186 //------------------------------CmpNNode-------------------------------------- 187 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1). 188 class CmpNNode : public CmpNode { 189 public: 190 CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 191 virtual int Opcode() const; 192 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 193 virtual const Type *sub( const Type *, const Type * ) const; 194 }; 195 196 //------------------------------CmpLNode--------------------------------------- 197 // Compare 2 long values, returning condition codes (-1, 0 or 1). 198 class CmpLNode : public CmpNode { 199 public: 200 CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 201 virtual int Opcode() const; 202 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 203 virtual const Type *sub( const Type *, const Type * ) const; 204 }; 205 206 //------------------------------CmpULNode--------------------------------------- 207 // Compare 2 unsigned long values, returning condition codes (-1, 0 or 1). 208 class CmpULNode : public CmpNode { 209 public: 210 CmpULNode(Node* in1, Node* in2) : CmpNode(in1, in2) { } 211 virtual int Opcode() const; 212 virtual const Type* sub(const Type*, const Type*) const; 213 }; 214 215 //------------------------------CmpL3Node-------------------------------------- 216 // Compare 2 long values, returning integer value (-1, 0 or 1). 217 class CmpL3Node : public CmpLNode { 218 public: 219 CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) { 220 // Since it is not consumed by Bools, it is not really a Cmp. 221 init_class_id(Class_Sub); 222 } 223 virtual int Opcode() const; 224 virtual uint ideal_reg() const { return Op_RegI; } 225 }; 226 227 //------------------------------CmpFNode--------------------------------------- 228 // Compare 2 float values, returning condition codes (-1, 0 or 1). 229 // This implements the Java bytecode fcmpl, so unordered returns -1. 230 // Operands may not commute. 231 class CmpFNode : public CmpNode { 232 public: 233 CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 234 virtual int Opcode() const; 235 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } 236 const Type* Value(PhaseGVN* phase) const; 237 }; 238 239 //------------------------------CmpF3Node-------------------------------------- 240 // Compare 2 float values, returning integer value (-1, 0 or 1). 241 // This implements the Java bytecode fcmpl, so unordered returns -1. 242 // Operands may not commute. 243 class CmpF3Node : public CmpFNode { 244 public: 245 CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) { 246 // Since it is not consumed by Bools, it is not really a Cmp. 247 init_class_id(Class_Sub); 248 } 249 virtual int Opcode() const; 250 // Since it is not consumed by Bools, it is not really a Cmp. 251 virtual uint ideal_reg() const { return Op_RegI; } 252 }; 253 254 255 //------------------------------CmpDNode--------------------------------------- 256 // Compare 2 double values, returning condition codes (-1, 0 or 1). 257 // This implements the Java bytecode dcmpl, so unordered returns -1. 258 // Operands may not commute. 259 class CmpDNode : public CmpNode { 260 public: 261 CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 262 virtual int Opcode() const; 263 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } 264 const Type* Value(PhaseGVN* phase) const; 265 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 266 }; 267 268 //------------------------------CmpD3Node-------------------------------------- 269 // Compare 2 double values, returning integer value (-1, 0 or 1). 270 // This implements the Java bytecode dcmpl, so unordered returns -1. 271 // Operands may not commute. 272 class CmpD3Node : public CmpDNode { 273 public: 274 CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) { 275 // Since it is not consumed by Bools, it is not really a Cmp. 276 init_class_id(Class_Sub); 277 } 278 virtual int Opcode() const; 279 virtual uint ideal_reg() const { return Op_RegI; } 280 }; 281 282 283 //------------------------------BoolTest--------------------------------------- 284 // Convert condition codes to a boolean test value (0 or -1). 285 // We pick the values as 3 bits; the low order 2 bits we compare against the 286 // condition codes, the high bit flips the sense of the result. 287 // For vector compares, additionally, the 4th bit indicates if the compare is unsigned 288 struct BoolTest { 289 enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, never = 8, illegal = 9, 290 // The following values are used with vector compares 291 // A BoolTest value should not be constructed for such values 292 unsigned_compare = 16, 293 ule = unsigned_compare | le, uge = unsigned_compare | ge, ult = unsigned_compare | lt, ugt = unsigned_compare | gt }; 294 mask _test; 295 BoolTest( mask btm ) : _test(btm) { assert((btm & unsigned_compare) == 0, "unsupported");} 296 const Type *cc2logical( const Type *CC ) const; 297 // Commute the test. I use a small table lookup. The table is created as 298 // a simple char array where each element is the ASCII version of a 'mask' 299 // enum from above. 300 mask commute( ) const { return mask("032147658"[_test]-'0'); } 301 mask negate( ) const { return mask(_test^4); } 302 bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); } 303 bool is_less( ) const { return _test == BoolTest::lt || _test == BoolTest::le; } 304 bool is_greater( ) const { return _test == BoolTest::gt || _test == BoolTest::ge; } 305 void dump_on(outputStream *st) const; 306 mask merge(BoolTest other) const; 307 }; 308 309 //------------------------------BoolNode--------------------------------------- 310 // A Node to convert a Condition Codes to a Logical result. 311 class BoolNode : public Node { 312 virtual uint hash() const; 313 virtual bool cmp( const Node &n ) const; 314 virtual uint size_of() const; 315 316 // Try to optimize signed integer comparison 317 Node* fold_cmpI(PhaseGVN* phase, SubNode* cmp, Node* cmp1, int cmp_op, 318 int cmp1_op, const TypeInt* cmp2_type); 319 public: 320 const BoolTest _test; 321 BoolNode(Node *cc, BoolTest::mask t): Node(NULL,cc), _test(t) { 322 init_class_id(Class_Bool); 323 } 324 // Convert an arbitrary int value to a Bool or other suitable predicate. 325 static Node* make_predicate(Node* test_value, PhaseGVN* phase); 326 // Convert self back to an integer value. 327 Node* as_int_value(PhaseGVN* phase); 328 // Invert sense of self, returning new Bool. 329 BoolNode* negate(PhaseGVN* phase); 330 virtual int Opcode() const; 331 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 332 virtual const Type* Value(PhaseGVN* phase) const; 333 virtual const Type *bottom_type() const { return TypeInt::BOOL; } 334 uint match_edge(uint idx) const { return 0; } 335 virtual uint ideal_reg() const { return Op_RegI; } 336 337 bool is_counted_loop_exit_test(); 338 #ifndef PRODUCT 339 virtual void dump_spec(outputStream *st) const; 340 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 341 #endif 342 }; 343 344 //------------------------------AbsNode---------------------------------------- 345 // Abstract class for absolute value. Mostly used to get a handy wrapper 346 // for finding this pattern in the graph. 347 class AbsNode : public Node { 348 public: 349 AbsNode( Node *value ) : Node(0,value) {} 350 virtual Node* Identity(PhaseGVN* phase); 351 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); 352 virtual const Type* Value(PhaseGVN* phase) const; 353 }; 354 355 //------------------------------AbsINode--------------------------------------- 356 // Absolute value an integer. Since a naive graph involves control flow, we 357 // "match" it in the ideal world (so the control flow can be removed). 358 class AbsINode : public AbsNode { 359 public: 360 AbsINode( Node *in1 ) : AbsNode(in1) {} 361 virtual int Opcode() const; 362 const Type *bottom_type() const { return TypeInt::INT; } 363 virtual uint ideal_reg() const { return Op_RegI; } 364 }; 365 366 //------------------------------AbsLNode--------------------------------------- 367 // Absolute value a long. Since a naive graph involves control flow, we 368 // "match" it in the ideal world (so the control flow can be removed). 369 class AbsLNode : public AbsNode { 370 public: 371 AbsLNode( Node *in1 ) : AbsNode(in1) {} 372 virtual int Opcode() const; 373 const Type *bottom_type() const { return TypeLong::LONG; } 374 virtual uint ideal_reg() const { return Op_RegL; } 375 }; 376 377 //------------------------------AbsFNode--------------------------------------- 378 // Absolute value a float, a common float-point idiom with a cheap hardware 379 // implementation on most chips. Since a naive graph involves control flow, we 380 // "match" it in the ideal world (so the control flow can be removed). 381 class AbsFNode : public AbsNode { 382 public: 383 AbsFNode( Node *in1 ) : AbsNode(in1) {} 384 virtual int Opcode() const; 385 const Type *bottom_type() const { return Type::FLOAT; } 386 virtual uint ideal_reg() const { return Op_RegF; } 387 }; 388 389 //------------------------------AbsDNode--------------------------------------- 390 // Absolute value a double, a common float-point idiom with a cheap hardware 391 // implementation on most chips. Since a naive graph involves control flow, we 392 // "match" it in the ideal world (so the control flow can be removed). 393 class AbsDNode : public AbsNode { 394 public: 395 AbsDNode( Node *in1 ) : AbsNode(in1) {} 396 virtual int Opcode() const; 397 const Type *bottom_type() const { return Type::DOUBLE; } 398 virtual uint ideal_reg() const { return Op_RegD; } 399 }; 400 401 402 //------------------------------CmpLTMaskNode---------------------------------- 403 // If p < q, return -1 else return 0. Nice for flow-free idioms. 404 class CmpLTMaskNode : public Node { 405 public: 406 CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {} 407 virtual int Opcode() const; 408 const Type *bottom_type() const { return TypeInt::INT; } 409 virtual uint ideal_reg() const { return Op_RegI; } 410 }; 411 412 413 //------------------------------NegNode---------------------------------------- 414 class NegNode : public Node { 415 public: 416 NegNode( Node *in1 ) : Node(0,in1) {} 417 }; 418 419 //------------------------------NegINode--------------------------------------- 420 // Negate value an int. For int values, negation is the same as subtraction 421 // from zero 422 class NegINode : public NegNode { 423 public: 424 NegINode(Node *in1) : NegNode(in1) {} 425 virtual int Opcode() const; 426 const Type *bottom_type() const { return TypeInt::INT; } 427 virtual uint ideal_reg() const { return Op_RegI; } 428 }; 429 430 //------------------------------NegLNode--------------------------------------- 431 // Negate value an int. For int values, negation is the same as subtraction 432 // from zero 433 class NegLNode : public NegNode { 434 public: 435 NegLNode(Node *in1) : NegNode(in1) {} 436 virtual int Opcode() const; 437 const Type *bottom_type() const { return TypeLong::LONG; } 438 virtual uint ideal_reg() const { return Op_RegL; } 439 }; 440 441 //------------------------------NegFNode--------------------------------------- 442 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from 443 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction 444 // cannot be used to replace negation we have to implement negation as ideal 445 // node; note that negation and addition can replace subtraction. 446 class NegFNode : public NegNode { 447 public: 448 NegFNode( Node *in1 ) : NegNode(in1) {} 449 virtual int Opcode() const; 450 const Type *bottom_type() const { return Type::FLOAT; } 451 virtual uint ideal_reg() const { return Op_RegF; } 452 }; 453 454 //------------------------------NegDNode--------------------------------------- 455 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from 456 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction 457 // cannot be used to replace negation we have to implement negation as ideal 458 // node; note that negation and addition can replace subtraction. 459 class NegDNode : public NegNode { 460 public: 461 NegDNode( Node *in1 ) : NegNode(in1) {} 462 virtual int Opcode() const; 463 const Type *bottom_type() const { return Type::DOUBLE; } 464 virtual uint ideal_reg() const { return Op_RegD; } 465 }; 466 467 //------------------------------AtanDNode-------------------------------------- 468 // arcus tangens of a double 469 class AtanDNode : public Node { 470 public: 471 AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} 472 virtual int Opcode() const; 473 const Type *bottom_type() const { return Type::DOUBLE; } 474 virtual uint ideal_reg() const { return Op_RegD; } 475 }; 476 477 478 //------------------------------SqrtDNode-------------------------------------- 479 // square root a double 480 class SqrtDNode : public Node { 481 public: 482 SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 483 init_flags(Flag_is_expensive); 484 C->add_expensive_node(this); 485 } 486 virtual int Opcode() const; 487 const Type *bottom_type() const { return Type::DOUBLE; } 488 virtual uint ideal_reg() const { return Op_RegD; } 489 virtual const Type* Value(PhaseGVN* phase) const; 490 }; 491 492 //------------------------------SqrtFNode-------------------------------------- 493 // square root a float 494 class SqrtFNode : public Node { 495 public: 496 SqrtFNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 497 init_flags(Flag_is_expensive); 498 if (c != NULL) { 499 // Treat node only as expensive if a control input is set because it might 500 // be created from a SqrtDNode in ConvD2FNode::Ideal() that was found to 501 // be unique and therefore has no control input. 502 C->add_expensive_node(this); 503 } 504 } 505 virtual int Opcode() const; 506 const Type *bottom_type() const { return Type::FLOAT; } 507 virtual uint ideal_reg() const { return Op_RegF; } 508 virtual const Type* Value(PhaseGVN* phase) const; 509 }; 510 511 //-------------------------------ReverseBytesINode-------------------------------- 512 // reverse bytes of an integer 513 class ReverseBytesINode : public Node { 514 public: 515 ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} 516 virtual int Opcode() const; 517 const Type *bottom_type() const { return TypeInt::INT; } 518 virtual uint ideal_reg() const { return Op_RegI; } 519 }; 520 521 //-------------------------------ReverseBytesLNode-------------------------------- 522 // reverse bytes of a long 523 class ReverseBytesLNode : public Node { 524 public: 525 ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} 526 virtual int Opcode() const; 527 const Type *bottom_type() const { return TypeLong::LONG; } 528 virtual uint ideal_reg() const { return Op_RegL; } 529 }; 530 531 //-------------------------------ReverseBytesUSNode-------------------------------- 532 // reverse bytes of an unsigned short / char 533 class ReverseBytesUSNode : public Node { 534 public: 535 ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} 536 virtual int Opcode() const; 537 const Type *bottom_type() const { return TypeInt::CHAR; } 538 virtual uint ideal_reg() const { return Op_RegI; } 539 }; 540 541 //-------------------------------ReverseBytesSNode-------------------------------- 542 // reverse bytes of a short 543 class ReverseBytesSNode : public Node { 544 public: 545 ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} 546 virtual int Opcode() const; 547 const Type *bottom_type() const { return TypeInt::SHORT; } 548 virtual uint ideal_reg() const { return Op_RegI; } 549 }; 550 551 #endif // SHARE_OPTO_SUBNODE_HPP