73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
74 virtual int Opcode() const;
75 };
76
77 //------------------------------AddVSNode--------------------------------------
78 // Vector add char/short
79 class AddVSNode : public VectorNode {
80 public:
81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
82 virtual int Opcode() const;
83 };
84
85 //------------------------------AddVINode--------------------------------------
86 // Vector add int
87 class AddVINode : public VectorNode {
88 public:
89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
90 virtual int Opcode() const;
91 };
92
93 //------------------------------AddVLNode--------------------------------------
94 // Vector add long
95 class AddVLNode : public VectorNode {
96 public:
97 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
98 virtual int Opcode() const;
99 };
100
101 //------------------------------AddVFNode--------------------------------------
102 // Vector add float
103 class AddVFNode : public VectorNode {
104 public:
105 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
106 virtual int Opcode() const;
107 };
108
109 //------------------------------AddVDNode--------------------------------------
110 // Vector add double
111 class AddVDNode : public VectorNode {
112 public:
113 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
114 virtual int Opcode() const;
115 };
116
117 //------------------------------SubVBNode--------------------------------------
118 // Vector subtract byte
119 class SubVBNode : public VectorNode {
120 public:
121 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
122 virtual int Opcode() const;
123 };
124
125 //------------------------------SubVSNode--------------------------------------
126 // Vector subtract short
127 class SubVSNode : public VectorNode {
128 public:
129 SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
130 virtual int Opcode() const;
131 };
132
133 //------------------------------SubVINode--------------------------------------
134 // Vector subtract int
135 class SubVINode : public VectorNode {
136 public:
161 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
162 virtual int Opcode() const;
163 };
164
165 //------------------------------MulVSNode--------------------------------------
166 // Vector multiply short
167 class MulVSNode : public VectorNode {
168 public:
169 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
170 virtual int Opcode() const;
171 };
172
173 //------------------------------MulVINode--------------------------------------
174 // Vector multiply int
175 class MulVINode : public VectorNode {
176 public:
177 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
178 virtual int Opcode() const;
179 };
180
181 //------------------------------MulVFNode--------------------------------------
182 // Vector multiply float
183 class MulVFNode : public VectorNode {
184 public:
185 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
186 virtual int Opcode() const;
187 };
188
189 //------------------------------MulVDNode--------------------------------------
190 // Vector multiply double
191 class MulVDNode : public VectorNode {
192 public:
193 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
194 virtual int Opcode() const;
195 };
196
197 //------------------------------DivVFNode--------------------------------------
198 // Vector divide float
199 class DivVFNode : public VectorNode {
200 public:
201 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
202 virtual int Opcode() const;
203 };
204
205 //------------------------------DivVDNode--------------------------------------
206 // Vector Divide double
207 class DivVDNode : public VectorNode {
208 public:
209 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
210 virtual int Opcode() const;
211 };
212
213 //------------------------------LShiftVBNode-----------------------------------
214 // Vector left shift bytes
|
73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
74 virtual int Opcode() const;
75 };
76
77 //------------------------------AddVSNode--------------------------------------
78 // Vector add char/short
79 class AddVSNode : public VectorNode {
80 public:
81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
82 virtual int Opcode() const;
83 };
84
85 //------------------------------AddVINode--------------------------------------
86 // Vector add int
87 class AddVINode : public VectorNode {
88 public:
89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
90 virtual int Opcode() const;
91 };
92
93 //------------------------------ReductionNode------------------------------------
94 // Perform reduction of a vector
95 class ReductionNode : public Node {
96 public:
97 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}
98
99 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);
100 static int opcode(int opc, BasicType bt);
101 static bool implemented(int opc, uint vlen, BasicType bt);
102 };
103
104 //------------------------------AddReductionVINode--------------------------------------
105 // Vector add int as a reduction
106 class AddReductionVINode : public ReductionNode {
107 public:
108 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
109 virtual int Opcode() const;
110 virtual const Type* bottom_type() const { return TypeInt::INT; }
111 virtual uint ideal_reg() const { return Op_RegI; }
112 };
113
114 //------------------------------AddReductionVLNode--------------------------------------
115 // Vector add long as a reduction
116 class AddReductionVLNode : public ReductionNode {
117 public:
118 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
119 virtual int Opcode() const;
120 virtual const Type* bottom_type() const { return TypeLong::LONG; }
121 virtual uint ideal_reg() const { return Op_RegL; }
122 };
123
124 //------------------------------AddVLNode--------------------------------------
125 // Vector add long
126 class AddVLNode : public VectorNode {
127 public:
128 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
129 virtual int Opcode() const;
130 };
131
132 //------------------------------AddVFNode--------------------------------------
133 // Vector add float
134 class AddVFNode : public VectorNode {
135 public:
136 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
137 virtual int Opcode() const;
138 };
139
140 //------------------------------AddReductionVFNode--------------------------------------
141 // Vector add float as a reduction
142 class AddReductionVFNode : public ReductionNode {
143 public:
144 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
145 virtual int Opcode() const;
146 virtual const Type* bottom_type() const { return Type::FLOAT; }
147 virtual uint ideal_reg() const { return Op_RegF; }
148 };
149
150 //------------------------------AddVDNode--------------------------------------
151 // Vector add double
152 class AddVDNode : public VectorNode {
153 public:
154 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
155 virtual int Opcode() const;
156 };
157
158 //------------------------------AddReductionVDNode--------------------------------------
159 // Vector add double as a reduction
160 class AddReductionVDNode : public ReductionNode {
161 public:
162 AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
163 virtual int Opcode() const;
164 virtual const Type* bottom_type() const { return Type::DOUBLE; }
165 virtual uint ideal_reg() const { return Op_RegD; }
166 };
167
168 //------------------------------SubVBNode--------------------------------------
169 // Vector subtract byte
170 class SubVBNode : public VectorNode {
171 public:
172 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
173 virtual int Opcode() const;
174 };
175
176 //------------------------------SubVSNode--------------------------------------
177 // Vector subtract short
178 class SubVSNode : public VectorNode {
179 public:
180 SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
181 virtual int Opcode() const;
182 };
183
184 //------------------------------SubVINode--------------------------------------
185 // Vector subtract int
186 class SubVINode : public VectorNode {
187 public:
212 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
213 virtual int Opcode() const;
214 };
215
216 //------------------------------MulVSNode--------------------------------------
217 // Vector multiply short
218 class MulVSNode : public VectorNode {
219 public:
220 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
221 virtual int Opcode() const;
222 };
223
224 //------------------------------MulVINode--------------------------------------
225 // Vector multiply int
226 class MulVINode : public VectorNode {
227 public:
228 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
229 virtual int Opcode() const;
230 };
231
232 //------------------------------MulReductionVINode--------------------------------------
233 // Vector multiply int as a reduction
234 class MulReductionVINode : public ReductionNode {
235 public:
236 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
237 virtual int Opcode() const;
238 virtual const Type* bottom_type() const { return TypeInt::INT; }
239 virtual uint ideal_reg() const { return Op_RegI; }
240 };
241
242 //------------------------------MulVFNode--------------------------------------
243 // Vector multiply float
244 class MulVFNode : public VectorNode {
245 public:
246 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
247 virtual int Opcode() const;
248 };
249
250 //------------------------------MulReductionVFNode--------------------------------------
251 // Vector multiply float as a reduction
252 class MulReductionVFNode : public ReductionNode {
253 public:
254 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
255 virtual int Opcode() const;
256 virtual const Type* bottom_type() const { return Type::FLOAT; }
257 virtual uint ideal_reg() const { return Op_RegF; }
258 };
259
260 //------------------------------MulVDNode--------------------------------------
261 // Vector multiply double
262 class MulVDNode : public VectorNode {
263 public:
264 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
265 virtual int Opcode() const;
266 };
267
268 //------------------------------MulReductionVDNode--------------------------------------
269 // Vector multiply double as a reduction
270 class MulReductionVDNode : public ReductionNode {
271 public:
272 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
273 virtual int Opcode() const;
274 virtual const Type* bottom_type() const { return Type::DOUBLE; }
275 virtual uint ideal_reg() const { return Op_RegD; }
276 };
277
278 //------------------------------DivVFNode--------------------------------------
279 // Vector divide float
280 class DivVFNode : public VectorNode {
281 public:
282 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
283 virtual int Opcode() const;
284 };
285
286 //------------------------------DivVDNode--------------------------------------
287 // Vector Divide double
288 class DivVDNode : public VectorNode {
289 public:
290 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
291 virtual int Opcode() const;
292 };
293
294 //------------------------------LShiftVBNode-----------------------------------
295 // Vector left shift bytes
|