1.1 --- a/src/share/vm/opto/vectornode.hpp Thu Jun 14 14:59:52 2012 -0700
1.2 +++ b/src/share/vm/opto/vectornode.hpp Fri Jun 15 01:25:19 2012 -0700
1.3 @@ -1,5 +1,5 @@
1.4 /*
1.5 - * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
1.6 + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
1.7 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
1.8 *
1.9 * This code is free software; you can redistribute it and/or modify it
1.10 @@ -31,48 +31,32 @@
1.11
1.12 //------------------------------VectorNode--------------------------------------
1.13 // Vector Operation
1.14 -class VectorNode : public Node {
1.15 - virtual uint size_of() const { return sizeof(*this); }
1.16 - protected:
1.17 - uint _length; // vector length
1.18 - virtual BasicType elt_basic_type() const = 0; // Vector element basic type
1.19 +class VectorNode : public TypeNode {
1.20 + public:
1.21
1.22 - static const Type* vect_type(BasicType elt_bt, uint len);
1.23 - static const Type* vect_type(const Type* elt_type, uint len) {
1.24 - return vect_type(elt_type->array_element_basic_type(), len);
1.25 + VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
1.26 + init_class_id(Class_Vector);
1.27 + init_req(1, n1);
1.28 + }
1.29 + VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
1.30 + init_class_id(Class_Vector);
1.31 + init_req(1, n1);
1.32 + init_req(2, n2);
1.33 }
1.34
1.35 - public:
1.36 - friend class VectorLoadNode; // For vect_type
1.37 - friend class VectorStoreNode; // ditto.
1.38 + const TypeVect* vect_type() const { return type()->is_vect(); }
1.39 + uint length() const { return vect_type()->length(); } // Vector length
1.40
1.41 - VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
1.42 - init_class_id(Class_Vector);
1.43 - }
1.44 - VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
1.45 - init_class_id(Class_Vector);
1.46 - }
1.47 virtual int Opcode() const;
1.48
1.49 - uint length() const { return _length; } // Vector length
1.50 -
1.51 - static uint max_vlen(BasicType bt) { // max vector length
1.52 - return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt));
1.53 - }
1.54 -
1.55 - // Element and vector type
1.56 - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
1.57 - const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
1.58 -
1.59 - virtual const Type *bottom_type() const { return vect_type(); }
1.60 - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
1.61 -
1.62 - // Vector opcode from scalar opcode
1.63 - static int opcode(int sopc, uint vlen, const Type* opd_t);
1.64 + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
1.65
1.66 static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
1.67
1.68 - static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
1.69 + static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
1.70 +
1.71 + static int opcode(int opc, uint vlen, BasicType bt);
1.72 + static bool implemented(int opc, uint vlen, BasicType bt);
1.73
1.74 };
1.75
1.76 @@ -81,981 +65,393 @@
1.77 //------------------------------AddVBNode---------------------------------------
1.78 // Vector add byte
1.79 class AddVBNode : public VectorNode {
1.80 - protected:
1.81 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.82 public:
1.83 - AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.84 - virtual int Opcode() const;
1.85 -};
1.86 -
1.87 -//------------------------------AddVCNode---------------------------------------
1.88 -// Vector add char
1.89 -class AddVCNode : public VectorNode {
1.90 - protected:
1.91 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.92 - public:
1.93 - AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.94 + AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.95 virtual int Opcode() const;
1.96 };
1.97
1.98 //------------------------------AddVSNode---------------------------------------
1.99 -// Vector add short
1.100 +// Vector add char/short
1.101 class AddVSNode : public VectorNode {
1.102 - protected:
1.103 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.104 public:
1.105 - AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.106 + AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.107 virtual int Opcode() const;
1.108 };
1.109
1.110 //------------------------------AddVINode---------------------------------------
1.111 // Vector add int
1.112 class AddVINode : public VectorNode {
1.113 - protected:
1.114 - virtual BasicType elt_basic_type() const { return T_INT; }
1.115 public:
1.116 - AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.117 + AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.118 virtual int Opcode() const;
1.119 };
1.120
1.121 //------------------------------AddVLNode---------------------------------------
1.122 // Vector add long
1.123 class AddVLNode : public VectorNode {
1.124 - protected:
1.125 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.126 public:
1.127 - AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.128 + AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.129 virtual int Opcode() const;
1.130 };
1.131
1.132 //------------------------------AddVFNode---------------------------------------
1.133 // Vector add float
1.134 class AddVFNode : public VectorNode {
1.135 - protected:
1.136 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.137 public:
1.138 - AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.139 + AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.140 virtual int Opcode() const;
1.141 };
1.142
1.143 //------------------------------AddVDNode---------------------------------------
1.144 // Vector add double
1.145 class AddVDNode : public VectorNode {
1.146 - protected:
1.147 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.148 public:
1.149 - AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.150 + AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.151 virtual int Opcode() const;
1.152 };
1.153
1.154 //------------------------------SubVBNode---------------------------------------
1.155 // Vector subtract byte
1.156 class SubVBNode : public VectorNode {
1.157 - protected:
1.158 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.159 public:
1.160 - SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.161 - virtual int Opcode() const;
1.162 -};
1.163 -
1.164 -//------------------------------SubVCNode---------------------------------------
1.165 -// Vector subtract char
1.166 -class SubVCNode : public VectorNode {
1.167 - protected:
1.168 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.169 - public:
1.170 - SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.171 + SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.172 virtual int Opcode() const;
1.173 };
1.174
1.175 //------------------------------SubVSNode---------------------------------------
1.176 // Vector subtract short
1.177 class SubVSNode : public VectorNode {
1.178 - protected:
1.179 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.180 public:
1.181 - SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.182 + SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.183 virtual int Opcode() const;
1.184 };
1.185
1.186 //------------------------------SubVINode---------------------------------------
1.187 // Vector subtract int
1.188 class SubVINode : public VectorNode {
1.189 - protected:
1.190 - virtual BasicType elt_basic_type() const { return T_INT; }
1.191 public:
1.192 - SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.193 + SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.194 virtual int Opcode() const;
1.195 };
1.196
1.197 //------------------------------SubVLNode---------------------------------------
1.198 // Vector subtract long
1.199 class SubVLNode : public VectorNode {
1.200 - protected:
1.201 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.202 public:
1.203 - SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.204 + SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.205 virtual int Opcode() const;
1.206 };
1.207
1.208 //------------------------------SubVFNode---------------------------------------
1.209 // Vector subtract float
1.210 class SubVFNode : public VectorNode {
1.211 - protected:
1.212 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.213 public:
1.214 - SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.215 + SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.216 virtual int Opcode() const;
1.217 };
1.218
1.219 //------------------------------SubVDNode---------------------------------------
1.220 // Vector subtract double
1.221 class SubVDNode : public VectorNode {
1.222 - protected:
1.223 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.224 public:
1.225 - SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.226 + SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.227 virtual int Opcode() const;
1.228 };
1.229
1.230 //------------------------------MulVFNode---------------------------------------
1.231 // Vector multiply float
1.232 class MulVFNode : public VectorNode {
1.233 - protected:
1.234 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.235 public:
1.236 - MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.237 + MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.238 virtual int Opcode() const;
1.239 };
1.240
1.241 //------------------------------MulVDNode---------------------------------------
1.242 // Vector multiply double
1.243 class MulVDNode : public VectorNode {
1.244 - protected:
1.245 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.246 public:
1.247 - MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.248 + MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.249 virtual int Opcode() const;
1.250 };
1.251
1.252 //------------------------------DivVFNode---------------------------------------
1.253 // Vector divide float
1.254 class DivVFNode : public VectorNode {
1.255 - protected:
1.256 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.257 public:
1.258 - DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.259 + DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.260 virtual int Opcode() const;
1.261 };
1.262
1.263 //------------------------------DivVDNode---------------------------------------
1.264 // Vector Divide double
1.265 class DivVDNode : public VectorNode {
1.266 - protected:
1.267 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.268 public:
1.269 - DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.270 + DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.271 virtual int Opcode() const;
1.272 };
1.273
1.274 //------------------------------LShiftVBNode---------------------------------------
1.275 // Vector lshift byte
1.276 class LShiftVBNode : public VectorNode {
1.277 - protected:
1.278 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.279 public:
1.280 - LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.281 - virtual int Opcode() const;
1.282 -};
1.283 -
1.284 -//------------------------------LShiftVCNode---------------------------------------
1.285 -// Vector lshift chars
1.286 -class LShiftVCNode : public VectorNode {
1.287 - protected:
1.288 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.289 - public:
1.290 - LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.291 + LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.292 virtual int Opcode() const;
1.293 };
1.294
1.295 //------------------------------LShiftVSNode---------------------------------------
1.296 // Vector lshift shorts
1.297 class LShiftVSNode : public VectorNode {
1.298 - protected:
1.299 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.300 public:
1.301 - LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.302 + LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.303 virtual int Opcode() const;
1.304 };
1.305
1.306 //------------------------------LShiftVINode---------------------------------------
1.307 // Vector lshift ints
1.308 class LShiftVINode : public VectorNode {
1.309 - protected:
1.310 - virtual BasicType elt_basic_type() const { return T_INT; }
1.311 public:
1.312 - LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.313 + LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.314 virtual int Opcode() const;
1.315 };
1.316
1.317 //------------------------------URShiftVBNode---------------------------------------
1.318 // Vector urshift bytes
1.319 -class URShiftVBNode : public VectorNode {
1.320 - protected:
1.321 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.322 +class RShiftVBNode : public VectorNode {
1.323 public:
1.324 - URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.325 - virtual int Opcode() const;
1.326 -};
1.327 -
1.328 -//------------------------------URShiftVCNode---------------------------------------
1.329 -// Vector urshift char
1.330 -class URShiftVCNode : public VectorNode {
1.331 - protected:
1.332 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.333 - public:
1.334 - URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.335 + RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.336 virtual int Opcode() const;
1.337 };
1.338
1.339 //------------------------------URShiftVSNode---------------------------------------
1.340 // Vector urshift shorts
1.341 -class URShiftVSNode : public VectorNode {
1.342 - protected:
1.343 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.344 +class RShiftVSNode : public VectorNode {
1.345 public:
1.346 - URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.347 + RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.348 virtual int Opcode() const;
1.349 };
1.350
1.351 //------------------------------URShiftVINode---------------------------------------
1.352 // Vector urshift ints
1.353 -class URShiftVINode : public VectorNode {
1.354 - protected:
1.355 - virtual BasicType elt_basic_type() const { return T_INT; }
1.356 +class RShiftVINode : public VectorNode {
1.357 public:
1.358 - URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
1.359 + RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.360 virtual int Opcode() const;
1.361 };
1.362
1.363 //------------------------------AndVNode---------------------------------------
1.364 // Vector and
1.365 class AndVNode : public VectorNode {
1.366 - protected:
1.367 - BasicType _bt;
1.368 - virtual BasicType elt_basic_type() const { return _bt; }
1.369 public:
1.370 - AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
1.371 + AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.372 virtual int Opcode() const;
1.373 };
1.374
1.375 //------------------------------OrVNode---------------------------------------
1.376 // Vector or
1.377 class OrVNode : public VectorNode {
1.378 - protected:
1.379 - BasicType _bt;
1.380 - virtual BasicType elt_basic_type() const { return _bt; }
1.381 public:
1.382 - OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
1.383 + OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.384 virtual int Opcode() const;
1.385 };
1.386
1.387 //------------------------------XorVNode---------------------------------------
1.388 // Vector xor
1.389 class XorVNode : public VectorNode {
1.390 - protected:
1.391 - BasicType _bt;
1.392 - virtual BasicType elt_basic_type() const { return _bt; }
1.393 public:
1.394 - XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
1.395 + XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
1.396 virtual int Opcode() const;
1.397 };
1.398
1.399 -//================================= M E M O R Y ==================================
1.400 +//================================= M E M O R Y ===============================
1.401
1.402 -
1.403 -//------------------------------VectorLoadNode--------------------------------------
1.404 -// Vector Load from memory
1.405 -class VectorLoadNode : public LoadNode {
1.406 - virtual uint size_of() const { return sizeof(*this); }
1.407 -
1.408 - protected:
1.409 - virtual BasicType elt_basic_type() const = 0; // Vector element basic type
1.410 - // For use in constructor
1.411 - static const Type* vect_type(const Type* elt_type, uint len) {
1.412 - return VectorNode::vect_type(elt_type, len);
1.413 +//------------------------------LoadVectorNode---------------------------------
1.414 +// Load Vector from memory
1.415 +class LoadVectorNode : public LoadNode {
1.416 + public:
1.417 + LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
1.418 + : LoadNode(c, mem, adr, at, vt) {
1.419 + init_class_id(Class_LoadVector);
1.420 }
1.421
1.422 - public:
1.423 - VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)
1.424 - : LoadNode(c,mem,adr,at,rt) {
1.425 - init_class_id(Class_VectorLoad);
1.426 - }
1.427 + const TypeVect* vect_type() const { return type()->is_vect(); }
1.428 + uint length() const { return vect_type()->length(); } // Vector length
1.429 +
1.430 virtual int Opcode() const;
1.431
1.432 - virtual uint length() const = 0; // Vector length
1.433 + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
1.434 + virtual BasicType memory_type() const { return T_VOID; }
1.435 + virtual int memory_size() const { return vect_type()->length_in_bytes(); }
1.436
1.437 - // Element and vector type
1.438 - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
1.439 - const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
1.440 + virtual int store_Opcode() const { return Op_StoreVector; }
1.441
1.442 - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
1.443 - virtual BasicType memory_type() const { return T_VOID; }
1.444 - virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
1.445 -
1.446 - // Vector opcode from scalar opcode
1.447 - static int opcode(int sopc, uint vlen);
1.448 -
1.449 - static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,
1.450 - Node* adr, const TypePtr* atyp, uint vlen);
1.451 + static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
1.452 + Node* adr, const TypePtr* atyp, uint vlen, BasicType bt);
1.453 };
1.454
1.455 -//------------------------------Load16BNode--------------------------------------
1.456 -// Vector load of 16 bytes (8bits signed) from memory
1.457 -class Load16BNode : public VectorLoadNode {
1.458 - protected:
1.459 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.460 +//------------------------------StoreVectorNode--------------------------------
1.461 +// Store Vector to memory
1.462 +class StoreVectorNode : public StoreNode {
1.463 public:
1.464 - Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
1.465 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}
1.466 - virtual int Opcode() const;
1.467 - virtual int store_Opcode() const { return Op_Store16B; }
1.468 - virtual uint length() const { return 16; }
1.469 -};
1.470 + StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.471 + : StoreNode(c, mem, adr, at, val) {
1.472 + assert(val->is_Vector() || val->is_LoadVector(), "sanity");
1.473 + init_class_id(Class_StoreVector);
1.474 + }
1.475
1.476 -//------------------------------Load8BNode--------------------------------------
1.477 -// Vector load of 8 bytes (8bits signed) from memory
1.478 -class Load8BNode : public VectorLoadNode {
1.479 - protected:
1.480 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.481 - public:
1.482 - Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
1.483 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
1.484 - virtual int Opcode() const;
1.485 - virtual int store_Opcode() const { return Op_Store8B; }
1.486 - virtual uint length() const { return 8; }
1.487 -};
1.488 + const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
1.489 + uint length() const { return vect_type()->length(); } // Vector length
1.490
1.491 -//------------------------------Load4BNode--------------------------------------
1.492 -// Vector load of 4 bytes (8bits signed) from memory
1.493 -class Load4BNode : public VectorLoadNode {
1.494 - protected:
1.495 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.496 - public:
1.497 - Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
1.498 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
1.499 - virtual int Opcode() const;
1.500 - virtual int store_Opcode() const { return Op_Store4B; }
1.501 - virtual uint length() const { return 4; }
1.502 -};
1.503 -
1.504 -//------------------------------Load8CNode--------------------------------------
1.505 -// Vector load of 8 chars (16bits unsigned) from memory
1.506 -class Load8CNode : public VectorLoadNode {
1.507 - protected:
1.508 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.509 - public:
1.510 - Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
1.511 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
1.512 - virtual int Opcode() const;
1.513 - virtual int store_Opcode() const { return Op_Store8C; }
1.514 - virtual uint length() const { return 8; }
1.515 -};
1.516 -
1.517 -//------------------------------Load4CNode--------------------------------------
1.518 -// Vector load of 4 chars (16bits unsigned) from memory
1.519 -class Load4CNode : public VectorLoadNode {
1.520 - protected:
1.521 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.522 - public:
1.523 - Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
1.524 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
1.525 - virtual int Opcode() const;
1.526 - virtual int store_Opcode() const { return Op_Store4C; }
1.527 - virtual uint length() const { return 4; }
1.528 -};
1.529 -
1.530 -//------------------------------Load2CNode--------------------------------------
1.531 -// Vector load of 2 chars (16bits unsigned) from memory
1.532 -class Load2CNode : public VectorLoadNode {
1.533 - protected:
1.534 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.535 - public:
1.536 - Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
1.537 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
1.538 - virtual int Opcode() const;
1.539 - virtual int store_Opcode() const { return Op_Store2C; }
1.540 - virtual uint length() const { return 2; }
1.541 -};
1.542 -
1.543 -//------------------------------Load8SNode--------------------------------------
1.544 -// Vector load of 8 shorts (16bits signed) from memory
1.545 -class Load8SNode : public VectorLoadNode {
1.546 - protected:
1.547 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.548 - public:
1.549 - Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
1.550 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
1.551 - virtual int Opcode() const;
1.552 - virtual int store_Opcode() const { return Op_Store8C; }
1.553 - virtual uint length() const { return 8; }
1.554 -};
1.555 -
1.556 -//------------------------------Load4SNode--------------------------------------
1.557 -// Vector load of 4 shorts (16bits signed) from memory
1.558 -class Load4SNode : public VectorLoadNode {
1.559 - protected:
1.560 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.561 - public:
1.562 - Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
1.563 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
1.564 - virtual int Opcode() const;
1.565 - virtual int store_Opcode() const { return Op_Store4C; }
1.566 - virtual uint length() const { return 4; }
1.567 -};
1.568 -
1.569 -//------------------------------Load2SNode--------------------------------------
1.570 -// Vector load of 2 shorts (16bits signed) from memory
1.571 -class Load2SNode : public VectorLoadNode {
1.572 - protected:
1.573 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.574 - public:
1.575 - Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
1.576 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
1.577 - virtual int Opcode() const;
1.578 - virtual int store_Opcode() const { return Op_Store2C; }
1.579 - virtual uint length() const { return 2; }
1.580 -};
1.581 -
1.582 -//------------------------------Load4INode--------------------------------------
1.583 -// Vector load of 4 integers (32bits signed) from memory
1.584 -class Load4INode : public VectorLoadNode {
1.585 - protected:
1.586 - virtual BasicType elt_basic_type() const { return T_INT; }
1.587 - public:
1.588 - Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
1.589 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
1.590 - virtual int Opcode() const;
1.591 - virtual int store_Opcode() const { return Op_Store4I; }
1.592 - virtual uint length() const { return 4; }
1.593 -};
1.594 -
1.595 -//------------------------------Load2INode--------------------------------------
1.596 -// Vector load of 2 integers (32bits signed) from memory
1.597 -class Load2INode : public VectorLoadNode {
1.598 - protected:
1.599 - virtual BasicType elt_basic_type() const { return T_INT; }
1.600 - public:
1.601 - Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
1.602 - : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
1.603 - virtual int Opcode() const;
1.604 - virtual int store_Opcode() const { return Op_Store2I; }
1.605 - virtual uint length() const { return 2; }
1.606 -};
1.607 -
1.608 -//------------------------------Load2LNode--------------------------------------
1.609 -// Vector load of 2 longs (64bits signed) from memory
1.610 -class Load2LNode : public VectorLoadNode {
1.611 - protected:
1.612 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.613 - public:
1.614 - Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)
1.615 - : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}
1.616 - virtual int Opcode() const;
1.617 - virtual int store_Opcode() const { return Op_Store2L; }
1.618 - virtual uint length() const { return 2; }
1.619 -};
1.620 -
1.621 -//------------------------------Load4FNode--------------------------------------
1.622 -// Vector load of 4 floats (32bits) from memory
1.623 -class Load4FNode : public VectorLoadNode {
1.624 - protected:
1.625 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.626 - public:
1.627 - Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
1.628 - : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}
1.629 - virtual int Opcode() const;
1.630 - virtual int store_Opcode() const { return Op_Store4F; }
1.631 - virtual uint length() const { return 4; }
1.632 -};
1.633 -
1.634 -//------------------------------Load2FNode--------------------------------------
1.635 -// Vector load of 2 floats (32bits) from memory
1.636 -class Load2FNode : public VectorLoadNode {
1.637 - protected:
1.638 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.639 - public:
1.640 - Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
1.641 - : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
1.642 - virtual int Opcode() const;
1.643 - virtual int store_Opcode() const { return Op_Store2F; }
1.644 - virtual uint length() const { return 2; }
1.645 -};
1.646 -
1.647 -//------------------------------Load2DNode--------------------------------------
1.648 -// Vector load of 2 doubles (64bits) from memory
1.649 -class Load2DNode : public VectorLoadNode {
1.650 - protected:
1.651 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.652 - public:
1.653 - Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)
1.654 - : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
1.655 - virtual int Opcode() const;
1.656 - virtual int store_Opcode() const { return Op_Store2D; }
1.657 - virtual uint length() const { return 2; }
1.658 -};
1.659 -
1.660 -
1.661 -//------------------------------VectorStoreNode--------------------------------------
1.662 -// Vector Store to memory
1.663 -class VectorStoreNode : public StoreNode {
1.664 - virtual uint size_of() const { return sizeof(*this); }
1.665 -
1.666 - protected:
1.667 - virtual BasicType elt_basic_type() const = 0; // Vector element basic type
1.668 -
1.669 - public:
1.670 - VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.671 - : StoreNode(c,mem,adr,at,val) {
1.672 - init_class_id(Class_VectorStore);
1.673 - }
1.674 virtual int Opcode() const;
1.675
1.676 - virtual uint length() const = 0; // Vector length
1.677 + virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
1.678 + virtual BasicType memory_type() const { return T_VOID; }
1.679 + virtual int memory_size() const { return vect_type()->length_in_bytes(); }
1.680
1.681 - // Element and vector type
1.682 - const Type* elt_type() const { return Type::get_const_basic_type(elt_basic_type()); }
1.683 - const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
1.684 -
1.685 - virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(); }
1.686 - virtual BasicType memory_type() const { return T_VOID; }
1.687 - virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
1.688 -
1.689 - // Vector opcode from scalar opcode
1.690 - static int opcode(int sopc, uint vlen);
1.691 -
1.692 - static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,
1.693 + static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
1.694 Node* adr, const TypePtr* atyp, Node* val,
1.695 uint vlen);
1.696 };
1.697
1.698 -//------------------------------Store16BNode--------------------------------------
1.699 -// Vector store of 16 bytes (8bits signed) to memory
1.700 -class Store16BNode : public VectorStoreNode {
1.701 - protected:
1.702 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.703 +
1.704 +//=========================Promote_Scalar_to_Vector============================
1.705 +
1.706 +//------------------------------ReplicateBNode---------------------------------
1.707 +// Replicate byte scalar to be vector
1.708 +class ReplicateBNode : public VectorNode {
1.709 public:
1.710 - Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.711 - : VectorStoreNode(c,mem,adr,at,val) {}
1.712 - virtual int Opcode() const;
1.713 - virtual uint length() const { return 16; }
1.714 -};
1.715 -
1.716 -//------------------------------Store8BNode--------------------------------------
1.717 -// Vector store of 8 bytes (8bits signed) to memory
1.718 -class Store8BNode : public VectorStoreNode {
1.719 - protected:
1.720 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.721 - public:
1.722 - Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.723 - : VectorStoreNode(c,mem,adr,at,val) {}
1.724 - virtual int Opcode() const;
1.725 - virtual uint length() const { return 8; }
1.726 -};
1.727 -
1.728 -//------------------------------Store4BNode--------------------------------------
1.729 -// Vector store of 4 bytes (8bits signed) to memory
1.730 -class Store4BNode : public VectorStoreNode {
1.731 - protected:
1.732 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.733 - public:
1.734 - Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.735 - : VectorStoreNode(c,mem,adr,at,val) {}
1.736 - virtual int Opcode() const;
1.737 - virtual uint length() const { return 4; }
1.738 -};
1.739 -
1.740 -//------------------------------Store8CNode--------------------------------------
1.741 -// Vector store of 8 chars (16bits signed/unsigned) to memory
1.742 -class Store8CNode : public VectorStoreNode {
1.743 - protected:
1.744 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.745 - public:
1.746 - Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.747 - : VectorStoreNode(c,mem,adr,at,val) {}
1.748 - virtual int Opcode() const;
1.749 - virtual uint length() const { return 8; }
1.750 -};
1.751 -
1.752 -//------------------------------Store4CNode--------------------------------------
1.753 -// Vector store of 4 chars (16bits signed/unsigned) to memory
1.754 -class Store4CNode : public VectorStoreNode {
1.755 - protected:
1.756 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.757 - public:
1.758 - Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.759 - : VectorStoreNode(c,mem,adr,at,val) {}
1.760 - virtual int Opcode() const;
1.761 - virtual uint length() const { return 4; }
1.762 -};
1.763 -
1.764 -//------------------------------Store2CNode--------------------------------------
1.765 -// Vector store of 2 chars (16bits signed/unsigned) to memory
1.766 -class Store2CNode : public VectorStoreNode {
1.767 - protected:
1.768 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.769 - public:
1.770 - Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.771 - : VectorStoreNode(c,mem,adr,at,val) {}
1.772 - virtual int Opcode() const;
1.773 - virtual uint length() const { return 2; }
1.774 -};
1.775 -
1.776 -//------------------------------Store4INode--------------------------------------
1.777 -// Vector store of 4 integers (32bits signed) to memory
1.778 -class Store4INode : public VectorStoreNode {
1.779 - protected:
1.780 - virtual BasicType elt_basic_type() const { return T_INT; }
1.781 - public:
1.782 - Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.783 - : VectorStoreNode(c,mem,adr,at,val) {}
1.784 - virtual int Opcode() const;
1.785 - virtual uint length() const { return 4; }
1.786 -};
1.787 -
1.788 -//------------------------------Store2INode--------------------------------------
1.789 -// Vector store of 2 integers (32bits signed) to memory
1.790 -class Store2INode : public VectorStoreNode {
1.791 - protected:
1.792 - virtual BasicType elt_basic_type() const { return T_INT; }
1.793 - public:
1.794 - Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.795 - : VectorStoreNode(c,mem,adr,at,val) {}
1.796 - virtual int Opcode() const;
1.797 - virtual uint length() const { return 2; }
1.798 -};
1.799 -
1.800 -//------------------------------Store2LNode--------------------------------------
1.801 -// Vector store of 2 longs (64bits signed) to memory
1.802 -class Store2LNode : public VectorStoreNode {
1.803 - protected:
1.804 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.805 - public:
1.806 - Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.807 - : VectorStoreNode(c,mem,adr,at,val) {}
1.808 - virtual int Opcode() const;
1.809 - virtual uint length() const { return 2; }
1.810 -};
1.811 -
1.812 -//------------------------------Store4FNode--------------------------------------
1.813 -// Vector store of 4 floats (32bits) to memory
1.814 -class Store4FNode : public VectorStoreNode {
1.815 - protected:
1.816 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.817 - public:
1.818 - Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.819 - : VectorStoreNode(c,mem,adr,at,val) {}
1.820 - virtual int Opcode() const;
1.821 - virtual uint length() const { return 4; }
1.822 -};
1.823 -
1.824 -//------------------------------Store2FNode--------------------------------------
1.825 -// Vector store of 2 floats (32bits) to memory
1.826 -class Store2FNode : public VectorStoreNode {
1.827 - protected:
1.828 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.829 - public:
1.830 - Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.831 - : VectorStoreNode(c,mem,adr,at,val) {}
1.832 - virtual int Opcode() const;
1.833 - virtual uint length() const { return 2; }
1.834 -};
1.835 -
1.836 -//------------------------------Store2DNode--------------------------------------
1.837 -// Vector store of 2 doubles (64bits) to memory
1.838 -class Store2DNode : public VectorStoreNode {
1.839 - protected:
1.840 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.841 - public:
1.842 - Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
1.843 - : VectorStoreNode(c,mem,adr,at,val) {}
1.844 - virtual int Opcode() const;
1.845 - virtual uint length() const { return 2; }
1.846 -};
1.847 -
1.848 -//=========================Promote_Scalar_to_Vector====================================
1.849 -
1.850 -//------------------------------Replicate16BNode---------------------------------------
1.851 -// Replicate byte scalar to be vector of 16 bytes
1.852 -class Replicate16BNode : public VectorNode {
1.853 - protected:
1.854 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.855 - public:
1.856 - Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}
1.857 + ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.858 virtual int Opcode() const;
1.859 };
1.860
1.861 -//------------------------------Replicate8BNode---------------------------------------
1.862 -// Replicate byte scalar to be vector of 8 bytes
1.863 -class Replicate8BNode : public VectorNode {
1.864 - protected:
1.865 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.866 +//------------------------------ReplicateSNode---------------------------------
1.867 +// Replicate short scalar to be vector
1.868 +class ReplicateSNode : public VectorNode {
1.869 public:
1.870 - Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}
1.871 + ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.872 virtual int Opcode() const;
1.873 };
1.874
1.875 -//------------------------------Replicate4BNode---------------------------------------
1.876 -// Replicate byte scalar to be vector of 4 bytes
1.877 -class Replicate4BNode : public VectorNode {
1.878 - protected:
1.879 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.880 +//------------------------------ReplicateINode---------------------------------
1.881 +// Replicate int scalar to be vector
1.882 +class ReplicateINode : public VectorNode {
1.883 public:
1.884 - Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}
1.885 + ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.886 virtual int Opcode() const;
1.887 };
1.888
1.889 -//------------------------------Replicate8CNode---------------------------------------
1.890 -// Replicate char scalar to be vector of 8 chars
1.891 -class Replicate8CNode : public VectorNode {
1.892 - protected:
1.893 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.894 +//------------------------------ReplicateLNode---------------------------------
1.895 +// Replicate long scalar to be vector
1.896 +class ReplicateLNode : public VectorNode {
1.897 public:
1.898 - Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}
1.899 + ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.900 virtual int Opcode() const;
1.901 };
1.902
1.903 -//------------------------------Replicate4CNode---------------------------------------
1.904 -// Replicate char scalar to be vector of 4 chars
1.905 -class Replicate4CNode : public VectorNode {
1.906 - protected:
1.907 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.908 +//------------------------------ReplicateFNode---------------------------------
1.909 +// Replicate float scalar to be vector
1.910 +class ReplicateFNode : public VectorNode {
1.911 public:
1.912 - Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}
1.913 + ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.914 virtual int Opcode() const;
1.915 };
1.916
1.917 -//------------------------------Replicate2CNode---------------------------------------
1.918 -// Replicate char scalar to be vector of 2 chars
1.919 -class Replicate2CNode : public VectorNode {
1.920 - protected:
1.921 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.922 +//------------------------------ReplicateDNode---------------------------------
1.923 +// Replicate double scalar to be vector
1.924 +class ReplicateDNode : public VectorNode {
1.925 public:
1.926 - Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}
1.927 + ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.928 virtual int Opcode() const;
1.929 };
1.930
1.931 -//------------------------------Replicate8SNode---------------------------------------
1.932 -// Replicate short scalar to be vector of 8 shorts
1.933 -class Replicate8SNode : public VectorNode {
1.934 - protected:
1.935 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.936 - public:
1.937 - Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}
1.938 - virtual int Opcode() const;
1.939 -};
1.940 -
1.941 -//------------------------------Replicate4SNode---------------------------------------
1.942 -// Replicate short scalar to be vector of 4 shorts
1.943 -class Replicate4SNode : public VectorNode {
1.944 - protected:
1.945 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.946 - public:
1.947 - Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}
1.948 - virtual int Opcode() const;
1.949 -};
1.950 -
1.951 -//------------------------------Replicate2SNode---------------------------------------
1.952 -// Replicate short scalar to be vector of 2 shorts
1.953 -class Replicate2SNode : public VectorNode {
1.954 - protected:
1.955 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.956 - public:
1.957 - Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}
1.958 - virtual int Opcode() const;
1.959 -};
1.960 -
1.961 -//------------------------------Replicate4INode---------------------------------------
1.962 -// Replicate int scalar to be vector of 4 ints
1.963 -class Replicate4INode : public VectorNode {
1.964 - protected:
1.965 - virtual BasicType elt_basic_type() const { return T_INT; }
1.966 - public:
1.967 - Replicate4INode(Node* in1) : VectorNode(in1, 4) {}
1.968 - virtual int Opcode() const;
1.969 -};
1.970 -
1.971 -//------------------------------Replicate2INode---------------------------------------
1.972 -// Replicate int scalar to be vector of 2 ints
1.973 -class Replicate2INode : public VectorNode {
1.974 - protected:
1.975 - virtual BasicType elt_basic_type() const { return T_INT; }
1.976 - public:
1.977 - Replicate2INode(Node* in1) : VectorNode(in1, 2) {}
1.978 - virtual int Opcode() const;
1.979 -};
1.980 -
1.981 -//------------------------------Replicate2LNode---------------------------------------
1.982 -// Replicate long scalar to be vector of 2 longs
1.983 -class Replicate2LNode : public VectorNode {
1.984 - protected:
1.985 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.986 - public:
1.987 - Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}
1.988 - virtual int Opcode() const;
1.989 -};
1.990 -
1.991 -//------------------------------Replicate4FNode---------------------------------------
1.992 -// Replicate float scalar to be vector of 4 floats
1.993 -class Replicate4FNode : public VectorNode {
1.994 - protected:
1.995 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.996 - public:
1.997 - Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}
1.998 - virtual int Opcode() const;
1.999 -};
1.1000 -
1.1001 -//------------------------------Replicate2FNode---------------------------------------
1.1002 -// Replicate float scalar to be vector of 2 floats
1.1003 -class Replicate2FNode : public VectorNode {
1.1004 - protected:
1.1005 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.1006 - public:
1.1007 - Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}
1.1008 - virtual int Opcode() const;
1.1009 -};
1.1010 -
1.1011 -//------------------------------Replicate2DNode---------------------------------------
1.1012 -// Replicate double scalar to be vector of 2 doubles
1.1013 -class Replicate2DNode : public VectorNode {
1.1014 - protected:
1.1015 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.1016 - public:
1.1017 - Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}
1.1018 - virtual int Opcode() const;
1.1019 -};
1.1020 -
1.1021 -//========================Pack_Scalars_into_a_Vector==============================
1.1022 +//========================Pack_Scalars_into_a_Vector===========================
1.1023
1.1024 //------------------------------PackNode---------------------------------------
1.1025 // Pack parent class (not for code generation).
1.1026 class PackNode : public VectorNode {
1.1027 public:
1.1028 - PackNode(Node* in1) : VectorNode(in1, 1) {}
1.1029 - PackNode(Node* in1, Node* n2) : VectorNode(in1, n2, 2) {}
1.1030 + PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
1.1031 + PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
1.1032 virtual int Opcode() const;
1.1033
1.1034 - void add_opd(Node* n) {
1.1035 - add_req(n);
1.1036 - _length++;
1.1037 - assert(_length == req() - 1, "vector length matches edge count");
1.1038 + void add_opd(uint i, Node* n) {
1.1039 + init_req(i+1, n);
1.1040 }
1.1041
1.1042 // Create a binary tree form for Packs. [lo, hi) (half-open) range
1.1043 Node* binaryTreePack(Compile* C, int lo, int hi);
1.1044
1.1045 - static PackNode* make(Compile* C, Node* s, const Type* elt_t);
1.1046 + static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);
1.1047 };
1.1048
1.1049 //------------------------------PackBNode---------------------------------------
1.1050 // Pack byte scalars into vector
1.1051 class PackBNode : public PackNode {
1.1052 - protected:
1.1053 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.1054 public:
1.1055 - PackBNode(Node* in1) : PackNode(in1) {}
1.1056 - virtual int Opcode() const;
1.1057 -};
1.1058 -
1.1059 -//------------------------------PackCNode---------------------------------------
1.1060 -// Pack char scalars into vector
1.1061 -class PackCNode : public PackNode {
1.1062 - protected:
1.1063 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.1064 - public:
1.1065 - PackCNode(Node* in1) : PackNode(in1) {}
1.1066 + PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1067 virtual int Opcode() const;
1.1068 };
1.1069
1.1070 //------------------------------PackSNode---------------------------------------
1.1071 // Pack short scalars into a vector
1.1072 class PackSNode : public PackNode {
1.1073 - protected:
1.1074 - virtual BasicType elt_basic_type() const { return T_SHORT; }
1.1075 public:
1.1076 - PackSNode(Node* in1) : PackNode(in1) {}
1.1077 + PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1078 + PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1079 virtual int Opcode() const;
1.1080 };
1.1081
1.1082 //------------------------------PackINode---------------------------------------
1.1083 // Pack integer scalars into a vector
1.1084 class PackINode : public PackNode {
1.1085 - protected:
1.1086 - virtual BasicType elt_basic_type() const { return T_INT; }
1.1087 public:
1.1088 - PackINode(Node* in1) : PackNode(in1) {}
1.1089 - PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1.1090 + PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1091 + PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1092 virtual int Opcode() const;
1.1093 };
1.1094
1.1095 //------------------------------PackLNode---------------------------------------
1.1096 // Pack long scalars into a vector
1.1097 class PackLNode : public PackNode {
1.1098 - protected:
1.1099 - virtual BasicType elt_basic_type() const { return T_LONG; }
1.1100 public:
1.1101 - PackLNode(Node* in1) : PackNode(in1) {}
1.1102 - PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1.1103 + PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1104 + PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1105 + virtual int Opcode() const;
1.1106 +};
1.1107 +
1.1108 +//------------------------------Pack2LNode--------------------------------------
1.1109 +// Pack 2 long scalars into a vector
1.1110 +class Pack2LNode : public PackNode {
1.1111 + public:
1.1112 + Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1113 virtual int Opcode() const;
1.1114 };
1.1115
1.1116 //------------------------------PackFNode---------------------------------------
1.1117 // Pack float scalars into vector
1.1118 class PackFNode : public PackNode {
1.1119 - protected:
1.1120 - virtual BasicType elt_basic_type() const { return T_FLOAT; }
1.1121 public:
1.1122 - PackFNode(Node* in1) : PackNode(in1) {}
1.1123 - PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1.1124 + PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1125 + PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1126 virtual int Opcode() const;
1.1127 };
1.1128
1.1129 //------------------------------PackDNode---------------------------------------
1.1130 // Pack double scalars into a vector
1.1131 class PackDNode : public PackNode {
1.1132 - protected:
1.1133 - virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1.1134 public:
1.1135 - PackDNode(Node* in1) : PackNode(in1) {}
1.1136 - PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1.1137 + PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
1.1138 + PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1139 virtual int Opcode() const;
1.1140 };
1.1141
1.1142 -// The Pack2xN nodes assist code generation. They are created from
1.1143 -// Pack4C, etc. nodes in final_graph_reshape in the form of a
1.1144 -// balanced, binary tree.
1.1145 -
1.1146 -//------------------------------Pack2x1BNode-----------------------------------------
1.1147 -// Pack 2 1-byte integers into vector of 2 bytes
1.1148 -class Pack2x1BNode : public PackNode {
1.1149 - protected:
1.1150 - virtual BasicType elt_basic_type() const { return T_BYTE; }
1.1151 +//------------------------------Pack2DNode--------------------------------------
1.1152 +// Pack 2 double scalars into a vector
1.1153 +class Pack2DNode : public PackNode {
1.1154 public:
1.1155 - Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1.1156 + Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
1.1157 virtual int Opcode() const;
1.1158 - virtual uint ideal_reg() const { return Op_RegI; }
1.1159 };
1.1160
1.1161 -//------------------------------Pack2x2BNode---------------------------------------
1.1162 -// Pack 2 2-byte integers into vector of 4 bytes
1.1163 -class Pack2x2BNode : public PackNode {
1.1164 - protected:
1.1165 - virtual BasicType elt_basic_type() const { return T_CHAR; }
1.1166 - public:
1.1167 - Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1.1168 - virtual int Opcode() const;
1.1169 - virtual uint ideal_reg() const { return Op_RegI; }
1.1170 -};
1.1171
1.1172 //========================Extract_Scalar_from_Vector===============================
1.1173
1.1174 @@ -1069,7 +465,7 @@
1.1175 virtual int Opcode() const;
1.1176 uint pos() const { return in(2)->get_int(); }
1.1177
1.1178 - static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);
1.1179 + static Node* make(Compile* C, Node* v, uint position, BasicType bt);
1.1180 };
1.1181
1.1182 //------------------------------ExtractBNode---------------------------------------
1.1183 @@ -1082,6 +478,16 @@
1.1184 virtual uint ideal_reg() const { return Op_RegI; }
1.1185 };
1.1186
1.1187 +//------------------------------ExtractUBNode--------------------------------------
1.1188 +// Extract a boolean from a vector at position "pos"
1.1189 +class ExtractUBNode : public ExtractNode {
1.1190 + public:
1.1191 + ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1.1192 + virtual int Opcode() const;
1.1193 + virtual const Type *bottom_type() const { return TypeInt::INT; }
1.1194 + virtual uint ideal_reg() const { return Op_RegI; }
1.1195 +};
1.1196 +
1.1197 //------------------------------ExtractCNode---------------------------------------
1.1198 // Extract a char from a vector at position "pos"
1.1199 class ExtractCNode : public ExtractNode {
