69 assert(bt == T_DOUBLE, "must be");
70 return Op_SubVD;
71 case Op_MulI:
72 switch (bt) {
73 case T_BOOLEAN:
74 case T_BYTE: return 0; // Unimplemented
75 case T_CHAR:
76 case T_SHORT: return Op_MulVS;
77 case T_INT: return Op_MulVI;
78 }
79 ShouldNotReachHere();
80 case Op_MulL:
81 assert(bt == T_LONG, "must be");
82 return Op_MulVL;
83 case Op_MulF:
84 assert(bt == T_FLOAT, "must be");
85 return Op_MulVF;
86 case Op_MulD:
87 assert(bt == T_DOUBLE, "must be");
88 return Op_MulVD;
89 case Op_CMoveD:
90 assert(bt == T_DOUBLE, "must be");
91 return Op_CMoveVD;
92 case Op_DivF:
93 assert(bt == T_FLOAT, "must be");
94 return Op_DivVF;
95 case Op_DivD:
96 assert(bt == T_DOUBLE, "must be");
97 return Op_DivVD;
98 case Op_AbsF:
99 assert(bt == T_FLOAT, "must be");
100 return Op_AbsVF;
101 case Op_AbsD:
102 assert(bt == T_DOUBLE, "must be");
103 return Op_AbsVD;
104 case Op_NegF:
105 assert(bt == T_FLOAT, "must be");
106 return Op_NegVF;
107 case Op_NegD:
108 assert(bt == T_DOUBLE, "must be");
242 case Op_LShiftI: case Op_LShiftL:
243 case Op_RShiftI: case Op_RShiftL:
244 case Op_URShiftI: case Op_URShiftL:
245 *start = 1;
246 *end = 2; // 1 vector operand
247 break;
248 case Op_AddI: case Op_AddL: case Op_AddF: case Op_AddD:
249 case Op_SubI: case Op_SubL: case Op_SubF: case Op_SubD:
250 case Op_MulI: case Op_MulL: case Op_MulF: case Op_MulD:
251 case Op_DivF: case Op_DivD:
252 case Op_AndI: case Op_AndL:
253 case Op_OrI: case Op_OrL:
254 case Op_XorI: case Op_XorL:
255 *start = 1;
256 *end = 3; // 2 vector operands
257 break;
258 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
259 *start = 2;
260 *end = n->req();
261 break;
262 default:
263 *start = 1;
264 *end = n->req(); // default is all operands
265 }
266 }
267
268 // Return the vector version of a scalar operation node.
269 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
270 const TypeVect* vt = TypeVect::make(bt, vlen);
271 int vopc = VectorNode::opcode(opc, bt);
272 // This method should not be called for unimplemented vectors.
273 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
274 switch (vopc) {
275 case Op_AddVB: return new AddVBNode(n1, n2, vt);
276 case Op_AddVS: return new AddVSNode(n1, n2, vt);
277 case Op_AddVI: return new AddVINode(n1, n2, vt);
278 case Op_AddVL: return new AddVLNode(n1, n2, vt);
279 case Op_AddVF: return new AddVFNode(n1, n2, vt);
280 case Op_AddVD: return new AddVDNode(n1, n2, vt);
281
309 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
310 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
311
312 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
313 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
314 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
315 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
316
317 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
318 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
319 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
320 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
321
322 case Op_AndV: return new AndVNode(n1, n2, vt);
323 case Op_OrV: return new OrVNode (n1, n2, vt);
324 case Op_XorV: return new XorVNode(n1, n2, vt);
325 }
326 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
327 return NULL;
328
329 }
330
331 // Scalar promotion
332 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
333 BasicType bt = opd_t->array_element_basic_type();
334 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
335 : TypeVect::make(bt, vlen);
336 switch (bt) {
337 case T_BOOLEAN:
338 case T_BYTE:
339 return new ReplicateBNode(s, vt);
340 case T_CHAR:
341 case T_SHORT:
342 return new ReplicateSNode(s, vt);
343 case T_INT:
344 return new ReplicateINode(s, vt);
345 case T_LONG:
346 return new ReplicateLNode(s, vt);
347 case T_FLOAT:
348 return new ReplicateFNode(s, vt);
|
69 assert(bt == T_DOUBLE, "must be");
70 return Op_SubVD;
71 case Op_MulI:
72 switch (bt) {
73 case T_BOOLEAN:
74 case T_BYTE: return 0; // Unimplemented
75 case T_CHAR:
76 case T_SHORT: return Op_MulVS;
77 case T_INT: return Op_MulVI;
78 }
79 ShouldNotReachHere();
80 case Op_MulL:
81 assert(bt == T_LONG, "must be");
82 return Op_MulVL;
83 case Op_MulF:
84 assert(bt == T_FLOAT, "must be");
85 return Op_MulVF;
86 case Op_MulD:
87 assert(bt == T_DOUBLE, "must be");
88 return Op_MulVD;
89 case Op_FmaD:
90 assert(bt == T_DOUBLE, "must be");
91 return Op_FmaVD;
92 case Op_FmaF:
93 assert(bt == T_FLOAT, "must be");
94 return Op_FmaVF;
95 case Op_CMoveD:
96 assert(bt == T_DOUBLE, "must be");
97 return Op_CMoveVD;
98 case Op_DivF:
99 assert(bt == T_FLOAT, "must be");
100 return Op_DivVF;
101 case Op_DivD:
102 assert(bt == T_DOUBLE, "must be");
103 return Op_DivVD;
104 case Op_AbsF:
105 assert(bt == T_FLOAT, "must be");
106 return Op_AbsVF;
107 case Op_AbsD:
108 assert(bt == T_DOUBLE, "must be");
109 return Op_AbsVD;
110 case Op_NegF:
111 assert(bt == T_FLOAT, "must be");
112 return Op_NegVF;
113 case Op_NegD:
114 assert(bt == T_DOUBLE, "must be");
248 case Op_LShiftI: case Op_LShiftL:
249 case Op_RShiftI: case Op_RShiftL:
250 case Op_URShiftI: case Op_URShiftL:
251 *start = 1;
252 *end = 2; // 1 vector operand
253 break;
254 case Op_AddI: case Op_AddL: case Op_AddF: case Op_AddD:
255 case Op_SubI: case Op_SubL: case Op_SubF: case Op_SubD:
256 case Op_MulI: case Op_MulL: case Op_MulF: case Op_MulD:
257 case Op_DivF: case Op_DivD:
258 case Op_AndI: case Op_AndL:
259 case Op_OrI: case Op_OrL:
260 case Op_XorI: case Op_XorL:
261 *start = 1;
262 *end = 3; // 2 vector operands
263 break;
264 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
265 *start = 2;
266 *end = n->req();
267 break;
268 case Op_FmaD:
269 case Op_FmaF:
270 *start = 1;
271 *end = 4; // 3 vector operands
272 break;
273 default:
274 *start = 1;
275 *end = n->req(); // default is all operands
276 }
277 }
278
279 // Return the vector version of a scalar operation node.
280 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
281 const TypeVect* vt = TypeVect::make(bt, vlen);
282 int vopc = VectorNode::opcode(opc, bt);
283 // This method should not be called for unimplemented vectors.
284 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
285 switch (vopc) {
286 case Op_AddVB: return new AddVBNode(n1, n2, vt);
287 case Op_AddVS: return new AddVSNode(n1, n2, vt);
288 case Op_AddVI: return new AddVINode(n1, n2, vt);
289 case Op_AddVL: return new AddVLNode(n1, n2, vt);
290 case Op_AddVF: return new AddVFNode(n1, n2, vt);
291 case Op_AddVD: return new AddVDNode(n1, n2, vt);
292
320 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
321 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
322
323 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
324 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
325 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
326 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
327
328 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
329 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
330 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
331 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
332
333 case Op_AndV: return new AndVNode(n1, n2, vt);
334 case Op_OrV: return new OrVNode (n1, n2, vt);
335 case Op_XorV: return new XorVNode(n1, n2, vt);
336 }
337 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
338 return NULL;
339
340 }
341
342 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, Node* n3, uint vlen, BasicType bt) {
343 const TypeVect* vt = TypeVect::make(bt, vlen);
344 int vopc = VectorNode::opcode(opc, bt);
345 // This method should not be called for unimplemented vectors.
346 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
347 switch (vopc) {
348 case Op_FmaVD: return new FmaVDNode(n1, n2, n3, vt);
349 case Op_FmaVF: return new FmaVFNode(n1, n2, n3, vt);
350 }
351 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
352 return NULL;
353 }
354
355 // Scalar promotion
356 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
357 BasicType bt = opd_t->array_element_basic_type();
358 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
359 : TypeVect::make(bt, vlen);
360 switch (bt) {
361 case T_BOOLEAN:
362 case T_BYTE:
363 return new ReplicateBNode(s, vt);
364 case T_CHAR:
365 case T_SHORT:
366 return new ReplicateSNode(s, vt);
367 case T_INT:
368 return new ReplicateINode(s, vt);
369 case T_LONG:
370 return new ReplicateLNode(s, vt);
371 case T_FLOAT:
372 return new ReplicateFNode(s, vt);
|