Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/opto/vectornode.hpp

Thu, 21 Jul 2011 11:25:07 -0700

author
kvn
date
Thu, 21 Jul 2011 11:25:07 -0700
changeset 3037
3d42f82cd811
parent 2727
08eb13460b3a
child 3040
c7b60b601eb4
permissions
-rw-r--r--

7063628: Use cbcond on T4
Summary: Add new short branch instruction to Hotspot sparc assembler.
Reviewed-by: never, twisti, jrose

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial