Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/opto/vectornode.hpp@bd441136a5ce (annotated)

src/share/vm/opto/vectornode.hpp

Thu, 19 Mar 2009 09:13:24 -0700

author
kvn
date
Thu, 19 Mar 2009 09:13:24 -0700
changeset 1082
bd441136a5ce
parent 631
d1605aabd0a1
child 1907
c18cbe5936b8
permissions
-rw-r--r--

Merge

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial