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 is_shift(Node* n);
62 static bool is_invariant_vector(Node* n);
63 };
64
65 //===========================Vector=ALU=Operations====================================
66
67 //------------------------------AddVBNode---------------------------------------
68 // Vector add byte
69 class AddVBNode : public VectorNode {
70 public:
71 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
72 virtual int Opcode() const;
73 };
74
75 //------------------------------AddVSNode---------------------------------------
76 // Vector add char/short
77 class AddVSNode : public VectorNode {
78 public:
79 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
80 virtual int Opcode() const;
81 };
82
143 SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
144 virtual int Opcode() const;
145 };
146
147 //------------------------------SubVFNode---------------------------------------
148 // Vector subtract float
149 class SubVFNode : public VectorNode {
150 public:
151 SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
152 virtual int Opcode() const;
153 };
154
155 //------------------------------SubVDNode---------------------------------------
156 // Vector subtract double
157 class SubVDNode : public VectorNode {
158 public:
159 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
160 virtual int Opcode() const;
161 };
162
163 //------------------------------MulVSNode---------------------------------------
164 // Vector multiply short
165 class MulVSNode : public VectorNode {
166 public:
167 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
168 virtual int Opcode() const;
169 };
170
171 //------------------------------MulVINode---------------------------------------
172 // Vector multiply int
173 class MulVINode : public VectorNode {
174 public:
175 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
176 virtual int Opcode() const;
177 };
178
179 //------------------------------MulVFNode---------------------------------------
180 // Vector multiply float
181 class MulVFNode : public VectorNode {
182 public:
183 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
184 virtual int Opcode() const;
185 };
186
187 //------------------------------MulVDNode---------------------------------------
188 // Vector multiply double
189 class MulVDNode : public VectorNode {
190 public:
191 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
192 virtual int Opcode() const;
193 };
194
195 //------------------------------DivVFNode---------------------------------------
196 // Vector divide float
197 class DivVFNode : public VectorNode {
198 public:
199 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
200 virtual int Opcode() const;
201 };
202
203 //------------------------------DivVDNode---------------------------------------
204 // Vector Divide double
205 class DivVDNode : public VectorNode {
206 public:
207 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
208 virtual int Opcode() const;
209 };
210
211 //------------------------------LShiftVBNode---------------------------------------
212 // Vector left shift bytes
213 class LShiftVBNode : public VectorNode {
214 public:
215 LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
216 virtual int Opcode() const;
217 };
218
219 //------------------------------LShiftVSNode---------------------------------------
220 // Vector left shift shorts
221 class LShiftVSNode : public VectorNode {
222 public:
223 LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
224 virtual int Opcode() const;
225 };
226
227 //------------------------------LShiftVINode---------------------------------------
228 // Vector left shift ints
229 class LShiftVINode : public VectorNode {
230 public:
231 LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
232 virtual int Opcode() const;
233 };
234
235 //------------------------------LShiftVLNode---------------------------------------
236 // Vector left shift longs
237 class LShiftVLNode : public VectorNode {
238 public:
239 LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
240 virtual int Opcode() const;
241 };
242
243 //------------------------------RShiftVBNode---------------------------------------
244 // Vector right arithmetic (signed) shift bytes
245 class RShiftVBNode : public VectorNode {
246 public:
247 RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
248 virtual int Opcode() const;
249 };
250
251 //------------------------------RShiftVSNode---------------------------------------
252 // Vector right arithmetic (signed) shift shorts
253 class RShiftVSNode : public VectorNode {
254 public:
255 RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
256 virtual int Opcode() const;
257 };
258
259 //------------------------------RShiftVINode---------------------------------------
260 // Vector right arithmetic (signed) shift ints
261 class RShiftVINode : public VectorNode {
262 public:
263 RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
264 virtual int Opcode() const;
265 };
266
267 //------------------------------RShiftVLNode---------------------------------------
268 // Vector right arithmetic (signed) shift longs
269 class RShiftVLNode : public VectorNode {
270 public:
271 RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
272 virtual int Opcode() const;
273 };
274
275 //------------------------------URShiftVBNode---------------------------------------
276 // Vector right logical (unsigned) shift bytes
277 class URShiftVBNode : public VectorNode {
278 public:
279 URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
280 virtual int Opcode() const;
281 };
282
283 //------------------------------URShiftVSNode---------------------------------------
284 // Vector right logical (unsigned) shift shorts
285 class URShiftVSNode : public VectorNode {
286 public:
287 URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
288 virtual int Opcode() const;
289 };
290
291 //------------------------------URShiftVINode---------------------------------------
292 // Vector right logical (unsigned) shift ints
293 class URShiftVINode : public VectorNode {
294 public:
295 URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
296 virtual int Opcode() const;
297 };
298
299 //------------------------------URShiftVLNode---------------------------------------
300 // Vector right logical (unsigned) shift longs
301 class URShiftVLNode : public VectorNode {
302 public:
303 URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
304 virtual int Opcode() const;
305 };
306
307
308 //------------------------------AndVNode---------------------------------------
309 // Vector and integer
310 class AndVNode : public VectorNode {
311 public:
312 AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
313 virtual int Opcode() const;
314 };
315
316 //------------------------------OrVNode---------------------------------------
317 // Vector or integer
318 class OrVNode : public VectorNode {
319 public:
320 OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
321 virtual int Opcode() const;
322 };
323
324 //------------------------------XorVNode---------------------------------------
325 // Vector xor integer
326 class XorVNode : public VectorNode {
327 public:
328 XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
329 virtual int Opcode() const;
330 };
331
332 //================================= M E M O R Y ===============================
333
334 //------------------------------LoadVectorNode---------------------------------
335 // Load Vector from memory
336 class LoadVectorNode : public LoadNode {
337 public:
338 LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
339 : LoadNode(c, mem, adr, at, vt) {
340 init_class_id(Class_LoadVector);
341 }
342
343 const TypeVect* vect_type() const { return type()->is_vect(); }
344 uint length() const { return vect_type()->length(); } // Vector length
345
|