Mercurial > hg > graal-compiler
annotate src/share/vm/opto/vectornode.hpp @ 1941:79d04223b8a5
Added caching for resolved types and resolved fields.
This is crucial, because the local load elimination will lead to wrong results, if field equality (of two RiField objects with the same object and the same RiType) is not given. The caching makes sure that the default equals implementation is sufficient.
| author | Thomas Wuerthinger <wuerthinger@ssw.jku.at> |
|---|---|
| date | Tue, 28 Dec 2010 18:33:26 +0100 |
| parents | c18cbe5936b8 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
2 * Copyright (c) 2007, 2008, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
196
diff
changeset
|
21 * questions. |
| 0 | 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 | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
51 return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt)); |
| 0 | 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; } | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
395 virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } |
| 0 | 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; } | |
|
29
d5fc211aea19
6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents:
0
diff
changeset
|
623 virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); } |
| 0 | 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 }; |