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
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
|
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 //------------------------------ReductionNode------------------------------------
118 // Perform reduction of a vector
119 class ReductionNode : public Node {
120 public:
121 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}
122
123 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);
124 static int opcode(int opc, BasicType bt);
125 static bool implemented(int opc, uint vlen, BasicType bt);
126 };
127
128 //------------------------------AddReductionVINode--------------------------------------
129 // Vector add int as a reduction
130 class AddReductionVINode : public ReductionNode {
131 public:
132 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
133 virtual int Opcode() const;
134 virtual const Type* bottom_type() const { return TypeInt::INT; }
135 virtual uint ideal_reg() const { return Op_RegI; }
136 };
137
138 //------------------------------AddReductionVLNode--------------------------------------
139 // Vector add long as a reduction
140 class AddReductionVLNode : public ReductionNode {
141 public:
142 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
143 virtual int Opcode() const;
144 virtual const Type* bottom_type() const { return TypeLong::LONG; }
145 virtual uint ideal_reg() const { return Op_RegL; }
146 };
147
148 //------------------------------AddReductionVFNode--------------------------------------
149 // Vector add float as a reduction
150 class AddReductionVFNode : public ReductionNode {
151 public:
152 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
153 virtual int Opcode() const;
154 virtual const Type* bottom_type() const { return Type::FLOAT; }
155 virtual uint ideal_reg() const { return Op_RegF; }
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
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 //------------------------------MulVLNode--------------------------------------
233 // Vector multiply long
234 class MulVLNode : public VectorNode {
235 public:
236 MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
237 virtual int Opcode() const;
238 };
239
240 //------------------------------MulVFNode--------------------------------------
241 // Vector multiply float
242 class MulVFNode : public VectorNode {
243 public:
244 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
245 virtual int Opcode() const;
246 };
247
248 //------------------------------MulVDNode--------------------------------------
249 // Vector multiply double
250 class MulVDNode : public VectorNode {
251 public:
252 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
253 virtual int Opcode() const;
254 };
255
256 //------------------------------MulReductionVINode--------------------------------------
257 // Vector multiply int as a reduction
258 class MulReductionVINode : public ReductionNode {
259 public:
260 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
261 virtual int Opcode() const;
262 virtual const Type* bottom_type() const { return TypeInt::INT; }
263 virtual uint ideal_reg() const { return Op_RegI; }
264 };
265
266 //------------------------------MulReductionVLNode--------------------------------------
267 // Vector multiply int as a reduction
268 class MulReductionVLNode : public ReductionNode {
269 public:
270 MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
271 virtual int Opcode() const;
272 virtual const Type* bottom_type() const { return TypeLong::LONG; }
273 virtual uint ideal_reg() const { return Op_RegI; }
274 };
275
276 //------------------------------MulReductionVFNode--------------------------------------
277 // Vector multiply float as a reduction
278 class MulReductionVFNode : public ReductionNode {
279 public:
280 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
281 virtual int Opcode() const;
282 virtual const Type* bottom_type() const { return Type::FLOAT; }
283 virtual uint ideal_reg() const { return Op_RegF; }
284 };
285
286 //------------------------------MulReductionVDNode--------------------------------------
287 // Vector multiply double as a reduction
288 class MulReductionVDNode : public ReductionNode {
289 public:
290 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
291 virtual int Opcode() const;
292 virtual const Type* bottom_type() const { return Type::DOUBLE; }
293 virtual uint ideal_reg() const { return Op_RegD; }
294 };
295
296 //------------------------------DivVFNode--------------------------------------
297 // Vector divide float
298 class DivVFNode : public VectorNode {
299 public:
300 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
301 virtual int Opcode() const;
302 };
303
|