1 /* 2 * Copyright (c) 2007, 2008, 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 //------------------------------VectorNode-------------------------------------- 25 // Vector Operation 26 class VectorNode : public Node { 27 protected: 28 uint _length; // vector length 29 virtual BasicType elt_basic_type() const = 0; // Vector element basic type 30 31 static const Type* vect_type(BasicType elt_bt, uint len); 32 static const Type* vect_type(const Type* elt_type, uint len) { 33 return vect_type(elt_type->array_element_basic_type(), len); 34 } 35 36 public: 37 friend class VectorLoadNode; // For vect_type 38 friend class VectorStoreNode; // ditto. 39 40 VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) { 41 init_flags(Flag_is_Vector); 42 } 43 VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) { 44 init_flags(Flag_is_Vector); 45 } 46 virtual int Opcode() const; 47 48 uint length() const { return _length; } // Vector length 49 50 static uint max_vlen(BasicType bt) { // max vector length 51 return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt)); 52 } 53 54 // Element and vector type 55 const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } 56 const Type* vect_type() const { return vect_type(elt_basic_type(), length()); } 57 58 virtual const Type *bottom_type() const { return vect_type(); } 59 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } 60 61 // Vector opcode from scalar opcode 62 static int opcode(int sopc, uint vlen, const Type* opd_t); 63 64 static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t); 65 66 static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t); 67 68 }; 69 70 //===========================Vector=ALU=Operations==================================== 71 72 //------------------------------AddVBNode--------------------------------------- 73 // Vector add byte 74 class AddVBNode : public VectorNode { 75 protected: 76 virtual BasicType elt_basic_type() const { return T_BYTE; } 77 public: 78 AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 79 virtual int Opcode() const; 80 }; 81 82 //------------------------------AddVCNode--------------------------------------- 83 // Vector add char 84 class AddVCNode : public VectorNode { 85 protected: 86 virtual BasicType elt_basic_type() const { return T_CHAR; } 87 public: 88 AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 89 virtual int Opcode() const; 90 }; 91 92 //------------------------------AddVSNode--------------------------------------- 93 // Vector add short 94 class AddVSNode : public VectorNode { 95 protected: 96 virtual BasicType elt_basic_type() const { return T_SHORT; } 97 public: 98 AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 99 virtual int Opcode() const; 100 }; 101 102 //------------------------------AddVINode--------------------------------------- 103 // Vector add int 104 class AddVINode : public VectorNode { 105 protected: 106 virtual BasicType elt_basic_type() const { return T_INT; } 107 public: 108 AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 109 virtual int Opcode() const; 110 }; 111 112 //------------------------------AddVLNode--------------------------------------- 113 // Vector add long 114 class AddVLNode : public VectorNode { 115 protected: 116 virtual BasicType elt_basic_type() const { return T_LONG; } 117 public: 118 AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 119 virtual int Opcode() const; 120 }; 121 122 //------------------------------AddVFNode--------------------------------------- 123 // Vector add float 124 class AddVFNode : public VectorNode { 125 protected: 126 virtual BasicType elt_basic_type() const { return T_FLOAT; } 127 public: 128 AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 129 virtual int Opcode() const; 130 }; 131 132 //------------------------------AddVDNode--------------------------------------- 133 // Vector add double 134 class AddVDNode : public VectorNode { 135 protected: 136 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 137 public: 138 AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 139 virtual int Opcode() const; 140 }; 141 142 //------------------------------SubVBNode--------------------------------------- 143 // Vector subtract byte 144 class SubVBNode : public VectorNode { 145 protected: 146 virtual BasicType elt_basic_type() const { return T_BYTE; } 147 public: 148 SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 149 virtual int Opcode() const; 150 }; 151 152 //------------------------------SubVCNode--------------------------------------- 153 // Vector subtract char 154 class SubVCNode : public VectorNode { 155 protected: 156 virtual BasicType elt_basic_type() const { return T_CHAR; } 157 public: 158 SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 159 virtual int Opcode() const; 160 }; 161 162 //------------------------------SubVSNode--------------------------------------- 163 // Vector subtract short 164 class SubVSNode : public VectorNode { 165 protected: 166 virtual BasicType elt_basic_type() const { return T_SHORT; } 167 public: 168 SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 169 virtual int Opcode() const; 170 }; 171 172 //------------------------------SubVINode--------------------------------------- 173 // Vector subtract int 174 class SubVINode : public VectorNode { 175 protected: 176 virtual BasicType elt_basic_type() const { return T_INT; } 177 public: 178 SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 179 virtual int Opcode() const; 180 }; 181 182 //------------------------------SubVLNode--------------------------------------- 183 // Vector subtract long 184 class SubVLNode : public VectorNode { 185 protected: 186 virtual BasicType elt_basic_type() const { return T_LONG; } 187 public: 188 SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 189 virtual int Opcode() const; 190 }; 191 192 //------------------------------SubVFNode--------------------------------------- 193 // Vector subtract float 194 class SubVFNode : public VectorNode { 195 protected: 196 virtual BasicType elt_basic_type() const { return T_FLOAT; } 197 public: 198 SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 199 virtual int Opcode() const; 200 }; 201 202 //------------------------------SubVDNode--------------------------------------- 203 // Vector subtract double 204 class SubVDNode : public VectorNode { 205 protected: 206 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 207 public: 208 SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 209 virtual int Opcode() const; 210 }; 211 212 //------------------------------MulVFNode--------------------------------------- 213 // Vector multiply float 214 class MulVFNode : public VectorNode { 215 protected: 216 virtual BasicType elt_basic_type() const { return T_FLOAT; } 217 public: 218 MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 219 virtual int Opcode() const; 220 }; 221 222 //------------------------------MulVDNode--------------------------------------- 223 // Vector multiply double 224 class MulVDNode : public VectorNode { 225 protected: 226 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 227 public: 228 MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 229 virtual int Opcode() const; 230 }; 231 232 //------------------------------DivVFNode--------------------------------------- 233 // Vector divide float 234 class DivVFNode : public VectorNode { 235 protected: 236 virtual BasicType elt_basic_type() const { return T_FLOAT; } 237 public: 238 DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 239 virtual int Opcode() const; 240 }; 241 242 //------------------------------DivVDNode--------------------------------------- 243 // Vector Divide double 244 class DivVDNode : public VectorNode { 245 protected: 246 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 247 public: 248 DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 249 virtual int Opcode() const; 250 }; 251 252 //------------------------------LShiftVBNode--------------------------------------- 253 // Vector lshift byte 254 class LShiftVBNode : public VectorNode { 255 protected: 256 virtual BasicType elt_basic_type() const { return T_BYTE; } 257 public: 258 LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 259 virtual int Opcode() const; 260 }; 261 262 //------------------------------LShiftVCNode--------------------------------------- 263 // Vector lshift chars 264 class LShiftVCNode : public VectorNode { 265 protected: 266 virtual BasicType elt_basic_type() const { return T_CHAR; } 267 public: 268 LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 269 virtual int Opcode() const; 270 }; 271 272 //------------------------------LShiftVSNode--------------------------------------- 273 // Vector lshift shorts 274 class LShiftVSNode : public VectorNode { 275 protected: 276 virtual BasicType elt_basic_type() const { return T_SHORT; } 277 public: 278 LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 279 virtual int Opcode() const; 280 }; 281 282 //------------------------------LShiftVINode--------------------------------------- 283 // Vector lshift ints 284 class LShiftVINode : public VectorNode { 285 protected: 286 virtual BasicType elt_basic_type() const { return T_INT; } 287 public: 288 LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 289 virtual int Opcode() const; 290 }; 291 292 //------------------------------URShiftVBNode--------------------------------------- 293 // Vector urshift bytes 294 class URShiftVBNode : public VectorNode { 295 protected: 296 virtual BasicType elt_basic_type() const { return T_BYTE; } 297 public: 298 URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 299 virtual int Opcode() const; 300 }; 301 302 //------------------------------URShiftVCNode--------------------------------------- 303 // Vector urshift char 304 class URShiftVCNode : public VectorNode { 305 protected: 306 virtual BasicType elt_basic_type() const { return T_SHORT; } 307 public: 308 URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 309 virtual int Opcode() const; 310 }; 311 312 //------------------------------URShiftVSNode--------------------------------------- 313 // Vector urshift shorts 314 class URShiftVSNode : public VectorNode { 315 protected: 316 virtual BasicType elt_basic_type() const { return T_SHORT; } 317 public: 318 URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 319 virtual int Opcode() const; 320 }; 321 322 //------------------------------URShiftVINode--------------------------------------- 323 // Vector urshift ints 324 class URShiftVINode : public VectorNode { 325 protected: 326 virtual BasicType elt_basic_type() const { return T_INT; } 327 public: 328 URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {} 329 virtual int Opcode() const; 330 }; 331 332 //------------------------------AndVNode--------------------------------------- 333 // Vector and 334 class AndVNode : public VectorNode { 335 protected: 336 BasicType _bt; 337 virtual BasicType elt_basic_type() const { return _bt; } 338 public: 339 AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} 340 virtual int Opcode() const; 341 }; 342 343 //------------------------------OrVNode--------------------------------------- 344 // Vector or 345 class OrVNode : public VectorNode { 346 protected: 347 BasicType _bt; 348 virtual BasicType elt_basic_type() const { return _bt; } 349 public: 350 OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} 351 virtual int Opcode() const; 352 }; 353 354 //------------------------------XorVNode--------------------------------------- 355 // Vector xor 356 class XorVNode : public VectorNode { 357 protected: 358 BasicType _bt; 359 virtual BasicType elt_basic_type() const { return _bt; } 360 public: 361 XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {} 362 virtual int Opcode() const; 363 }; 364 365 //================================= M E M O R Y ================================== 366 367 368 //------------------------------VectorLoadNode-------------------------------------- 369 // Vector Load from memory 370 class VectorLoadNode : public LoadNode { 371 virtual uint size_of() const { return sizeof(*this); } 372 373 protected: 374 virtual BasicType elt_basic_type() const = 0; // Vector element basic type 375 // For use in constructor 376 static const Type* vect_type(const Type* elt_type, uint len) { 377 return VectorNode::vect_type(elt_type, len); 378 } 379 380 public: 381 VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt) 382 : LoadNode(c,mem,adr,at,rt) { 383 init_flags(Flag_is_Vector); 384 } 385 virtual int Opcode() const; 386 387 virtual uint length() const = 0; // Vector length 388 389 // Element and vector type 390 const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } 391 const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); } 392 393 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } 394 virtual BasicType memory_type() const { return T_VOID; } 395 virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } 396 397 // Vector opcode from scalar opcode 398 static int opcode(int sopc, uint vlen); 399 400 static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem, 401 Node* adr, const TypePtr* atyp, uint vlen); 402 }; 403 404 //------------------------------Load16BNode-------------------------------------- 405 // Vector load of 16 bytes (8bits signed) from memory 406 class Load16BNode : public VectorLoadNode { 407 protected: 408 virtual BasicType elt_basic_type() const { return T_BYTE; } 409 public: 410 Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) 411 : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {} 412 virtual int Opcode() const; 413 virtual int store_Opcode() const { return Op_Store16B; } 414 virtual uint length() const { return 16; } 415 }; 416 417 //------------------------------Load8BNode-------------------------------------- 418 // Vector load of 8 bytes (8bits signed) from memory 419 class Load8BNode : public VectorLoadNode { 420 protected: 421 virtual BasicType elt_basic_type() const { return T_BYTE; } 422 public: 423 Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) 424 : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} 425 virtual int Opcode() const; 426 virtual int store_Opcode() const { return Op_Store8B; } 427 virtual uint length() const { return 8; } 428 }; 429 430 //------------------------------Load4BNode-------------------------------------- 431 // Vector load of 4 bytes (8bits signed) from memory 432 class Load4BNode : public VectorLoadNode { 433 protected: 434 virtual BasicType elt_basic_type() const { return T_BYTE; } 435 public: 436 Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE) 437 : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} 438 virtual int Opcode() const; 439 virtual int store_Opcode() const { return Op_Store4B; } 440 virtual uint length() const { return 4; } 441 }; 442 443 //------------------------------Load8CNode-------------------------------------- 444 // Vector load of 8 chars (16bits unsigned) from memory 445 class Load8CNode : public VectorLoadNode { 446 protected: 447 virtual BasicType elt_basic_type() const { return T_CHAR; } 448 public: 449 Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) 450 : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} 451 virtual int Opcode() const; 452 virtual int store_Opcode() const { return Op_Store8C; } 453 virtual uint length() const { return 8; } 454 }; 455 456 //------------------------------Load4CNode-------------------------------------- 457 // Vector load of 4 chars (16bits unsigned) from memory 458 class Load4CNode : public VectorLoadNode { 459 protected: 460 virtual BasicType elt_basic_type() const { return T_CHAR; } 461 public: 462 Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) 463 : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} 464 virtual int Opcode() const; 465 virtual int store_Opcode() const { return Op_Store4C; } 466 virtual uint length() const { return 4; } 467 }; 468 469 //------------------------------Load2CNode-------------------------------------- 470 // Vector load of 2 chars (16bits unsigned) from memory 471 class Load2CNode : public VectorLoadNode { 472 protected: 473 virtual BasicType elt_basic_type() const { return T_CHAR; } 474 public: 475 Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR) 476 : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} 477 virtual int Opcode() const; 478 virtual int store_Opcode() const { return Op_Store2C; } 479 virtual uint length() const { return 2; } 480 }; 481 482 //------------------------------Load8SNode-------------------------------------- 483 // Vector load of 8 shorts (16bits signed) from memory 484 class Load8SNode : public VectorLoadNode { 485 protected: 486 virtual BasicType elt_basic_type() const { return T_SHORT; } 487 public: 488 Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) 489 : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {} 490 virtual int Opcode() const; 491 virtual int store_Opcode() const { return Op_Store8C; } 492 virtual uint length() const { return 8; } 493 }; 494 495 //------------------------------Load4SNode-------------------------------------- 496 // Vector load of 4 shorts (16bits signed) from memory 497 class Load4SNode : public VectorLoadNode { 498 protected: 499 virtual BasicType elt_basic_type() const { return T_SHORT; } 500 public: 501 Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) 502 : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} 503 virtual int Opcode() const; 504 virtual int store_Opcode() const { return Op_Store4C; } 505 virtual uint length() const { return 4; } 506 }; 507 508 //------------------------------Load2SNode-------------------------------------- 509 // Vector load of 2 shorts (16bits signed) from memory 510 class Load2SNode : public VectorLoadNode { 511 protected: 512 virtual BasicType elt_basic_type() const { return T_SHORT; } 513 public: 514 Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT) 515 : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} 516 virtual int Opcode() const; 517 virtual int store_Opcode() const { return Op_Store2C; } 518 virtual uint length() const { return 2; } 519 }; 520 521 //------------------------------Load4INode-------------------------------------- 522 // Vector load of 4 integers (32bits signed) from memory 523 class Load4INode : public VectorLoadNode { 524 protected: 525 virtual BasicType elt_basic_type() const { return T_INT; } 526 public: 527 Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT) 528 : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {} 529 virtual int Opcode() const; 530 virtual int store_Opcode() const { return Op_Store4I; } 531 virtual uint length() const { return 4; } 532 }; 533 534 //------------------------------Load2INode-------------------------------------- 535 // Vector load of 2 integers (32bits signed) from memory 536 class Load2INode : public VectorLoadNode { 537 protected: 538 virtual BasicType elt_basic_type() const { return T_INT; } 539 public: 540 Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT) 541 : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {} 542 virtual int Opcode() const; 543 virtual int store_Opcode() const { return Op_Store2I; } 544 virtual uint length() const { return 2; } 545 }; 546 547 //------------------------------Load2LNode-------------------------------------- 548 // Vector load of 2 longs (64bits signed) from memory 549 class Load2LNode : public VectorLoadNode { 550 protected: 551 virtual BasicType elt_basic_type() const { return T_LONG; } 552 public: 553 Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG) 554 : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {} 555 virtual int Opcode() const; 556 virtual int store_Opcode() const { return Op_Store2L; } 557 virtual uint length() const { return 2; } 558 }; 559 560 //------------------------------Load4FNode-------------------------------------- 561 // Vector load of 4 floats (32bits) from memory 562 class Load4FNode : public VectorLoadNode { 563 protected: 564 virtual BasicType elt_basic_type() const { return T_FLOAT; } 565 public: 566 Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT) 567 : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {} 568 virtual int Opcode() const; 569 virtual int store_Opcode() const { return Op_Store4F; } 570 virtual uint length() const { return 4; } 571 }; 572 573 //------------------------------Load2FNode-------------------------------------- 574 // Vector load of 2 floats (32bits) from memory 575 class Load2FNode : public VectorLoadNode { 576 protected: 577 virtual BasicType elt_basic_type() const { return T_FLOAT; } 578 public: 579 Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT) 580 : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {} 581 virtual int Opcode() const; 582 virtual int store_Opcode() const { return Op_Store2F; } 583 virtual uint length() const { return 2; } 584 }; 585 586 //------------------------------Load2DNode-------------------------------------- 587 // Vector load of 2 doubles (64bits) from memory 588 class Load2DNode : public VectorLoadNode { 589 protected: 590 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 591 public: 592 Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE) 593 : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {} 594 virtual int Opcode() const; 595 virtual int store_Opcode() const { return Op_Store2D; } 596 virtual uint length() const { return 2; } 597 }; 598 599 600 //------------------------------VectorStoreNode-------------------------------------- 601 // Vector Store to memory 602 class VectorStoreNode : public StoreNode { 603 virtual uint size_of() const { return sizeof(*this); } 604 605 protected: 606 virtual BasicType elt_basic_type() const = 0; // Vector element basic type 607 608 public: 609 VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 610 : StoreNode(c,mem,adr,at,val) { 611 init_flags(Flag_is_Vector); 612 } 613 virtual int Opcode() const; 614 615 virtual uint length() const = 0; // Vector length 616 617 // Element and vector type 618 const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); } 619 const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); } 620 621 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); } 622 virtual BasicType memory_type() const { return T_VOID; } 623 virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } 624 625 // Vector opcode from scalar opcode 626 static int opcode(int sopc, uint vlen); 627 628 static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem, 629 Node* adr, const TypePtr* atyp, VectorNode* val, 630 uint vlen); 631 }; 632 633 //------------------------------Store16BNode-------------------------------------- 634 // Vector store of 16 bytes (8bits signed) to memory 635 class Store16BNode : public VectorStoreNode { 636 protected: 637 virtual BasicType elt_basic_type() const { return T_BYTE; } 638 public: 639 Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 640 : VectorStoreNode(c,mem,adr,at,val) {} 641 virtual int Opcode() const; 642 virtual uint length() const { return 16; } 643 }; 644 645 //------------------------------Store8BNode-------------------------------------- 646 // Vector store of 8 bytes (8bits signed) to memory 647 class Store8BNode : public VectorStoreNode { 648 protected: 649 virtual BasicType elt_basic_type() const { return T_BYTE; } 650 public: 651 Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 652 : VectorStoreNode(c,mem,adr,at,val) {} 653 virtual int Opcode() const; 654 virtual uint length() const { return 8; } 655 }; 656 657 //------------------------------Store4BNode-------------------------------------- 658 // Vector store of 4 bytes (8bits signed) to memory 659 class Store4BNode : public VectorStoreNode { 660 protected: 661 virtual BasicType elt_basic_type() const { return T_BYTE; } 662 public: 663 Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 664 : VectorStoreNode(c,mem,adr,at,val) {} 665 virtual int Opcode() const; 666 virtual uint length() const { return 4; } 667 }; 668 669 //------------------------------Store8CNode-------------------------------------- 670 // Vector store of 8 chars (16bits signed/unsigned) to memory 671 class Store8CNode : public VectorStoreNode { 672 protected: 673 virtual BasicType elt_basic_type() const { return T_CHAR; } 674 public: 675 Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 676 : VectorStoreNode(c,mem,adr,at,val) {} 677 virtual int Opcode() const; 678 virtual uint length() const { return 8; } 679 }; 680 681 //------------------------------Store4CNode-------------------------------------- 682 // Vector store of 4 chars (16bits signed/unsigned) to memory 683 class Store4CNode : public VectorStoreNode { 684 protected: 685 virtual BasicType elt_basic_type() const { return T_CHAR; } 686 public: 687 Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 688 : VectorStoreNode(c,mem,adr,at,val) {} 689 virtual int Opcode() const; 690 virtual uint length() const { return 4; } 691 }; 692 693 //------------------------------Store2CNode-------------------------------------- 694 // Vector store of 2 chars (16bits signed/unsigned) to memory 695 class Store2CNode : public VectorStoreNode { 696 protected: 697 virtual BasicType elt_basic_type() const { return T_CHAR; } 698 public: 699 Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 700 : VectorStoreNode(c,mem,adr,at,val) {} 701 virtual int Opcode() const; 702 virtual uint length() const { return 2; } 703 }; 704 705 //------------------------------Store4INode-------------------------------------- 706 // Vector store of 4 integers (32bits signed) to memory 707 class Store4INode : public VectorStoreNode { 708 protected: 709 virtual BasicType elt_basic_type() const { return T_INT; } 710 public: 711 Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 712 : VectorStoreNode(c,mem,adr,at,val) {} 713 virtual int Opcode() const; 714 virtual uint length() const { return 4; } 715 }; 716 717 //------------------------------Store2INode-------------------------------------- 718 // Vector store of 2 integers (32bits signed) to memory 719 class Store2INode : public VectorStoreNode { 720 protected: 721 virtual BasicType elt_basic_type() const { return T_INT; } 722 public: 723 Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 724 : VectorStoreNode(c,mem,adr,at,val) {} 725 virtual int Opcode() const; 726 virtual uint length() const { return 2; } 727 }; 728 729 //------------------------------Store2LNode-------------------------------------- 730 // Vector store of 2 longs (64bits signed) to memory 731 class Store2LNode : public VectorStoreNode { 732 protected: 733 virtual BasicType elt_basic_type() const { return T_LONG; } 734 public: 735 Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 736 : VectorStoreNode(c,mem,adr,at,val) {} 737 virtual int Opcode() const; 738 virtual uint length() const { return 2; } 739 }; 740 741 //------------------------------Store4FNode-------------------------------------- 742 // Vector store of 4 floats (32bits) to memory 743 class Store4FNode : public VectorStoreNode { 744 protected: 745 virtual BasicType elt_basic_type() const { return T_FLOAT; } 746 public: 747 Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 748 : VectorStoreNode(c,mem,adr,at,val) {} 749 virtual int Opcode() const; 750 virtual uint length() const { return 4; } 751 }; 752 753 //------------------------------Store2FNode-------------------------------------- 754 // Vector store of 2 floats (32bits) to memory 755 class Store2FNode : public VectorStoreNode { 756 protected: 757 virtual BasicType elt_basic_type() const { return T_FLOAT; } 758 public: 759 Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 760 : VectorStoreNode(c,mem,adr,at,val) {} 761 virtual int Opcode() const; 762 virtual uint length() const { return 2; } 763 }; 764 765 //------------------------------Store2DNode-------------------------------------- 766 // Vector store of 2 doubles (64bits) to memory 767 class Store2DNode : public VectorStoreNode { 768 protected: 769 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 770 public: 771 Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val) 772 : VectorStoreNode(c,mem,adr,at,val) {} 773 virtual int Opcode() const; 774 virtual uint length() const { return 2; } 775 }; 776 777 //=========================Promote_Scalar_to_Vector==================================== 778 779 //------------------------------Replicate16BNode--------------------------------------- 780 // Replicate byte scalar to be vector of 16 bytes 781 class Replicate16BNode : public VectorNode { 782 protected: 783 virtual BasicType elt_basic_type() const { return T_BYTE; } 784 public: 785 Replicate16BNode(Node* in1) : VectorNode(in1, 16) {} 786 virtual int Opcode() const; 787 }; 788 789 //------------------------------Replicate8BNode--------------------------------------- 790 // Replicate byte scalar to be vector of 8 bytes 791 class Replicate8BNode : public VectorNode { 792 protected: 793 virtual BasicType elt_basic_type() const { return T_BYTE; } 794 public: 795 Replicate8BNode(Node* in1) : VectorNode(in1, 8) {} 796 virtual int Opcode() const; 797 }; 798 799 //------------------------------Replicate4BNode--------------------------------------- 800 // Replicate byte scalar to be vector of 4 bytes 801 class Replicate4BNode : public VectorNode { 802 protected: 803 virtual BasicType elt_basic_type() const { return T_BYTE; } 804 public: 805 Replicate4BNode(Node* in1) : VectorNode(in1, 4) {} 806 virtual int Opcode() const; 807 }; 808 809 //------------------------------Replicate8CNode--------------------------------------- 810 // Replicate char scalar to be vector of 8 chars 811 class Replicate8CNode : public VectorNode { 812 protected: 813 virtual BasicType elt_basic_type() const { return T_CHAR; } 814 public: 815 Replicate8CNode(Node* in1) : VectorNode(in1, 8) {} 816 virtual int Opcode() const; 817 }; 818 819 //------------------------------Replicate4CNode--------------------------------------- 820 // Replicate char scalar to be vector of 4 chars 821 class Replicate4CNode : public VectorNode { 822 protected: 823 virtual BasicType elt_basic_type() const { return T_CHAR; } 824 public: 825 Replicate4CNode(Node* in1) : VectorNode(in1, 4) {} 826 virtual int Opcode() const; 827 }; 828 829 //------------------------------Replicate2CNode--------------------------------------- 830 // Replicate char scalar to be vector of 2 chars 831 class Replicate2CNode : public VectorNode { 832 protected: 833 virtual BasicType elt_basic_type() const { return T_CHAR; } 834 public: 835 Replicate2CNode(Node* in1) : VectorNode(in1, 2) {} 836 virtual int Opcode() const; 837 }; 838 839 //------------------------------Replicate8SNode--------------------------------------- 840 // Replicate short scalar to be vector of 8 shorts 841 class Replicate8SNode : public VectorNode { 842 protected: 843 virtual BasicType elt_basic_type() const { return T_SHORT; } 844 public: 845 Replicate8SNode(Node* in1) : VectorNode(in1, 8) {} 846 virtual int Opcode() const; 847 }; 848 849 //------------------------------Replicate4SNode--------------------------------------- 850 // Replicate short scalar to be vector of 4 shorts 851 class Replicate4SNode : public VectorNode { 852 protected: 853 virtual BasicType elt_basic_type() const { return T_SHORT; } 854 public: 855 Replicate4SNode(Node* in1) : VectorNode(in1, 4) {} 856 virtual int Opcode() const; 857 }; 858 859 //------------------------------Replicate2SNode--------------------------------------- 860 // Replicate short scalar to be vector of 2 shorts 861 class Replicate2SNode : public VectorNode { 862 protected: 863 virtual BasicType elt_basic_type() const { return T_SHORT; } 864 public: 865 Replicate2SNode(Node* in1) : VectorNode(in1, 2) {} 866 virtual int Opcode() const; 867 }; 868 869 //------------------------------Replicate4INode--------------------------------------- 870 // Replicate int scalar to be vector of 4 ints 871 class Replicate4INode : public VectorNode { 872 protected: 873 virtual BasicType elt_basic_type() const { return T_INT; } 874 public: 875 Replicate4INode(Node* in1) : VectorNode(in1, 4) {} 876 virtual int Opcode() const; 877 }; 878 879 //------------------------------Replicate2INode--------------------------------------- 880 // Replicate int scalar to be vector of 2 ints 881 class Replicate2INode : public VectorNode { 882 protected: 883 virtual BasicType elt_basic_type() const { return T_INT; } 884 public: 885 Replicate2INode(Node* in1) : VectorNode(in1, 2) {} 886 virtual int Opcode() const; 887 }; 888 889 //------------------------------Replicate2LNode--------------------------------------- 890 // Replicate long scalar to be vector of 2 longs 891 class Replicate2LNode : public VectorNode { 892 protected: 893 virtual BasicType elt_basic_type() const { return T_LONG; } 894 public: 895 Replicate2LNode(Node* in1) : VectorNode(in1, 2) {} 896 virtual int Opcode() const; 897 }; 898 899 //------------------------------Replicate4FNode--------------------------------------- 900 // Replicate float scalar to be vector of 4 floats 901 class Replicate4FNode : public VectorNode { 902 protected: 903 virtual BasicType elt_basic_type() const { return T_FLOAT; } 904 public: 905 Replicate4FNode(Node* in1) : VectorNode(in1, 4) {} 906 virtual int Opcode() const; 907 }; 908 909 //------------------------------Replicate2FNode--------------------------------------- 910 // Replicate float scalar to be vector of 2 floats 911 class Replicate2FNode : public VectorNode { 912 protected: 913 virtual BasicType elt_basic_type() const { return T_FLOAT; } 914 public: 915 Replicate2FNode(Node* in1) : VectorNode(in1, 2) {} 916 virtual int Opcode() const; 917 }; 918 919 //------------------------------Replicate2DNode--------------------------------------- 920 // Replicate double scalar to be vector of 2 doubles 921 class Replicate2DNode : public VectorNode { 922 protected: 923 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 924 public: 925 Replicate2DNode(Node* in1) : VectorNode(in1, 2) {} 926 virtual int Opcode() const; 927 }; 928 929 //========================Pack_Scalars_into_a_Vector============================== 930 931 //------------------------------PackNode--------------------------------------- 932 // Pack parent class (not for code generation). 933 class PackNode : public VectorNode { 934 public: 935 PackNode(Node* in1) : VectorNode(in1, 1) {} 936 PackNode(Node* in1, Node* n2) : VectorNode(in1, n2, 2) {} 937 virtual int Opcode() const; 938 939 void add_opd(Node* n) { 940 add_req(n); 941 _length++; 942 assert(_length == req() - 1, "vector length matches edge count"); 943 } 944 945 // Create a binary tree form for Packs. [lo, hi) (half-open) range 946 Node* binaryTreePack(Compile* C, int lo, int hi); 947 948 static PackNode* make(Compile* C, Node* s, const Type* elt_t); 949 }; 950 951 //------------------------------PackBNode--------------------------------------- 952 // Pack byte scalars into vector 953 class PackBNode : public PackNode { 954 protected: 955 virtual BasicType elt_basic_type() const { return T_BYTE; } 956 public: 957 PackBNode(Node* in1) : PackNode(in1) {} 958 virtual int Opcode() const; 959 }; 960 961 //------------------------------PackCNode--------------------------------------- 962 // Pack char scalars into vector 963 class PackCNode : public PackNode { 964 protected: 965 virtual BasicType elt_basic_type() const { return T_CHAR; } 966 public: 967 PackCNode(Node* in1) : PackNode(in1) {} 968 virtual int Opcode() const; 969 }; 970 971 //------------------------------PackSNode--------------------------------------- 972 // Pack short scalars into a vector 973 class PackSNode : public PackNode { 974 protected: 975 virtual BasicType elt_basic_type() const { return T_SHORT; } 976 public: 977 PackSNode(Node* in1) : PackNode(in1) {} 978 virtual int Opcode() const; 979 }; 980 981 //------------------------------PackINode--------------------------------------- 982 // Pack integer scalars into a vector 983 class PackINode : public PackNode { 984 protected: 985 virtual BasicType elt_basic_type() const { return T_INT; } 986 public: 987 PackINode(Node* in1) : PackNode(in1) {} 988 PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {} 989 virtual int Opcode() const; 990 }; 991 992 //------------------------------PackLNode--------------------------------------- 993 // Pack long scalars into a vector 994 class PackLNode : public PackNode { 995 protected: 996 virtual BasicType elt_basic_type() const { return T_LONG; } 997 public: 998 PackLNode(Node* in1) : PackNode(in1) {} 999 PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {} 1000 virtual int Opcode() const; 1001 }; 1002 1003 //------------------------------PackFNode--------------------------------------- 1004 // Pack float scalars into vector 1005 class PackFNode : public PackNode { 1006 protected: 1007 virtual BasicType elt_basic_type() const { return T_FLOAT; } 1008 public: 1009 PackFNode(Node* in1) : PackNode(in1) {} 1010 PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {} 1011 virtual int Opcode() const; 1012 }; 1013 1014 //------------------------------PackDNode--------------------------------------- 1015 // Pack double scalars into a vector 1016 class PackDNode : public PackNode { 1017 protected: 1018 virtual BasicType elt_basic_type() const { return T_DOUBLE; } 1019 public: 1020 PackDNode(Node* in1) : PackNode(in1) {} 1021 PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {} 1022 virtual int Opcode() const; 1023 }; 1024 1025 // The Pack2xN nodes assist code generation. They are created from 1026 // Pack4C, etc. nodes in final_graph_reshape in the form of a 1027 // balanced, binary tree. 1028 1029 //------------------------------Pack2x1BNode----------------------------------------- 1030 // Pack 2 1-byte integers into vector of 2 bytes 1031 class Pack2x1BNode : public PackNode { 1032 protected: 1033 virtual BasicType elt_basic_type() const { return T_BYTE; } 1034 public: 1035 Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {} 1036 virtual int Opcode() const; 1037 virtual uint ideal_reg() const { return Op_RegI; } 1038 }; 1039 1040 //------------------------------Pack2x2BNode--------------------------------------- 1041 // Pack 2 2-byte integers into vector of 4 bytes 1042 class Pack2x2BNode : public PackNode { 1043 protected: 1044 virtual BasicType elt_basic_type() const { return T_CHAR; } 1045 public: 1046 Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {} 1047 virtual int Opcode() const; 1048 virtual uint ideal_reg() const { return Op_RegI; } 1049 }; 1050 1051 //========================Extract_Scalar_from_Vector=============================== 1052 1053 //------------------------------ExtractNode--------------------------------------- 1054 // Extract a scalar from a vector at position "pos" 1055 class ExtractNode : public Node { 1056 public: 1057 ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) { 1058 assert(in(2)->get_int() >= 0, "positive constants"); 1059 } 1060 virtual int Opcode() const; 1061 uint pos() const { return in(2)->get_int(); } 1062 1063 static Node* make(Compile* C, Node* v, uint position, const Type* opd_t); 1064 }; 1065 1066 //------------------------------ExtractBNode--------------------------------------- 1067 // Extract a byte from a vector at position "pos" 1068 class ExtractBNode : public ExtractNode { 1069 public: 1070 ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1071 virtual int Opcode() const; 1072 virtual const Type *bottom_type() const { return TypeInt::INT; } 1073 virtual uint ideal_reg() const { return Op_RegI; } 1074 }; 1075 1076 //------------------------------ExtractCNode--------------------------------------- 1077 // Extract a char from a vector at position "pos" 1078 class ExtractCNode : public ExtractNode { 1079 public: 1080 ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1081 virtual int Opcode() const; 1082 virtual const Type *bottom_type() const { return TypeInt::INT; } 1083 virtual uint ideal_reg() const { return Op_RegI; } 1084 }; 1085 1086 //------------------------------ExtractSNode--------------------------------------- 1087 // Extract a short from a vector at position "pos" 1088 class ExtractSNode : public ExtractNode { 1089 public: 1090 ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1091 virtual int Opcode() const; 1092 virtual const Type *bottom_type() const { return TypeInt::INT; } 1093 virtual uint ideal_reg() const { return Op_RegI; } 1094 }; 1095 1096 //------------------------------ExtractINode--------------------------------------- 1097 // Extract an int from a vector at position "pos" 1098 class ExtractINode : public ExtractNode { 1099 public: 1100 ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1101 virtual int Opcode() const; 1102 virtual const Type *bottom_type() const { return TypeInt::INT; } 1103 virtual uint ideal_reg() const { return Op_RegI; } 1104 }; 1105 1106 //------------------------------ExtractLNode--------------------------------------- 1107 // Extract a long from a vector at position "pos" 1108 class ExtractLNode : public ExtractNode { 1109 public: 1110 ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1111 virtual int Opcode() const; 1112 virtual const Type *bottom_type() const { return TypeLong::LONG; } 1113 virtual uint ideal_reg() const { return Op_RegL; } 1114 }; 1115 1116 //------------------------------ExtractFNode--------------------------------------- 1117 // Extract a float from a vector at position "pos" 1118 class ExtractFNode : public ExtractNode { 1119 public: 1120 ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1121 virtual int Opcode() const; 1122 virtual const Type *bottom_type() const { return Type::FLOAT; } 1123 virtual uint ideal_reg() const { return Op_RegF; } 1124 }; 1125 1126 //------------------------------ExtractDNode--------------------------------------- 1127 // Extract a double from a vector at position "pos" 1128 class ExtractDNode : public ExtractNode { 1129 public: 1130 ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} 1131 virtual int Opcode() const; 1132 virtual const Type *bottom_type() const { return Type::DOUBLE; } 1133 virtual uint ideal_reg() const { return Op_RegD; } 1134 };