Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/opto/vectornode.hpp

Tue, 23 Nov 2010 13:22:55 -0800

author
stefank
date
Tue, 23 Nov 2010 13:22:55 -0800
changeset 2314
f95d63e2154a
parent 1907
c18cbe5936b8
child 2727
08eb13460b3a
permissions
-rw-r--r--

6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial