1 /*
2 * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #ifndef SHARE_VM_OPTO_VECTORNODE_HPP
25 #define SHARE_VM_OPTO_VECTORNODE_HPP
26
27 #include "opto/matcher.hpp"
28 #include "opto/memnode.hpp"
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
81 //------------------------------AddVINode---------------------------------------
82 // Vector add int
83 class AddVINode : public VectorNode {
84 public:
85 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
86 virtual int Opcode() const;
87 };
88
89 //------------------------------AddVLNode---------------------------------------
90 // Vector add long
91 class AddVLNode : public VectorNode {
92 public:
93 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
94 virtual int Opcode() const;
95 };
96
97 //------------------------------AddVFNode---------------------------------------
98 // Vector add float
99 class AddVFNode : public VectorNode {
100 public:
101 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
102 virtual int Opcode() const;
103 };
104
105 //------------------------------AddVDNode---------------------------------------
106 // Vector add double
107 class AddVDNode : public VectorNode {
108 public:
109 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
110 virtual int Opcode() const;
111 };
112
113 //------------------------------SubVBNode---------------------------------------
114 // Vector subtract byte
115 class SubVBNode : public VectorNode {
116 public:
117 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
118 virtual int Opcode() const;
119 };
120
121 //------------------------------SubVSNode---------------------------------------
122 // Vector subtract short
123 class SubVSNode : public VectorNode {
124 public:
125 SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
126 virtual int Opcode() const;
127 };
128
129 //------------------------------SubVINode---------------------------------------
130 // Vector subtract int
131 class SubVINode : public VectorNode {
132 public:
133 SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
134 virtual int Opcode() const;
135 };
136
137 //------------------------------SubVLNode---------------------------------------
138 // Vector subtract long
139 class SubVLNode : public VectorNode {
140 public:
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
279 virtual int Opcode() const;
280
281 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
282 virtual BasicType memory_type() const { return T_VOID; }
283 virtual int memory_size() const { return vect_type()->length_in_bytes(); }
284
285 virtual int store_Opcode() const { return Op_StoreVector; }
286
287 static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
288 Node* adr, const TypePtr* atyp, uint vlen, BasicType bt);
289 };
290
291 //------------------------------StoreVectorNode--------------------------------
292 // Store Vector to memory
293 class StoreVectorNode : public StoreNode {
294 public:
295 StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
296 : StoreNode(c, mem, adr, at, val) {
297 assert(val->is_Vector() || val->is_LoadVector(), "sanity");
298 init_class_id(Class_StoreVector);
299 }
300
301 const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
302 uint length() const { return vect_type()->length(); } // Vector length
303
304 virtual int Opcode() const;
305
306 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
307 virtual BasicType memory_type() const { return T_VOID; }
308 virtual int memory_size() const { return vect_type()->length_in_bytes(); }
309
310 static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
311 Node* adr, const TypePtr* atyp, Node* val,
312 uint vlen);
313 };
314
315
316 //=========================Promote_Scalar_to_Vector============================
317
318 //------------------------------ReplicateBNode---------------------------------
319 // Replicate byte scalar to be vector
320 class ReplicateBNode : public VectorNode {
321 public:
322 ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
323 virtual int Opcode() const;
324 };
325
326 //------------------------------ReplicateSNode---------------------------------
327 // Replicate short scalar to be vector
328 class ReplicateSNode : public VectorNode {
329 public:
330 ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
331 virtual int Opcode() const;
332 };
333
334 //------------------------------ReplicateINode---------------------------------
335 // Replicate int scalar to be vector
336 class ReplicateINode : public VectorNode {
337 public:
338 ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
339 virtual int Opcode() const;
340 };
341
342 //------------------------------ReplicateLNode---------------------------------
343 // Replicate long scalar to be vector
344 class ReplicateLNode : public VectorNode {
345 public:
346 ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
347 virtual int Opcode() const;
348 };
349
350 //------------------------------ReplicateFNode---------------------------------
351 // Replicate float scalar to be vector
352 class ReplicateFNode : public VectorNode {
353 public:
354 ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
355 virtual int Opcode() const;
356 };
357
358 //------------------------------ReplicateDNode---------------------------------
359 // Replicate double scalar to be vector
360 class ReplicateDNode : public VectorNode {
361 public:
362 ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
363 virtual int Opcode() const;
364 };
365
366 //========================Pack_Scalars_into_a_Vector===========================
367
368 //------------------------------PackNode---------------------------------------
369 // Pack parent class (not for code generation).
370 class PackNode : public VectorNode {
371 public:
372 PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
373 PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
374 virtual int Opcode() const;
375
376 void add_opd(uint i, Node* n) {
377 init_req(i+1, n);
378 }
379
380 // Create a binary tree form for Packs. [lo, hi) (half-open) range
381 Node* binaryTreePack(Compile* C, int lo, int hi);
382
383 static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);
384 };
385
386 //------------------------------PackBNode---------------------------------------
387 // Pack byte scalars into vector
388 class PackBNode : public PackNode {
389 public:
390 PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
391 virtual int Opcode() const;
392 };
393
394 //------------------------------PackSNode---------------------------------------
395 // Pack short scalars into a vector
396 class PackSNode : public PackNode {
397 public:
398 PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
399 PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
400 virtual int Opcode() const;
401 };
402
403 //------------------------------PackINode---------------------------------------
404 // Pack integer scalars into a vector
405 class PackINode : public PackNode {
406 public:
407 PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
408 PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
409 virtual int Opcode() const;
410 };
411
412 //------------------------------PackLNode---------------------------------------
413 // Pack long scalars into a vector
414 class PackLNode : public PackNode {
415 public:
416 PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
417 PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
418 virtual int Opcode() const;
419 };
420
421 //------------------------------Pack2LNode--------------------------------------
422 // Pack 2 long scalars into a vector
423 class Pack2LNode : public PackNode {
424 public:
425 Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
426 virtual int Opcode() const;
427 };
428
429 //------------------------------PackFNode---------------------------------------
430 // Pack float scalars into vector
431 class PackFNode : public PackNode {
432 public:
433 PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
434 PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
435 virtual int Opcode() const;
436 };
437
438 //------------------------------PackDNode---------------------------------------
439 // Pack double scalars into a vector
440 class PackDNode : public PackNode {
441 public:
442 PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
443 PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
444 virtual int Opcode() const;
445 };
446
447 //------------------------------Pack2DNode--------------------------------------
448 // Pack 2 double scalars into a vector
449 class Pack2DNode : public PackNode {
450 public:
451 Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
452 virtual int Opcode() const;
453 };
454
455
456 //========================Extract_Scalar_from_Vector===============================
457
458 //------------------------------ExtractNode---------------------------------------
459 // Extract a scalar from a vector at position "pos"
460 class ExtractNode : public Node {
461 public:
462 ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
463 assert(in(2)->get_int() >= 0, "positive constants");
464 }
465 virtual int Opcode() const;
466 uint pos() const { return in(2)->get_int(); }
467
468 static Node* make(Compile* C, Node* v, uint position, BasicType bt);
469 };
470
471 //------------------------------ExtractBNode---------------------------------------
472 // Extract a byte from a vector at position "pos"
473 class ExtractBNode : public ExtractNode {
474 public:
475 ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
476 virtual int Opcode() const;
477 virtual const Type *bottom_type() const { return TypeInt::INT; }
478 virtual uint ideal_reg() const { return Op_RegI; }
479 };
480
481 //------------------------------ExtractUBNode--------------------------------------
482 // Extract a boolean from a vector at position "pos"
483 class ExtractUBNode : public ExtractNode {
484 public:
485 ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
486 virtual int Opcode() const;
487 virtual const Type *bottom_type() const { return TypeInt::INT; }
488 virtual uint ideal_reg() const { return Op_RegI; }
489 };
490
491 //------------------------------ExtractCNode---------------------------------------
492 // Extract a char from a vector at position "pos"
493 class ExtractCNode : public ExtractNode {
494 public:
495 ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
496 virtual int Opcode() const;
497 virtual const Type *bottom_type() const { return TypeInt::INT; }
498 virtual uint ideal_reg() const { return Op_RegI; }
499 };
500
501 //------------------------------ExtractSNode---------------------------------------
502 // Extract a short from a vector at position "pos"
503 class ExtractSNode : public ExtractNode {
504 public:
505 ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
506 virtual int Opcode() const;
507 virtual const Type *bottom_type() const { return TypeInt::INT; }
508 virtual uint ideal_reg() const { return Op_RegI; }
509 };
510
511 //------------------------------ExtractINode---------------------------------------
512 // Extract an int from a vector at position "pos"
513 class ExtractINode : public ExtractNode {
514 public:
515 ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
516 virtual int Opcode() const;
517 virtual const Type *bottom_type() const { return TypeInt::INT; }
518 virtual uint ideal_reg() const { return Op_RegI; }
519 };
520
521 //------------------------------ExtractLNode---------------------------------------
522 // Extract a long from a vector at position "pos"
523 class ExtractLNode : public ExtractNode {
524 public:
525 ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
526 virtual int Opcode() const;
527 virtual const Type *bottom_type() const { return TypeLong::LONG; }
528 virtual uint ideal_reg() const { return Op_RegL; }
529 };
530
531 //------------------------------ExtractFNode---------------------------------------
532 // Extract a float from a vector at position "pos"
533 class ExtractFNode : public ExtractNode {
534 public:
535 ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
536 virtual int Opcode() const;
537 virtual const Type *bottom_type() const { return Type::FLOAT; }
538 virtual uint ideal_reg() const { return Op_RegF; }
539 };
540
541 //------------------------------ExtractDNode---------------------------------------
542 // Extract a double from a vector at position "pos"
543 class ExtractDNode : public ExtractNode {
544 public:
545 ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
546 virtual int Opcode() const;
547 virtual const Type *bottom_type() const { return Type::DOUBLE; }
548 virtual uint ideal_reg() const { return Op_RegD; }
549 };
550
551 #endif // SHARE_VM_OPTO_VECTORNODE_HPP