Mercurial > hg > graal-compiler
comparison src/share/vm/opto/vectornode.cpp @ 6823:859c45fb8cea
7201026: add vector for shift count
Summary: Add generation of vectors for scalar shift count.
Reviewed-by: roland, twisti, dlong
author | kvn |
---|---|
date | Tue, 02 Oct 2012 12:25:13 -0700 |
parents | e626685e9f6c |
children | aaeb9add1ab3 |
comparison
equal
deleted
inserted
replaced
6822:f6b0eb4e44cf | 6823:859c45fb8cea |
---|---|
241 | 241 |
242 // Return the vector version of a scalar operation node. | 242 // Return the vector version of a scalar operation node. |
243 VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt) { | 243 VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt) { |
244 const TypeVect* vt = TypeVect::make(bt, vlen); | 244 const TypeVect* vt = TypeVect::make(bt, vlen); |
245 int vopc = VectorNode::opcode(opc, bt); | 245 int vopc = VectorNode::opcode(opc, bt); |
246 // This method should not be called for unimplemented vectors. | |
247 guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc])); | |
246 | 248 |
247 switch (vopc) { | 249 switch (vopc) { |
248 case Op_AddVB: return new (C) AddVBNode(n1, n2, vt); | 250 case Op_AddVB: return new (C) AddVBNode(n1, n2, vt); |
249 case Op_AddVS: return new (C) AddVSNode(n1, n2, vt); | 251 case Op_AddVS: return new (C) AddVSNode(n1, n2, vt); |
250 case Op_AddVI: return new (C) AddVINode(n1, n2, vt); | 252 case Op_AddVI: return new (C) AddVINode(n1, n2, vt); |
284 | 286 |
285 case Op_AndV: return new (C) AndVNode(n1, n2, vt); | 287 case Op_AndV: return new (C) AndVNode(n1, n2, vt); |
286 case Op_OrV: return new (C) OrVNode (n1, n2, vt); | 288 case Op_OrV: return new (C) OrVNode (n1, n2, vt); |
287 case Op_XorV: return new (C) XorVNode(n1, n2, vt); | 289 case Op_XorV: return new (C) XorVNode(n1, n2, vt); |
288 } | 290 } |
289 ShouldNotReachHere(); | 291 fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc])); |
290 return NULL; | 292 return NULL; |
291 | 293 |
292 } | 294 } |
293 | 295 |
294 // Scalar promotion | 296 // Scalar promotion |
310 case T_FLOAT: | 312 case T_FLOAT: |
311 return new (C) ReplicateFNode(s, vt); | 313 return new (C) ReplicateFNode(s, vt); |
312 case T_DOUBLE: | 314 case T_DOUBLE: |
313 return new (C) ReplicateDNode(s, vt); | 315 return new (C) ReplicateDNode(s, vt); |
314 } | 316 } |
315 ShouldNotReachHere(); | 317 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); |
318 return NULL; | |
319 } | |
320 | |
321 VectorNode* VectorNode::shift_count(Compile* C, Node* shift, Node* cnt, uint vlen, BasicType bt) { | |
322 assert(VectorNode::is_shift(shift) && !cnt->is_Con(), "only variable shift count"); | |
323 // Match shift count type with shift vector type. | |
324 const TypeVect* vt = TypeVect::make(bt, vlen); | |
325 switch (shift->Opcode()) { | |
326 case Op_LShiftI: | |
327 case Op_LShiftL: | |
328 return new (C) LShiftCntVNode(cnt, vt); | |
329 case Op_RShiftI: | |
330 case Op_RShiftL: | |
331 case Op_URShiftI: | |
332 case Op_URShiftL: | |
333 return new (C) RShiftCntVNode(cnt, vt); | |
334 } | |
335 fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[shift->Opcode()])); | |
316 return NULL; | 336 return NULL; |
317 } | 337 } |
318 | 338 |
319 // Return initial Pack node. Additional operands added with add_opd() calls. | 339 // Return initial Pack node. Additional operands added with add_opd() calls. |
320 PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { | 340 PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { |
333 case T_FLOAT: | 353 case T_FLOAT: |
334 return new (C) PackFNode(s, vt); | 354 return new (C) PackFNode(s, vt); |
335 case T_DOUBLE: | 355 case T_DOUBLE: |
336 return new (C) PackDNode(s, vt); | 356 return new (C) PackDNode(s, vt); |
337 } | 357 } |
338 ShouldNotReachHere(); | 358 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); |
339 return NULL; | 359 return NULL; |
340 } | 360 } |
341 | 361 |
342 // Create a binary tree form for Packs. [lo, hi) (half-open) range | 362 // Create a binary tree form for Packs. [lo, hi) (half-open) range |
343 PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) { | 363 PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) { |
369 case T_FLOAT: | 389 case T_FLOAT: |
370 return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); | 390 return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); |
371 case T_DOUBLE: | 391 case T_DOUBLE: |
372 return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); | 392 return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); |
373 } | 393 } |
374 ShouldNotReachHere(); | 394 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); |
375 } | 395 } |
376 return NULL; | 396 return NULL; |
377 } | 397 } |
378 | 398 |
379 // Return the vector version of a scalar load node. | 399 // Return the vector version of a scalar load node. |
380 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, | 400 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, |
381 Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { | 401 Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { |
382 const TypeVect* vt = TypeVect::make(bt, vlen); | 402 const TypeVect* vt = TypeVect::make(bt, vlen); |
383 return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt); | 403 return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt); |
384 return NULL; | |
385 } | 404 } |
386 | 405 |
387 // Return the vector version of a scalar store node. | 406 // Return the vector version of a scalar store node. |
388 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, | 407 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, |
389 Node* adr, const TypePtr* atyp, Node* val, | 408 Node* adr, const TypePtr* atyp, Node* val, |
411 case T_FLOAT: | 430 case T_FLOAT: |
412 return new (C) ExtractFNode(v, pos); | 431 return new (C) ExtractFNode(v, pos); |
413 case T_DOUBLE: | 432 case T_DOUBLE: |
414 return new (C) ExtractDNode(v, pos); | 433 return new (C) ExtractDNode(v, pos); |
415 } | 434 } |
416 ShouldNotReachHere(); | 435 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); |
417 return NULL; | 436 return NULL; |
418 } | 437 } |
419 | 438 |