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