1 /*
   2  * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 #include "precompiled.hpp"
  25 #include "memory/allocation.inline.hpp"
  26 #include "opto/connode.hpp"
  27 #include "opto/vectornode.hpp"
  28 
  29 //------------------------------VectorNode--------------------------------------
  30 
  31 // Return the vector operator for the specified scalar operation
  32 // and vector length.  Also used to check if the code generator
  33 // supports the vector operation.
  34 int VectorNode::opcode(int sopc, uint vlen, BasicType bt) {
  35   switch (sopc) {
  36   case Op_AddI:
  37     switch (bt) {
  38     case T_BOOLEAN:
  39     case T_BYTE:      return Op_AddVB;
  40     case T_CHAR:
  41     case T_SHORT:     return Op_AddVS;
  42     case T_INT:       return Op_AddVI;
  43     }
  44     ShouldNotReachHere();
  45   case Op_AddL:
  46     assert(bt == T_LONG, "must be");
  47     return Op_AddVL;
  48   case Op_AddF:
  49     assert(bt == T_FLOAT, "must be");
  50     return Op_AddVF;
  51   case Op_AddD:
  52     assert(bt == T_DOUBLE, "must be");
  53     return Op_AddVD;
  54   case Op_SubI:
  55     switch (bt) {
  56     case T_BOOLEAN:
  57     case T_BYTE:   return Op_SubVB;
  58     case T_CHAR:
  59     case T_SHORT:  return Op_SubVS;
  60     case T_INT:    return Op_SubVI;
  61     }
  62     ShouldNotReachHere();
  63   case Op_SubL:
  64     assert(bt == T_LONG, "must be");
  65     return Op_SubVL;
  66   case Op_SubF:
  67     assert(bt == T_FLOAT, "must be");
  68     return Op_SubVF;
  69   case Op_SubD:
  70     assert(bt == T_DOUBLE, "must be");
  71     return Op_SubVD;
  72   case Op_MulI:
  73     switch (bt) {
  74     case T_BOOLEAN:
  75     case T_BYTE:   return 0;   // Unimplemented
  76     case T_CHAR:
  77     case T_SHORT:  return Op_MulVS;
  78     case T_INT:    return Matcher::match_rule_supported(Op_MulVI) ? Op_MulVI : 0; // SSE4_1
  79     }
  80     ShouldNotReachHere();
  81   case Op_MulF:
  82     assert(bt == T_FLOAT, "must be");
  83     return Op_MulVF;
  84   case Op_MulD:
  85     assert(bt == T_DOUBLE, "must be");
  86     return Op_MulVD;
  87   case Op_DivF:
  88     assert(bt == T_FLOAT, "must be");
  89     return Op_DivVF;
  90   case Op_DivD:
  91     assert(bt == T_DOUBLE, "must be");
  92     return Op_DivVD;
  93   case Op_LShiftI:
  94     switch (bt) {
  95     case T_BOOLEAN:
  96     case T_BYTE:   return Op_LShiftVB;
  97     case T_CHAR:
  98     case T_SHORT:  return Op_LShiftVS;
  99     case T_INT:    return Op_LShiftVI;
 100     }
 101     ShouldNotReachHere();
 102   case Op_LShiftL:
 103     assert(bt == T_LONG, "must be");
 104     return Op_LShiftVL;
 105   case Op_RShiftI:
 106     switch (bt) {
 107     case T_BOOLEAN:
 108     case T_BYTE:   return Op_RShiftVB;
 109     case T_CHAR:
 110     case T_SHORT:  return Op_RShiftVS;
 111     case T_INT:    return Op_RShiftVI;
 112     }
 113     ShouldNotReachHere();
 114   case Op_RShiftL:
 115     assert(bt == T_LONG, "must be");
 116     return Op_RShiftVL;
 117   case Op_URShiftI:
 118     switch (bt) {
 119     case T_BOOLEAN:
 120     case T_BYTE:   return Op_URShiftVB;
 121     case T_CHAR:
 122     case T_SHORT:  return Op_URShiftVS;
 123     case T_INT:    return Op_URShiftVI;
 124     }
 125     ShouldNotReachHere();
 126   case Op_URShiftL:
 127     assert(bt == T_LONG, "must be");
 128     return Op_URShiftVL;
 129   case Op_AndI:
 130   case Op_AndL:
 131     return Op_AndV;
 132   case Op_OrI:
 133   case Op_OrL:
 134     return Op_OrV;
 135   case Op_XorI:
 136   case Op_XorL:
 137     return Op_XorV;
 138 
 139   case Op_LoadB:
 140   case Op_LoadUB:
 141   case Op_LoadUS:
 142   case Op_LoadS:
 143   case Op_LoadI:
 144   case Op_LoadL:
 145   case Op_LoadF:
 146   case Op_LoadD:
 147     return Op_LoadVector;
 148 
 149   case Op_StoreB:
 150   case Op_StoreC:
 151   case Op_StoreI:
 152   case Op_StoreL:
 153   case Op_StoreF:
 154   case Op_StoreD:
 155     return Op_StoreVector;
 156   }
 157   return 0; // Unimplemented
 158 }
 159 
 160 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
 161   if (is_java_primitive(bt) &&
 162       (vlen > 1) && is_power_of_2(vlen) &&
 163       Matcher::vector_size_supported(bt, vlen)) {
 164     int vopc = VectorNode::opcode(opc, vlen, bt);
 165     return vopc > 0 && Matcher::has_match_rule(vopc);
 166   }
 167   return false;
 168 }
 169 
 170 // Check if input should be vectorized.
 171 bool VectorNode::needs_vector_input(Node* n, int opd_idx) {
 172   // Only shift vector instructions don't need a vector for a shift value.
 173   if (opd_idx != 2) return true;
 174   switch (n->Opcode()) {
 175   case Op_LShiftI:
 176   case Op_LShiftL:
 177   case Op_RShiftI:
 178   case Op_RShiftL:
 179   case Op_URShiftI:
 180   case Op_URShiftL:
 181     return false;
 182   }
 183   return true;
 184 }
 185 
 186 // Return the vector version of a scalar operation node.
 187 VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
 188   const TypeVect* vt = TypeVect::make(bt, vlen);
 189   int vopc = VectorNode::opcode(opc, vlen, bt);
 190 
 191   switch (vopc) {
 192   case Op_AddVB: return new (C, 3) AddVBNode(n1, n2, vt);
 193   case Op_AddVS: return new (C, 3) AddVSNode(n1, n2, vt);
 194   case Op_AddVI: return new (C, 3) AddVINode(n1, n2, vt);
 195   case Op_AddVL: return new (C, 3) AddVLNode(n1, n2, vt);
 196   case Op_AddVF: return new (C, 3) AddVFNode(n1, n2, vt);
 197   case Op_AddVD: return new (C, 3) AddVDNode(n1, n2, vt);
 198 
 199   case Op_SubVB: return new (C, 3) SubVBNode(n1, n2, vt);
 200   case Op_SubVS: return new (C, 3) SubVSNode(n1, n2, vt);
 201   case Op_SubVI: return new (C, 3) SubVINode(n1, n2, vt);
 202   case Op_SubVL: return new (C, 3) SubVLNode(n1, n2, vt);
 203   case Op_SubVF: return new (C, 3) SubVFNode(n1, n2, vt);
 204   case Op_SubVD: return new (C, 3) SubVDNode(n1, n2, vt);
 205 
 206   case Op_MulVS: return new (C, 3) MulVSNode(n1, n2, vt);
 207   case Op_MulVI: return new (C, 3) MulVINode(n1, n2, vt);
 208   case Op_MulVF: return new (C, 3) MulVFNode(n1, n2, vt);
 209   case Op_MulVD: return new (C, 3) MulVDNode(n1, n2, vt);
 210 
 211   case Op_DivVF: return new (C, 3) DivVFNode(n1, n2, vt);
 212   case Op_DivVD: return new (C, 3) DivVDNode(n1, n2, vt);
 213 
 214   case Op_LShiftVB: return new (C, 3) LShiftVBNode(n1, n2, vt);
 215   case Op_LShiftVS: return new (C, 3) LShiftVSNode(n1, n2, vt);
 216   case Op_LShiftVI: return new (C, 3) LShiftVINode(n1, n2, vt);
 217   case Op_LShiftVL: return new (C, 3) LShiftVLNode(n1, n2, vt);
 218 
 219   case Op_RShiftVB: return new (C, 3) RShiftVBNode(n1, n2, vt);
 220   case Op_RShiftVS: return new (C, 3) RShiftVSNode(n1, n2, vt);
 221   case Op_RShiftVI: return new (C, 3) RShiftVINode(n1, n2, vt);
 222   case Op_RShiftVL: return new (C, 3) RShiftVLNode(n1, n2, vt);
 223 
 224   case Op_URShiftVB: return new (C, 3) URShiftVBNode(n1, n2, vt);
 225   case Op_URShiftVS: return new (C, 3) URShiftVSNode(n1, n2, vt);
 226   case Op_URShiftVI: return new (C, 3) URShiftVINode(n1, n2, vt);
 227   case Op_URShiftVL: return new (C, 3) URShiftVLNode(n1, n2, vt);
 228 
 229   case Op_AndV: return new (C, 3) AndVNode(n1, n2, vt);
 230   case Op_OrV:  return new (C, 3) OrVNode (n1, n2, vt);
 231   case Op_XorV: return new (C, 3) XorVNode(n1, n2, vt);
 232   }
 233   ShouldNotReachHere();
 234   return NULL;
 235 
 236 }
 237 
 238 // Scalar promotion
 239 VectorNode* VectorNode::scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t) {
 240   BasicType bt = opd_t->array_element_basic_type();
 241   const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
 242                                           : TypeVect::make(bt, vlen);
 243   switch (bt) {
 244   case T_BOOLEAN:
 245   case T_BYTE:
 246     return new (C, 2) ReplicateBNode(s, vt);
 247   case T_CHAR:
 248   case T_SHORT:
 249     return new (C, 2) ReplicateSNode(s, vt);
 250   case T_INT:
 251     return new (C, 2) ReplicateINode(s, vt);
 252   case T_LONG:
 253     return new (C, 2) ReplicateLNode(s, vt);
 254   case T_FLOAT:
 255     return new (C, 2) ReplicateFNode(s, vt);
 256   case T_DOUBLE:
 257     return new (C, 2) ReplicateDNode(s, vt);
 258   }
 259   ShouldNotReachHere();
 260   return NULL;
 261 }
 262 
 263 // Return initial Pack node. Additional operands added with add_opd() calls.
 264 PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) {
 265   const TypeVect* vt = TypeVect::make(bt, vlen);
 266   switch (bt) {
 267   case T_BOOLEAN:
 268   case T_BYTE:
 269     return new (C, vlen+1) PackBNode(s, vt);
 270   case T_CHAR:
 271   case T_SHORT:
 272     return new (C, vlen+1) PackSNode(s, vt);
 273   case T_INT:
 274     return new (C, vlen+1) PackINode(s, vt);
 275   case T_LONG:
 276     return new (C, vlen+1) PackLNode(s, vt);
 277   case T_FLOAT:
 278     return new (C, vlen+1) PackFNode(s, vt);
 279   case T_DOUBLE:
 280     return new (C, vlen+1) PackDNode(s, vt);
 281   }
 282   ShouldNotReachHere();
 283   return NULL;
 284 }
 285 
 286 // Create a binary tree form for Packs. [lo, hi) (half-open) range
 287 Node* PackNode::binaryTreePack(Compile* C, int lo, int hi) {
 288   int ct = hi - lo;
 289   assert(is_power_of_2(ct), "power of 2");
 290   if (ct == 2) {
 291     PackNode* pk = PackNode::make(C, in(lo), 2, vect_type()->element_basic_type());
 292     pk->add_opd(1, in(lo+1));
 293     return pk;
 294 
 295   } else {
 296     int mid = lo + ct/2;
 297     Node* n1 = binaryTreePack(C, lo,  mid);
 298     Node* n2 = binaryTreePack(C, mid, hi );
 299 
 300     BasicType bt = vect_type()->element_basic_type();
 301     switch (bt) {
 302     case T_BOOLEAN:
 303     case T_BYTE:
 304       return new (C, 3) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2));
 305     case T_CHAR:
 306     case T_SHORT:
 307       return new (C, 3) PackINode(n1, n2, TypeVect::make(T_INT, 2));
 308     case T_INT:
 309       return new (C, 3) PackLNode(n1, n2, TypeVect::make(T_LONG, 2));
 310     case T_LONG:
 311       return new (C, 3) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2));
 312     case T_FLOAT:
 313       return new (C, 3) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
 314     case T_DOUBLE:
 315       return new (C, 3) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
 316     }
 317     ShouldNotReachHere();
 318   }
 319   return NULL;
 320 }
 321 
 322 // Return the vector version of a scalar load node.
 323 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
 324                                      Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) {
 325   const TypeVect* vt = TypeVect::make(bt, vlen);
 326   return new (C, 3) LoadVectorNode(ctl, mem, adr, atyp, vt);
 327   return NULL;
 328 }
 329 
 330 // Return the vector version of a scalar store node.
 331 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
 332                                        Node* adr, const TypePtr* atyp, Node* val,
 333                                        uint vlen) {
 334   return new (C, 4) StoreVectorNode(ctl, mem, adr, atyp, val);
 335 }
 336 
 337 // Extract a scalar element of vector.
 338 Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) {
 339   assert((int)position < Matcher::max_vector_size(bt), "pos in range");
 340   ConINode* pos = ConINode::make(C, (int)position);
 341   switch (bt) {
 342   case T_BOOLEAN:
 343     return new (C, 3) ExtractUBNode(v, pos);
 344   case T_BYTE:
 345     return new (C, 3) ExtractBNode(v, pos);
 346   case T_CHAR:
 347     return new (C, 3) ExtractCNode(v, pos);
 348   case T_SHORT:
 349     return new (C, 3) ExtractSNode(v, pos);
 350   case T_INT:
 351     return new (C, 3) ExtractINode(v, pos);
 352   case T_LONG:
 353     return new (C, 3) ExtractLNode(v, pos);
 354   case T_FLOAT:
 355     return new (C, 3) ExtractFNode(v, pos);
 356   case T_DOUBLE:
 357     return new (C, 3) ExtractDNode(v, pos);
 358   }
 359   ShouldNotReachHere();
 360   return NULL;
 361 }
 362