1 /* 2 * Copyright (c) 2007, 2014, 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 #ifndef SHARE_VM_OPTO_VECTORNODE_HPP 25 #define SHARE_VM_OPTO_VECTORNODE_HPP 26 27 #include "opto/matcher.hpp" 28 #include "opto/memnode.hpp" 29 #include "opto/node.hpp" 30 #include "opto/opcodes.hpp" 31 32 //------------------------------VectorNode------------------------------------- 33 // Vector Operation 34 class VectorNode : public TypeNode { 35 public: 36 37 VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) { 38 init_class_id(Class_Vector); 39 init_req(1, n1); 40 } 41 VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) { 42 init_class_id(Class_Vector); 43 init_req(1, n1); 44 init_req(2, n2); 45 } 46 47 const TypeVect* vect_type() const { return type()->is_vect(); } 48 uint length() const { return vect_type()->length(); } // Vector length 49 uint length_in_bytes() const { return vect_type()->length_in_bytes(); } 50 51 virtual int Opcode() const; 52 53 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); } 54 55 static VectorNode* scalar2vector(Node* s, uint vlen, const Type* opd_t); 56 static VectorNode* shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt); 57 static VectorNode* make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt); 58 59 static int opcode(int opc, BasicType bt); 60 static bool implemented(int opc, uint vlen, BasicType bt); 61 static bool is_shift(Node* n); 62 static bool is_invariant_vector(Node* n); 63 // [Start, end) half-open range defining which operands are vectors 64 static void vector_operands(Node* n, uint* start, uint* end); 65 }; 66 67 //===========================Vector=ALU=Operations============================= 68 69 //------------------------------AddVBNode-------------------------------------- 70 // Vector add byte 71 class AddVBNode : public VectorNode { 72 public: 73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 74 virtual int Opcode() const; 75 }; 76 77 //------------------------------AddVSNode-------------------------------------- 78 // Vector add char/short 79 class AddVSNode : public VectorNode { 80 public: 81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 82 virtual int Opcode() const; 83 }; 84 85 //------------------------------AddVINode-------------------------------------- 86 // Vector add int 87 class AddVINode : public VectorNode { 88 public: 89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 90 virtual int Opcode() const; 91 }; 92 93 //------------------------------AddVLNode-------------------------------------- 94 // Vector add long 95 class AddVLNode : public VectorNode { 96 public: 97 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 98 virtual int Opcode() const; 99 }; 100 101 //------------------------------AddVFNode-------------------------------------- 102 // Vector add float 103 class AddVFNode : public VectorNode { 104 public: 105 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 106 virtual int Opcode() const; 107 }; 108 109 //------------------------------AddVDNode-------------------------------------- 110 // Vector add double 111 class AddVDNode : public VectorNode { 112 public: 113 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 114 virtual int Opcode() const; 115 }; 116 117 //------------------------------ReductionNode------------------------------------ 118 // Perform reduction of a vector 119 class ReductionNode : public Node { 120 public: 121 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {} 122 123 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt); 124 static int opcode(int opc, BasicType bt); 125 static bool implemented(int opc, uint vlen, BasicType bt); 126 }; 127 128 //------------------------------AddReductionVINode-------------------------------------- 129 // Vector add int as a reduction 130 class AddReductionVINode : public ReductionNode { 131 public: 132 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 133 virtual int Opcode() const; 134 virtual const Type* bottom_type() const { return TypeInt::INT; } 135 virtual uint ideal_reg() const { return Op_RegI; } 136 }; 137 138 //------------------------------AddReductionVLNode-------------------------------------- 139 // Vector add long as a reduction 140 class AddReductionVLNode : public ReductionNode { 141 public: 142 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 143 virtual int Opcode() const; 144 virtual const Type* bottom_type() const { return TypeLong::LONG; } 145 virtual uint ideal_reg() const { return Op_RegL; } 146 }; 147 148 //------------------------------AddReductionVFNode-------------------------------------- 149 // Vector add float as a reduction 150 class AddReductionVFNode : public ReductionNode { 151 public: 152 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 153 virtual int Opcode() const; 154 virtual const Type* bottom_type() const { return Type::FLOAT; } 155 virtual uint ideal_reg() const { return Op_RegF; } 156 }; 157 158 //------------------------------AddReductionVDNode-------------------------------------- 159 // Vector add double as a reduction 160 class AddReductionVDNode : public ReductionNode { 161 public: 162 AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 163 virtual int Opcode() const; 164 virtual const Type* bottom_type() const { return Type::DOUBLE; } 165 virtual uint ideal_reg() const { return Op_RegD; } 166 }; 167 168 //------------------------------SubVBNode-------------------------------------- 169 // Vector subtract byte 170 class SubVBNode : public VectorNode { 171 public: 172 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 173 virtual int Opcode() const; 174 }; 175 176 //------------------------------SubVSNode-------------------------------------- 177 // Vector subtract short 178 class SubVSNode : public VectorNode { 179 public: 180 SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 181 virtual int Opcode() const; 182 }; 183 184 //------------------------------SubVINode-------------------------------------- 185 // Vector subtract int 186 class SubVINode : public VectorNode { 187 public: 188 SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 189 virtual int Opcode() const; 190 }; 191 192 //------------------------------SubVLNode-------------------------------------- 193 // Vector subtract long 194 class SubVLNode : public VectorNode { 195 public: 196 SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 197 virtual int Opcode() const; 198 }; 199 200 //------------------------------SubVFNode-------------------------------------- 201 // Vector subtract float 202 class SubVFNode : public VectorNode { 203 public: 204 SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 205 virtual int Opcode() const; 206 }; 207 208 //------------------------------SubVDNode-------------------------------------- 209 // Vector subtract double 210 class SubVDNode : public VectorNode { 211 public: 212 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 213 virtual int Opcode() const; 214 }; 215 216 //------------------------------MulVSNode-------------------------------------- 217 // Vector multiply short 218 class MulVSNode : public VectorNode { 219 public: 220 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 221 virtual int Opcode() const; 222 }; 223 224 //------------------------------MulVINode-------------------------------------- 225 // Vector multiply int 226 class MulVINode : public VectorNode { 227 public: 228 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 229 virtual int Opcode() const; 230 }; 231 232 //------------------------------MulVLNode-------------------------------------- 233 // Vector multiply long 234 class MulVLNode : public VectorNode { 235 public: 236 MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 237 virtual int Opcode() const; 238 }; 239 240 //------------------------------MulVFNode-------------------------------------- 241 // Vector multiply float 242 class MulVFNode : public VectorNode { 243 public: 244 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 245 virtual int Opcode() const; 246 }; 247 248 //------------------------------MulVDNode-------------------------------------- 249 // Vector multiply double 250 class MulVDNode : public VectorNode { 251 public: 252 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} 253 virtual int Opcode() const; 254 }; 255 256 //------------------------------MulReductionVINode-------------------------------------- 257 // Vector multiply int as a reduction 258 class MulReductionVINode : public ReductionNode { 259 public: 260 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 261 virtual int Opcode() const; 262 virtual const Type* bottom_type() const { return TypeInt::INT; } 263 virtual uint ideal_reg() const { return Op_RegI; } 264 }; 265 266 //------------------------------MulReductionVLNode-------------------------------------- 267 // Vector multiply int as a reduction 268 class MulReductionVLNode : public ReductionNode { 269 public: 270 MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 271 virtual int Opcode() const; 272 virtual const Type* bottom_type() const { return TypeLong::LONG; } 273 virtual uint ideal_reg() const { return Op_RegI; } 274 }; 275 276 //------------------------------MulReductionVFNode-------------------------------------- 277 // Vector multiply float as a reduction 278 class MulReductionVFNode : public ReductionNode { 279 public: 280 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 281 virtual int Opcode() const; 282 virtual const Type* bottom_type() const { return Type::FLOAT; } 283 virtual uint ideal_reg() const { return Op_RegF; } 284 }; 285 286 //------------------------------MulReductionVDNode-------------------------------------- 287 // Vector multiply double as a reduction 288 class MulReductionVDNode : public ReductionNode { 289 public: 290 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} 291 virtual int Opcode() const; 292 virtual const Type* bottom_type() const { return Type::DOUBLE; } 293 virtual uint ideal_reg() const { return Op_RegD; } 294 }; 295 296 //------------------------------DivVFNode-------------------------------------- 297 // Vector divide float 298 class DivVFNode : public VectorNode { 299 public: 300 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 301 virtual int Opcode() const; 302 }; 303 304 //------------------------------DivVDNode-------------------------------------- 305 // Vector Divide double 306 class DivVDNode : public VectorNode { 307 public: 308 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 309 virtual int Opcode() const; 310 }; 311 312 //------------------------------AbsVFNode-------------------------------------- 313 // Vector Abs float 314 class AbsVFNode : public VectorNode { 315 public: 316 AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} 317 virtual int Opcode() const; 318 }; 319 320 //------------------------------AbsVDNode-------------------------------------- 321 // Vector Abs double 322 class AbsVDNode : public VectorNode { 323 public: 324 AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} 325 virtual int Opcode() const; 326 }; 327 328 //------------------------------NegVFNode-------------------------------------- 329 // Vector Neg float 330 class NegVFNode : public VectorNode { 331 public: 332 NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} 333 virtual int Opcode() const; 334 }; 335 336 //------------------------------NegVDNode-------------------------------------- 337 // Vector Neg double 338 class NegVDNode : public VectorNode { 339 public: 340 NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} 341 virtual int Opcode() const; 342 }; 343 344 //------------------------------SqrtVDNode-------------------------------------- 345 // Vector Sqrt double 346 class SqrtVDNode : public VectorNode { 347 public: 348 SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} 349 virtual int Opcode() const; 350 }; 351 352 //------------------------------LShiftVBNode----------------------------------- 353 // Vector left shift bytes 354 class LShiftVBNode : public VectorNode { 355 public: 356 LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 357 virtual int Opcode() const; 358 }; 359 360 //------------------------------LShiftVSNode----------------------------------- 361 // Vector left shift shorts 362 class LShiftVSNode : public VectorNode { 363 public: 364 LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 365 virtual int Opcode() const; 366 }; 367 368 //------------------------------LShiftVINode----------------------------------- 369 // Vector left shift ints 370 class LShiftVINode : public VectorNode { 371 public: 372 LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 373 virtual int Opcode() const; 374 }; 375 376 //------------------------------LShiftVLNode----------------------------------- 377 // Vector left shift longs 378 class LShiftVLNode : public VectorNode { 379 public: 380 LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 381 virtual int Opcode() const; 382 }; 383 384 //------------------------------RShiftVBNode----------------------------------- 385 // Vector right arithmetic (signed) shift bytes 386 class RShiftVBNode : public VectorNode { 387 public: 388 RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 389 virtual int Opcode() const; 390 }; 391 392 //------------------------------RShiftVSNode----------------------------------- 393 // Vector right arithmetic (signed) shift shorts 394 class RShiftVSNode : public VectorNode { 395 public: 396 RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 397 virtual int Opcode() const; 398 }; 399 400 //------------------------------RShiftVINode----------------------------------- 401 // Vector right arithmetic (signed) shift ints 402 class RShiftVINode : public VectorNode { 403 public: 404 RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 405 virtual int Opcode() const; 406 }; 407 408 //------------------------------RShiftVLNode----------------------------------- 409 // Vector right arithmetic (signed) shift longs 410 class RShiftVLNode : public VectorNode { 411 public: 412 RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 413 virtual int Opcode() const; 414 }; 415 416 //------------------------------URShiftVBNode---------------------------------- 417 // Vector right logical (unsigned) shift bytes 418 class URShiftVBNode : public VectorNode { 419 public: 420 URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 421 virtual int Opcode() const; 422 }; 423 424 //------------------------------URShiftVSNode---------------------------------- 425 // Vector right logical (unsigned) shift shorts 426 class URShiftVSNode : public VectorNode { 427 public: 428 URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 429 virtual int Opcode() const; 430 }; 431 432 //------------------------------URShiftVINode---------------------------------- 433 // Vector right logical (unsigned) shift ints 434 class URShiftVINode : public VectorNode { 435 public: 436 URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 437 virtual int Opcode() const; 438 }; 439 440 //------------------------------URShiftVLNode---------------------------------- 441 // Vector right logical (unsigned) shift longs 442 class URShiftVLNode : public VectorNode { 443 public: 444 URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 445 virtual int Opcode() const; 446 }; 447 448 //------------------------------LShiftCntVNode--------------------------------- 449 // Vector left shift count 450 class LShiftCntVNode : public VectorNode { 451 public: 452 LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {} 453 virtual int Opcode() const; 454 virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); } 455 }; 456 457 //------------------------------RShiftCntVNode--------------------------------- 458 // Vector right shift count 459 class RShiftCntVNode : public VectorNode { 460 public: 461 RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {} 462 virtual int Opcode() const; 463 virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); } 464 }; 465 466 467 //------------------------------AndVNode--------------------------------------- 468 // Vector and integer 469 class AndVNode : public VectorNode { 470 public: 471 AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 472 virtual int Opcode() const; 473 }; 474 475 //------------------------------OrVNode--------------------------------------- 476 // Vector or integer 477 class OrVNode : public VectorNode { 478 public: 479 OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 480 virtual int Opcode() const; 481 }; 482 483 //------------------------------XorVNode--------------------------------------- 484 // Vector xor integer 485 class XorVNode : public VectorNode { 486 public: 487 XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} 488 virtual int Opcode() const; 489 }; 490 491 //================================= M E M O R Y =============================== 492 493 //------------------------------LoadVectorNode--------------------------------- 494 // Load Vector from memory 495 class LoadVectorNode : public LoadNode { 496 public: 497 LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt, ControlDependency control_dependency = LoadNode::DependsOnlyOnTest) 498 : LoadNode(c, mem, adr, at, vt, MemNode::unordered, control_dependency) { 499 init_class_id(Class_LoadVector); 500 } 501 502 const TypeVect* vect_type() const { return type()->is_vect(); } 503 uint length() const { return vect_type()->length(); } // Vector length 504 505 virtual int Opcode() const; 506 507 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } 508 virtual BasicType memory_type() const { return T_VOID; } 509 virtual int memory_size() const { return vect_type()->length_in_bytes(); } 510 511 virtual int store_Opcode() const { return Op_StoreVector; } 512 513 static LoadVectorNode* make(int opc, Node* ctl, Node* mem, 514 Node* adr, const TypePtr* atyp, 515 uint vlen, BasicType bt, 516 ControlDependency control_dependency = LoadNode::DependsOnlyOnTest); 517 }; 518 519 //------------------------------StoreVectorNode-------------------------------- 520 // Store Vector to memory 521 class StoreVectorNode : public StoreNode { 522 public: 523 StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 524 : StoreNode(c, mem, adr, at, val, MemNode::unordered) { 525 assert(val->is_Vector() || val->is_LoadVector(), "sanity"); 526 init_class_id(Class_StoreVector); 527 } 528 529 const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); } 530 uint length() const { return vect_type()->length(); } // Vector length 531 532 virtual int Opcode() const; 533 534 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } 535 virtual BasicType memory_type() const { return T_VOID; } 536 virtual int memory_size() const { return vect_type()->length_in_bytes(); } 537 538 static StoreVectorNode* make(int opc, Node* ctl, Node* mem, 539 Node* adr, const TypePtr* atyp, Node* val, 540 uint vlen); 541 }; 542 543 544 //=========================Promote_Scalar_to_Vector============================ 545 546 //------------------------------ReplicateBNode--------------------------------- 547 // Replicate byte scalar to be vector 548 class ReplicateBNode : public VectorNode { 549 public: 550 ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 551 virtual int Opcode() const; 552 }; 553 554 //------------------------------ReplicateSNode--------------------------------- 555 // Replicate short scalar to be vector 556 class ReplicateSNode : public VectorNode { 557 public: 558 ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 559 virtual int Opcode() const; 560 }; 561 562 //------------------------------ReplicateINode--------------------------------- 563 // Replicate int scalar to be vector 564 class ReplicateINode : public VectorNode { 565 public: 566 ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 567 virtual int Opcode() const; 568 }; 569 570 //------------------------------ReplicateLNode--------------------------------- 571 // Replicate long scalar to be vector 572 class ReplicateLNode : public VectorNode { 573 public: 574 ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 575 virtual int Opcode() const; 576 }; 577 578 //------------------------------ReplicateFNode--------------------------------- 579 // Replicate float scalar to be vector 580 class ReplicateFNode : public VectorNode { 581 public: 582 ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 583 virtual int Opcode() const; 584 }; 585 586 //------------------------------ReplicateDNode--------------------------------- 587 // Replicate double scalar to be vector 588 class ReplicateDNode : public VectorNode { 589 public: 590 ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 591 virtual int Opcode() const; 592 }; 593 594 //========================Pack_Scalars_into_a_Vector=========================== 595 596 //------------------------------PackNode--------------------------------------- 597 // Pack parent class (not for code generation). 598 class PackNode : public VectorNode { 599 public: 600 PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} 601 PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {} 602 virtual int Opcode() const; 603 604 void add_opd(Node* n) { 605 add_req(n); 606 } 607 608 // Create a binary tree form for Packs. [lo, hi) (half-open) range 609 PackNode* binary_tree_pack(int lo, int hi); 610 611 static PackNode* make(Node* s, uint vlen, BasicType bt); 612 }; 613 614 //------------------------------PackBNode-------------------------------------- 615 // Pack byte scalars into vector 616 class PackBNode : public PackNode { 617 public: 618 PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 619 virtual int Opcode() const; 620 }; 621 622 //------------------------------PackSNode-------------------------------------- 623 // Pack short scalars into a vector 624 class PackSNode : public PackNode { 625 public: 626 PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 627 PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 628 virtual int Opcode() const; 629 }; 630 631 //------------------------------PackINode-------------------------------------- 632 // Pack integer scalars into a vector 633 class PackINode : public PackNode { 634 public: 635 PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 636 PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 637 virtual int Opcode() const; 638 }; 639 640 //------------------------------PackLNode-------------------------------------- 641 // Pack long scalars into a vector 642 class PackLNode : public PackNode { 643 public: 644 PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 645 PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 646 virtual int Opcode() const; 647 }; 648 649 //------------------------------Pack2LNode------------------------------------- 650 // Pack 2 long scalars into a vector 651 class Pack2LNode : public PackNode { 652 public: 653 Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 654 virtual int Opcode() const; 655 }; 656 657 //------------------------------PackFNode-------------------------------------- 658 // Pack float scalars into vector 659 class PackFNode : public PackNode { 660 public: 661 PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 662 PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 663 virtual int Opcode() const; 664 }; 665 666 //------------------------------PackDNode-------------------------------------- 667 // Pack double scalars into a vector 668 class PackDNode : public PackNode { 669 public: 670 PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} 671 PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 672 virtual int Opcode() const; 673 }; 674 675 //------------------------------Pack2DNode------------------------------------- 676 // Pack 2 double scalars into a vector 677 class Pack2DNode : public PackNode { 678 public: 679 Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} 680 virtual int Opcode() const; 681 }; 682 683 684 //========================Extract_Scalar_from_Vector=========================== 685 686 //------------------------------ExtractNode------------------------------------ 687 // Extract a scalar from a vector at position "pos" 688 class ExtractNode : public Node { 689 public: 690 ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) { 691 assert(in(2)->get_int() >= 0, "positive constants"); 692 } 693 virtual int Opcode() const; 694 uint pos() const { return in(2)->get_int(); } 695 696 static Node* make(Node* v, uint position, BasicType bt); 697 }; 698 699 //------------------------------ExtractBNode----------------------------------- 700 // Extract a byte from a vector at position "pos" 701 class ExtractBNode : public ExtractNode { 702 public: 703 ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 704 virtual int Opcode() const; 705 virtual const Type *bottom_type() const { return TypeInt::INT; } 706 virtual uint ideal_reg() const { return Op_RegI; } 707 }; 708 709 //------------------------------ExtractUBNode---------------------------------- 710 // Extract a boolean from a vector at position "pos" 711 class ExtractUBNode : public ExtractNode { 712 public: 713 ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 714 virtual int Opcode() const; 715 virtual const Type *bottom_type() const { return TypeInt::INT; } 716 virtual uint ideal_reg() const { return Op_RegI; } 717 }; 718 719 //------------------------------ExtractCNode----------------------------------- 720 // Extract a char from a vector at position "pos" 721 class ExtractCNode : public ExtractNode { 722 public: 723 ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 724 virtual int Opcode() const; 725 virtual const Type *bottom_type() const { return TypeInt::INT; } 726 virtual uint ideal_reg() const { return Op_RegI; } 727 }; 728 729 //------------------------------ExtractSNode----------------------------------- 730 // Extract a short from a vector at position "pos" 731 class ExtractSNode : public ExtractNode { 732 public: 733 ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 734 virtual int Opcode() const; 735 virtual const Type *bottom_type() const { return TypeInt::INT; } 736 virtual uint ideal_reg() const { return Op_RegI; } 737 }; 738 739 //------------------------------ExtractINode----------------------------------- 740 // Extract an int from a vector at position "pos" 741 class ExtractINode : public ExtractNode { 742 public: 743 ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 744 virtual int Opcode() const; 745 virtual const Type *bottom_type() const { return TypeInt::INT; } 746 virtual uint ideal_reg() const { return Op_RegI; } 747 }; 748 749 //------------------------------ExtractLNode----------------------------------- 750 // Extract a long from a vector at position "pos" 751 class ExtractLNode : public ExtractNode { 752 public: 753 ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 754 virtual int Opcode() const; 755 virtual const Type *bottom_type() const { return TypeLong::LONG; } 756 virtual uint ideal_reg() const { return Op_RegL; } 757 }; 758 759 //------------------------------ExtractFNode----------------------------------- 760 // Extract a float from a vector at position "pos" 761 class ExtractFNode : public ExtractNode { 762 public: 763 ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 764 virtual int Opcode() const; 765 virtual const Type *bottom_type() const { return Type::FLOAT; } 766 virtual uint ideal_reg() const { return Op_RegF; } 767 }; 768 769 //------------------------------ExtractDNode----------------------------------- 770 // Extract a double from a vector at position "pos" 771 class ExtractDNode : public ExtractNode { 772 public: 773 ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 774 virtual int Opcode() const; 775 virtual const Type *bottom_type() const { return Type::DOUBLE; } 776 virtual uint ideal_reg() const { return Op_RegD; } 777 }; 778 779 #endif // SHARE_VM_OPTO_VECTORNODE_HPP