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