53 case Op_SubI:
54 switch (bt) {
55 case T_BOOLEAN:
56 case T_BYTE: return Op_SubVB;
57 case T_CHAR:
58 case T_SHORT: return Op_SubVS;
59 case T_INT: return Op_SubVI;
60 default: ShouldNotReachHere(); return 0;
61 }
62 case Op_SubL:
63 assert(bt == T_LONG, "must be");
64 return Op_SubVL;
65 case Op_SubF:
66 assert(bt == T_FLOAT, "must be");
67 return Op_SubVF;
68 case Op_SubD:
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 default: ShouldNotReachHere(); return 0;
79 }
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_CMoveF:
96 assert(bt == T_FLOAT, "must be");
97 return Op_CMoveVF;
98 case Op_CMoveD:
99 assert(bt == T_DOUBLE, "must be");
100 return Op_CMoveVD;
101 case Op_DivF:
102 assert(bt == T_FLOAT, "must be");
103 return Op_DivVF;
104 case Op_DivD:
105 assert(bt == T_DOUBLE, "must be");
106 return Op_DivVD;
107 case Op_AbsF:
108 assert(bt == T_FLOAT, "must be");
109 return Op_AbsVF;
110 case Op_AbsD:
111 assert(bt == T_DOUBLE, "must be");
112 return Op_AbsVD;
113 case Op_NegF:
114 assert(bt == T_FLOAT, "must be");
115 return Op_NegVF;
116 case Op_NegD:
117 assert(bt == T_DOUBLE, "must be");
118 return Op_NegVD;
119 case Op_SqrtF:
120 assert(bt == T_FLOAT, "must be");
121 return Op_SqrtVF;
122 case Op_SqrtD:
123 assert(bt == T_DOUBLE, "must be");
124 return Op_SqrtVD;
125 case Op_PopCountI:
126 if (bt == T_INT) {
333 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
334 const TypeVect* vt = TypeVect::make(bt, vlen);
335 int vopc = VectorNode::opcode(opc, bt);
336 // This method should not be called for unimplemented vectors.
337 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
338 switch (vopc) {
339 case Op_AddVB: return new AddVBNode(n1, n2, vt);
340 case Op_AddVS: return new AddVSNode(n1, n2, vt);
341 case Op_AddVI: return new AddVINode(n1, n2, vt);
342 case Op_AddVL: return new AddVLNode(n1, n2, vt);
343 case Op_AddVF: return new AddVFNode(n1, n2, vt);
344 case Op_AddVD: return new AddVDNode(n1, n2, vt);
345
346 case Op_SubVB: return new SubVBNode(n1, n2, vt);
347 case Op_SubVS: return new SubVSNode(n1, n2, vt);
348 case Op_SubVI: return new SubVINode(n1, n2, vt);
349 case Op_SubVL: return new SubVLNode(n1, n2, vt);
350 case Op_SubVF: return new SubVFNode(n1, n2, vt);
351 case Op_SubVD: return new SubVDNode(n1, n2, vt);
352
353 case Op_MulVS: return new MulVSNode(n1, n2, vt);
354 case Op_MulVI: return new MulVINode(n1, n2, vt);
355 case Op_MulVL: return new MulVLNode(n1, n2, vt);
356 case Op_MulVF: return new MulVFNode(n1, n2, vt);
357 case Op_MulVD: return new MulVDNode(n1, n2, vt);
358
359 case Op_DivVF: return new DivVFNode(n1, n2, vt);
360 case Op_DivVD: return new DivVDNode(n1, n2, vt);
361
362 case Op_AbsVF: return new AbsVFNode(n1, vt);
363 case Op_AbsVD: return new AbsVDNode(n1, vt);
364
365 case Op_NegVF: return new NegVFNode(n1, vt);
366 case Op_NegVD: return new NegVDNode(n1, vt);
367
368 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
369 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
370
371 case Op_PopCountVI: return new PopCountVINode(n1, vt);
372
373 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
374 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
375 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
376 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
377
378 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
379 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
380 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
381 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
|
53 case Op_SubI:
54 switch (bt) {
55 case T_BOOLEAN:
56 case T_BYTE: return Op_SubVB;
57 case T_CHAR:
58 case T_SHORT: return Op_SubVS;
59 case T_INT: return Op_SubVI;
60 default: ShouldNotReachHere(); return 0;
61 }
62 case Op_SubL:
63 assert(bt == T_LONG, "must be");
64 return Op_SubVL;
65 case Op_SubF:
66 assert(bt == T_FLOAT, "must be");
67 return Op_SubVF;
68 case Op_SubD:
69 assert(bt == T_DOUBLE, "must be");
70 return Op_SubVD;
71 case Op_MulI:
72 switch (bt) {
73 case T_BOOLEAN:return 0;
74 case T_BYTE: return Op_MulVB;
75 case T_CHAR:
76 case T_SHORT: return Op_MulVS;
77 case T_INT: return Op_MulVI;
78 default: ShouldNotReachHere(); return 0;
79 }
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_CMoveF:
96 assert(bt == T_FLOAT, "must be");
97 return Op_CMoveVF;
98 case Op_CMoveD:
99 assert(bt == T_DOUBLE, "must be");
100 return Op_CMoveVD;
101 case Op_DivF:
102 assert(bt == T_FLOAT, "must be");
103 return Op_DivVF;
104 case Op_DivD:
105 assert(bt == T_DOUBLE, "must be");
106 return Op_DivVD;
107 case Op_AbsI:
108 switch (bt) {
109 case T_BOOLEAN:
110 case T_CHAR: return 0; // abs does not make sense for unsigned
111 case T_BYTE: return Op_AbsVB;
112 case T_SHORT: return Op_AbsVS;
113 case T_INT: return Op_AbsVI;
114 default: ShouldNotReachHere(); return 0;
115 }
116 case Op_AbsL:
117 assert(bt == T_LONG, "must be");
118 return Op_AbsVL;
119 case Op_AbsF:
120 assert(bt == T_FLOAT, "must be");
121 return Op_AbsVF;
122 case Op_AbsD:
123 assert(bt == T_DOUBLE, "must be");
124 return Op_AbsVD;
125 case Op_NegF:
126 assert(bt == T_FLOAT, "must be");
127 return Op_NegVF;
128 case Op_NegD:
129 assert(bt == T_DOUBLE, "must be");
130 return Op_NegVD;
131 case Op_SqrtF:
132 assert(bt == T_FLOAT, "must be");
133 return Op_SqrtVF;
134 case Op_SqrtD:
135 assert(bt == T_DOUBLE, "must be");
136 return Op_SqrtVD;
137 case Op_PopCountI:
138 if (bt == T_INT) {
345 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
346 const TypeVect* vt = TypeVect::make(bt, vlen);
347 int vopc = VectorNode::opcode(opc, bt);
348 // This method should not be called for unimplemented vectors.
349 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
350 switch (vopc) {
351 case Op_AddVB: return new AddVBNode(n1, n2, vt);
352 case Op_AddVS: return new AddVSNode(n1, n2, vt);
353 case Op_AddVI: return new AddVINode(n1, n2, vt);
354 case Op_AddVL: return new AddVLNode(n1, n2, vt);
355 case Op_AddVF: return new AddVFNode(n1, n2, vt);
356 case Op_AddVD: return new AddVDNode(n1, n2, vt);
357
358 case Op_SubVB: return new SubVBNode(n1, n2, vt);
359 case Op_SubVS: return new SubVSNode(n1, n2, vt);
360 case Op_SubVI: return new SubVINode(n1, n2, vt);
361 case Op_SubVL: return new SubVLNode(n1, n2, vt);
362 case Op_SubVF: return new SubVFNode(n1, n2, vt);
363 case Op_SubVD: return new SubVDNode(n1, n2, vt);
364
365 case Op_MulVB: return new MulVBNode(n1, n2, vt);
366 case Op_MulVS: return new MulVSNode(n1, n2, vt);
367 case Op_MulVI: return new MulVINode(n1, n2, vt);
368 case Op_MulVL: return new MulVLNode(n1, n2, vt);
369 case Op_MulVF: return new MulVFNode(n1, n2, vt);
370 case Op_MulVD: return new MulVDNode(n1, n2, vt);
371
372 case Op_DivVF: return new DivVFNode(n1, n2, vt);
373 case Op_DivVD: return new DivVDNode(n1, n2, vt);
374
375 case Op_AbsVB: return new AbsVBNode(n1, vt);
376 case Op_AbsVS: return new AbsVSNode(n1, vt);
377 case Op_AbsVI: return new AbsVINode(n1, vt);
378 case Op_AbsVL: return new AbsVLNode(n1, vt);
379 case Op_AbsVF: return new AbsVFNode(n1, vt);
380 case Op_AbsVD: return new AbsVDNode(n1, vt);
381
382 case Op_NegVF: return new NegVFNode(n1, vt);
383 case Op_NegVD: return new NegVDNode(n1, vt);
384
385 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
386 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
387
388 case Op_PopCountVI: return new PopCountVINode(n1, vt);
389
390 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
391 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
392 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
393 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
394
395 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
396 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
397 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
398 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
|