29 #include "opto/node.hpp"
30 #include "opto/opcodes.hpp"
31
32 //------------------------------VectorNode--------------------------------------
33 // Vector Operation
34 class VectorNode : public TypeNode {
35 public:
36
37 VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
38 init_class_id(Class_Vector);
39 init_req(1, n1);
40 }
41 VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
42 init_class_id(Class_Vector);
43 init_req(1, n1);
44 init_req(2, n2);
45 }
46
47 const TypeVect* vect_type() const { return type()->is_vect(); }
48 uint length() const { return vect_type()->length(); } // Vector length
49
50 virtual int Opcode() const;
51
52 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
53
54 static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
55
56 static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
57
58 static int opcode(int opc, uint vlen, BasicType bt);
59 static bool implemented(int opc, uint vlen, BasicType bt);
60
61 };
62
63 //===========================Vector=ALU=Operations====================================
64
65 //------------------------------AddVBNode---------------------------------------
66 // Vector add byte
67 class AddVBNode : public VectorNode {
68 public:
69 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
70 virtual int Opcode() const;
71 };
72
73 //------------------------------AddVSNode---------------------------------------
74 // Vector add char/short
75 class AddVSNode : public VectorNode {
76 public:
77 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
78 virtual int Opcode() const;
79 };
80
141 SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
142 virtual int Opcode() const;
143 };
144
145 //------------------------------SubVFNode---------------------------------------
146 // Vector subtract float
147 class SubVFNode : public VectorNode {
148 public:
149 SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
150 virtual int Opcode() const;
151 };
152
153 //------------------------------SubVDNode---------------------------------------
154 // Vector subtract double
155 class SubVDNode : public VectorNode {
156 public:
157 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
158 virtual int Opcode() const;
159 };
160
161 //------------------------------MulVFNode---------------------------------------
162 // Vector multiply float
163 class MulVFNode : public VectorNode {
164 public:
165 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
166 virtual int Opcode() const;
167 };
168
169 //------------------------------MulVDNode---------------------------------------
170 // Vector multiply double
171 class MulVDNode : public VectorNode {
172 public:
173 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
174 virtual int Opcode() const;
175 };
176
177 //------------------------------DivVFNode---------------------------------------
178 // Vector divide float
179 class DivVFNode : public VectorNode {
180 public:
181 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
182 virtual int Opcode() const;
183 };
184
185 //------------------------------DivVDNode---------------------------------------
186 // Vector Divide double
187 class DivVDNode : public VectorNode {
188 public:
189 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
190 virtual int Opcode() const;
191 };
192
193 //------------------------------LShiftVBNode---------------------------------------
194 // Vector lshift byte
195 class LShiftVBNode : public VectorNode {
196 public:
197 LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
198 virtual int Opcode() const;
199 };
200
201 //------------------------------LShiftVSNode---------------------------------------
202 // Vector lshift shorts
203 class LShiftVSNode : public VectorNode {
204 public:
205 LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
206 virtual int Opcode() const;
207 };
208
209 //------------------------------LShiftVINode---------------------------------------
210 // Vector lshift ints
211 class LShiftVINode : public VectorNode {
212 public:
213 LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
214 virtual int Opcode() const;
215 };
216
217 //------------------------------URShiftVBNode---------------------------------------
218 // Vector urshift bytes
219 class RShiftVBNode : public VectorNode {
220 public:
221 RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
222 virtual int Opcode() const;
223 };
224
225 //------------------------------URShiftVSNode---------------------------------------
226 // Vector urshift shorts
227 class RShiftVSNode : public VectorNode {
228 public:
229 RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
230 virtual int Opcode() const;
231 };
232
233 //------------------------------URShiftVINode---------------------------------------
234 // Vector urshift ints
235 class RShiftVINode : public VectorNode {
236 public:
237 RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
238 virtual int Opcode() const;
239 };
240
241 //------------------------------AndVNode---------------------------------------
242 // Vector and
243 class AndVNode : public VectorNode {
244 public:
245 AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
246 virtual int Opcode() const;
247 };
248
249 //------------------------------OrVNode---------------------------------------
250 // Vector or
251 class OrVNode : public VectorNode {
252 public:
253 OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
254 virtual int Opcode() const;
255 };
256
257 //------------------------------XorVNode---------------------------------------
258 // Vector xor
259 class XorVNode : public VectorNode {
260 public:
261 XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
262 virtual int Opcode() const;
263 };
264
265 //================================= M E M O R Y ===============================
266
267 //------------------------------LoadVectorNode---------------------------------
268 // Load Vector from memory
269 class LoadVectorNode : public LoadNode {
270 public:
271 LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
272 : LoadNode(c, mem, adr, at, vt) {
273 init_class_id(Class_LoadVector);
274 }
275
276 const TypeVect* vect_type() const { return type()->is_vect(); }
277 uint length() const { return vect_type()->length(); } // Vector length
278
|
29 #include "opto/node.hpp"
30 #include "opto/opcodes.hpp"
31
32 //------------------------------VectorNode--------------------------------------
33 // Vector Operation
34 class VectorNode : public TypeNode {
35 public:
36
37 VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
38 init_class_id(Class_Vector);
39 init_req(1, n1);
40 }
41 VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
42 init_class_id(Class_Vector);
43 init_req(1, n1);
44 init_req(2, n2);
45 }
46
47 const TypeVect* vect_type() const { return type()->is_vect(); }
48 uint length() const { return vect_type()->length(); } // Vector length
49 uint length_in_bytes() const { return vect_type()->length_in_bytes(); }
50
51 virtual int Opcode() const;
52
53 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
54
55 static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
56
57 static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
58
59 static int opcode(int opc, uint vlen, BasicType bt);
60 static bool implemented(int opc, uint vlen, BasicType bt);
61 static bool needs_vector_input(Node* n, int opd_idx);
62 };
63
64 //===========================Vector=ALU=Operations====================================
65
66 //------------------------------AddVBNode---------------------------------------
67 // Vector add byte
68 class AddVBNode : public VectorNode {
69 public:
70 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
71 virtual int Opcode() const;
72 };
73
74 //------------------------------AddVSNode---------------------------------------
75 // Vector add char/short
76 class AddVSNode : public VectorNode {
77 public:
78 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
79 virtual int Opcode() const;
80 };
81
142 SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
143 virtual int Opcode() const;
144 };
145
146 //------------------------------SubVFNode---------------------------------------
147 // Vector subtract float
148 class SubVFNode : public VectorNode {
149 public:
150 SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
151 virtual int Opcode() const;
152 };
153
154 //------------------------------SubVDNode---------------------------------------
155 // Vector subtract double
156 class SubVDNode : public VectorNode {
157 public:
158 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
159 virtual int Opcode() const;
160 };
161
162 //------------------------------MulVSNode---------------------------------------
163 // Vector multiply short
164 class MulVSNode : public VectorNode {
165 public:
166 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
167 virtual int Opcode() const;
168 };
169
170 //------------------------------MulVINode---------------------------------------
171 // Vector multiply int
172 class MulVINode : public VectorNode {
173 public:
174 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
175 virtual int Opcode() const;
176 };
177
178 //------------------------------MulVFNode---------------------------------------
179 // Vector multiply float
180 class MulVFNode : public VectorNode {
181 public:
182 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
183 virtual int Opcode() const;
184 };
185
186 //------------------------------MulVDNode---------------------------------------
187 // Vector multiply double
188 class MulVDNode : public VectorNode {
189 public:
190 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
191 virtual int Opcode() const;
192 };
193
194 //------------------------------DivVFNode---------------------------------------
195 // Vector divide float
196 class DivVFNode : public VectorNode {
197 public:
198 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
199 virtual int Opcode() const;
200 };
201
202 //------------------------------DivVDNode---------------------------------------
203 // Vector Divide double
204 class DivVDNode : public VectorNode {
205 public:
206 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
207 virtual int Opcode() const;
208 };
209
210 //------------------------------LShiftVBNode---------------------------------------
211 // Vector left shift bytes
212 class LShiftVBNode : public VectorNode {
213 public:
214 LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
215 virtual int Opcode() const;
216 };
217
218 //------------------------------LShiftVSNode---------------------------------------
219 // Vector left shift shorts
220 class LShiftVSNode : public VectorNode {
221 public:
222 LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
223 virtual int Opcode() const;
224 };
225
226 //------------------------------LShiftVINode---------------------------------------
227 // Vector left shift ints
228 class LShiftVINode : public VectorNode {
229 public:
230 LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
231 virtual int Opcode() const;
232 };
233
234 //------------------------------LShiftVLNode---------------------------------------
235 // Vector left shift longs
236 class LShiftVLNode : public VectorNode {
237 public:
238 LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
239 virtual int Opcode() const;
240 };
241
242 //------------------------------RShiftVBNode---------------------------------------
243 // Vector right arithmetic (signed) shift bytes
244 class RShiftVBNode : public VectorNode {
245 public:
246 RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
247 virtual int Opcode() const;
248 };
249
250 //------------------------------RShiftVSNode---------------------------------------
251 // Vector right arithmetic (signed) shift shorts
252 class RShiftVSNode : public VectorNode {
253 public:
254 RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
255 virtual int Opcode() const;
256 };
257
258 //------------------------------RShiftVINode---------------------------------------
259 // Vector right arithmetic (signed) shift ints
260 class RShiftVINode : public VectorNode {
261 public:
262 RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
263 virtual int Opcode() const;
264 };
265
266 //------------------------------RShiftVLNode---------------------------------------
267 // Vector right arithmetic (signed) shift longs
268 class RShiftVLNode : public VectorNode {
269 public:
270 RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
271 virtual int Opcode() const;
272 };
273
274 //------------------------------URShiftVBNode---------------------------------------
275 // Vector right logical (unsigned) shift bytes
276 class URShiftVBNode : public VectorNode {
277 public:
278 URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
279 virtual int Opcode() const;
280 };
281
282 //------------------------------URShiftVSNode---------------------------------------
283 // Vector right logical (unsigned) shift shorts
284 class URShiftVSNode : public VectorNode {
285 public:
286 URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
287 virtual int Opcode() const;
288 };
289
290 //------------------------------URShiftVINode---------------------------------------
291 // Vector right logical (unsigned) shift ints
292 class URShiftVINode : public VectorNode {
293 public:
294 URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
295 virtual int Opcode() const;
296 };
297
298 //------------------------------URShiftVLNode---------------------------------------
299 // Vector right logical (unsigned) shift longs
300 class URShiftVLNode : public VectorNode {
301 public:
302 URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
303 virtual int Opcode() const;
304 };
305
306
307 //------------------------------AndVNode---------------------------------------
308 // Vector and integer
309 class AndVNode : public VectorNode {
310 public:
311 AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
312 virtual int Opcode() const;
313 };
314
315 //------------------------------OrVNode---------------------------------------
316 // Vector or integer
317 class OrVNode : public VectorNode {
318 public:
319 OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
320 virtual int Opcode() const;
321 };
322
323 //------------------------------XorVNode---------------------------------------
324 // Vector xor integer
325 class XorVNode : public VectorNode {
326 public:
327 XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
328 virtual int Opcode() const;
329 };
330
331 //================================= M E M O R Y ===============================
332
333 //------------------------------LoadVectorNode---------------------------------
334 // Load Vector from memory
335 class LoadVectorNode : public LoadNode {
336 public:
337 LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
338 : LoadNode(c, mem, adr, at, vt) {
339 init_class_id(Class_LoadVector);
340 }
341
342 const TypeVect* vect_type() const { return type()->is_vect(); }
343 uint length() const { return vect_type()->length(); } // Vector length
344
|