Mercurial > hg > truffle
comparison src/share/vm/opto/vectornode.cpp @ 6804:e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
Summary: Deleted placement new operator of Node - node(size_t, Compile *, int).
Reviewed-by: kvn, twisti
Contributed-by: bharadwaj.yadavalli@oracle.com
author | kvn |
---|---|
date | Thu, 27 Sep 2012 09:38:42 -0700 |
parents | 5af51c882207 |
children | 859c45fb8cea |
comparison
equal
deleted
inserted
replaced
6803:06f52c4d0e18 | 6804:e626685e9f6c |
---|---|
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 | 246 |
247 switch (vopc) { | 247 switch (vopc) { |
248 case Op_AddVB: return new (C, 3) AddVBNode(n1, n2, vt); | 248 case Op_AddVB: return new (C) AddVBNode(n1, n2, vt); |
249 case Op_AddVS: return new (C, 3) AddVSNode(n1, n2, vt); | 249 case Op_AddVS: return new (C) AddVSNode(n1, n2, vt); |
250 case Op_AddVI: return new (C, 3) AddVINode(n1, n2, vt); | 250 case Op_AddVI: return new (C) AddVINode(n1, n2, vt); |
251 case Op_AddVL: return new (C, 3) AddVLNode(n1, n2, vt); | 251 case Op_AddVL: return new (C) AddVLNode(n1, n2, vt); |
252 case Op_AddVF: return new (C, 3) AddVFNode(n1, n2, vt); | 252 case Op_AddVF: return new (C) AddVFNode(n1, n2, vt); |
253 case Op_AddVD: return new (C, 3) AddVDNode(n1, n2, vt); | 253 case Op_AddVD: return new (C) AddVDNode(n1, n2, vt); |
254 | 254 |
255 case Op_SubVB: return new (C, 3) SubVBNode(n1, n2, vt); | 255 case Op_SubVB: return new (C) SubVBNode(n1, n2, vt); |
256 case Op_SubVS: return new (C, 3) SubVSNode(n1, n2, vt); | 256 case Op_SubVS: return new (C) SubVSNode(n1, n2, vt); |
257 case Op_SubVI: return new (C, 3) SubVINode(n1, n2, vt); | 257 case Op_SubVI: return new (C) SubVINode(n1, n2, vt); |
258 case Op_SubVL: return new (C, 3) SubVLNode(n1, n2, vt); | 258 case Op_SubVL: return new (C) SubVLNode(n1, n2, vt); |
259 case Op_SubVF: return new (C, 3) SubVFNode(n1, n2, vt); | 259 case Op_SubVF: return new (C) SubVFNode(n1, n2, vt); |
260 case Op_SubVD: return new (C, 3) SubVDNode(n1, n2, vt); | 260 case Op_SubVD: return new (C) SubVDNode(n1, n2, vt); |
261 | 261 |
262 case Op_MulVS: return new (C, 3) MulVSNode(n1, n2, vt); | 262 case Op_MulVS: return new (C) MulVSNode(n1, n2, vt); |
263 case Op_MulVI: return new (C, 3) MulVINode(n1, n2, vt); | 263 case Op_MulVI: return new (C) MulVINode(n1, n2, vt); |
264 case Op_MulVF: return new (C, 3) MulVFNode(n1, n2, vt); | 264 case Op_MulVF: return new (C) MulVFNode(n1, n2, vt); |
265 case Op_MulVD: return new (C, 3) MulVDNode(n1, n2, vt); | 265 case Op_MulVD: return new (C) MulVDNode(n1, n2, vt); |
266 | 266 |
267 case Op_DivVF: return new (C, 3) DivVFNode(n1, n2, vt); | 267 case Op_DivVF: return new (C) DivVFNode(n1, n2, vt); |
268 case Op_DivVD: return new (C, 3) DivVDNode(n1, n2, vt); | 268 case Op_DivVD: return new (C) DivVDNode(n1, n2, vt); |
269 | 269 |
270 case Op_LShiftVB: return new (C, 3) LShiftVBNode(n1, n2, vt); | 270 case Op_LShiftVB: return new (C) LShiftVBNode(n1, n2, vt); |
271 case Op_LShiftVS: return new (C, 3) LShiftVSNode(n1, n2, vt); | 271 case Op_LShiftVS: return new (C) LShiftVSNode(n1, n2, vt); |
272 case Op_LShiftVI: return new (C, 3) LShiftVINode(n1, n2, vt); | 272 case Op_LShiftVI: return new (C) LShiftVINode(n1, n2, vt); |
273 case Op_LShiftVL: return new (C, 3) LShiftVLNode(n1, n2, vt); | 273 case Op_LShiftVL: return new (C) LShiftVLNode(n1, n2, vt); |
274 | 274 |
275 case Op_RShiftVB: return new (C, 3) RShiftVBNode(n1, n2, vt); | 275 case Op_RShiftVB: return new (C) RShiftVBNode(n1, n2, vt); |
276 case Op_RShiftVS: return new (C, 3) RShiftVSNode(n1, n2, vt); | 276 case Op_RShiftVS: return new (C) RShiftVSNode(n1, n2, vt); |
277 case Op_RShiftVI: return new (C, 3) RShiftVINode(n1, n2, vt); | 277 case Op_RShiftVI: return new (C) RShiftVINode(n1, n2, vt); |
278 case Op_RShiftVL: return new (C, 3) RShiftVLNode(n1, n2, vt); | 278 case Op_RShiftVL: return new (C) RShiftVLNode(n1, n2, vt); |
279 | 279 |
280 case Op_URShiftVB: return new (C, 3) URShiftVBNode(n1, n2, vt); | 280 case Op_URShiftVB: return new (C) URShiftVBNode(n1, n2, vt); |
281 case Op_URShiftVS: return new (C, 3) URShiftVSNode(n1, n2, vt); | 281 case Op_URShiftVS: return new (C) URShiftVSNode(n1, n2, vt); |
282 case Op_URShiftVI: return new (C, 3) URShiftVINode(n1, n2, vt); | 282 case Op_URShiftVI: return new (C) URShiftVINode(n1, n2, vt); |
283 case Op_URShiftVL: return new (C, 3) URShiftVLNode(n1, n2, vt); | 283 case Op_URShiftVL: return new (C) URShiftVLNode(n1, n2, vt); |
284 | 284 |
285 case Op_AndV: return new (C, 3) AndVNode(n1, n2, vt); | 285 case Op_AndV: return new (C) AndVNode(n1, n2, vt); |
286 case Op_OrV: return new (C, 3) OrVNode (n1, n2, vt); | 286 case Op_OrV: return new (C) OrVNode (n1, n2, vt); |
287 case Op_XorV: return new (C, 3) XorVNode(n1, n2, vt); | 287 case Op_XorV: return new (C) XorVNode(n1, n2, vt); |
288 } | 288 } |
289 ShouldNotReachHere(); | 289 ShouldNotReachHere(); |
290 return NULL; | 290 return NULL; |
291 | 291 |
292 } | 292 } |
297 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen) | 297 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen) |
298 : TypeVect::make(bt, vlen); | 298 : TypeVect::make(bt, vlen); |
299 switch (bt) { | 299 switch (bt) { |
300 case T_BOOLEAN: | 300 case T_BOOLEAN: |
301 case T_BYTE: | 301 case T_BYTE: |
302 return new (C, 2) ReplicateBNode(s, vt); | 302 return new (C) ReplicateBNode(s, vt); |
303 case T_CHAR: | 303 case T_CHAR: |
304 case T_SHORT: | 304 case T_SHORT: |
305 return new (C, 2) ReplicateSNode(s, vt); | 305 return new (C) ReplicateSNode(s, vt); |
306 case T_INT: | 306 case T_INT: |
307 return new (C, 2) ReplicateINode(s, vt); | 307 return new (C) ReplicateINode(s, vt); |
308 case T_LONG: | 308 case T_LONG: |
309 return new (C, 2) ReplicateLNode(s, vt); | 309 return new (C) ReplicateLNode(s, vt); |
310 case T_FLOAT: | 310 case T_FLOAT: |
311 return new (C, 2) ReplicateFNode(s, vt); | 311 return new (C) ReplicateFNode(s, vt); |
312 case T_DOUBLE: | 312 case T_DOUBLE: |
313 return new (C, 2) ReplicateDNode(s, vt); | 313 return new (C) ReplicateDNode(s, vt); |
314 } | 314 } |
315 ShouldNotReachHere(); | 315 ShouldNotReachHere(); |
316 return NULL; | 316 return NULL; |
317 } | 317 } |
318 | 318 |
320 PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { | 320 PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { |
321 const TypeVect* vt = TypeVect::make(bt, vlen); | 321 const TypeVect* vt = TypeVect::make(bt, vlen); |
322 switch (bt) { | 322 switch (bt) { |
323 case T_BOOLEAN: | 323 case T_BOOLEAN: |
324 case T_BYTE: | 324 case T_BYTE: |
325 return new (C, 2) PackBNode(s, vt); | 325 return new (C) PackBNode(s, vt); |
326 case T_CHAR: | 326 case T_CHAR: |
327 case T_SHORT: | 327 case T_SHORT: |
328 return new (C, 2) PackSNode(s, vt); | 328 return new (C) PackSNode(s, vt); |
329 case T_INT: | 329 case T_INT: |
330 return new (C, 2) PackINode(s, vt); | 330 return new (C) PackINode(s, vt); |
331 case T_LONG: | 331 case T_LONG: |
332 return new (C, 2) PackLNode(s, vt); | 332 return new (C) PackLNode(s, vt); |
333 case T_FLOAT: | 333 case T_FLOAT: |
334 return new (C, 2) PackFNode(s, vt); | 334 return new (C) PackFNode(s, vt); |
335 case T_DOUBLE: | 335 case T_DOUBLE: |
336 return new (C, 2) PackDNode(s, vt); | 336 return new (C) PackDNode(s, vt); |
337 } | 337 } |
338 ShouldNotReachHere(); | 338 ShouldNotReachHere(); |
339 return NULL; | 339 return NULL; |
340 } | 340 } |
341 | 341 |
356 BasicType bt = n1->vect_type()->element_basic_type(); | 356 BasicType bt = n1->vect_type()->element_basic_type(); |
357 assert(bt == n2->vect_type()->element_basic_type(), "should be the same"); | 357 assert(bt == n2->vect_type()->element_basic_type(), "should be the same"); |
358 switch (bt) { | 358 switch (bt) { |
359 case T_BOOLEAN: | 359 case T_BOOLEAN: |
360 case T_BYTE: | 360 case T_BYTE: |
361 return new (C, 3) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2)); | 361 return new (C) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2)); |
362 case T_CHAR: | 362 case T_CHAR: |
363 case T_SHORT: | 363 case T_SHORT: |
364 return new (C, 3) PackINode(n1, n2, TypeVect::make(T_INT, 2)); | 364 return new (C) PackINode(n1, n2, TypeVect::make(T_INT, 2)); |
365 case T_INT: | 365 case T_INT: |
366 return new (C, 3) PackLNode(n1, n2, TypeVect::make(T_LONG, 2)); | 366 return new (C) PackLNode(n1, n2, TypeVect::make(T_LONG, 2)); |
367 case T_LONG: | 367 case T_LONG: |
368 return new (C, 3) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2)); | 368 return new (C) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2)); |
369 case T_FLOAT: | 369 case T_FLOAT: |
370 return new (C, 3) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); | 370 return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); |
371 case T_DOUBLE: | 371 case T_DOUBLE: |
372 return new (C, 3) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); | 372 return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); |
373 } | 373 } |
374 ShouldNotReachHere(); | 374 ShouldNotReachHere(); |
375 } | 375 } |
376 return NULL; | 376 return NULL; |
377 } | 377 } |
378 | 378 |
379 // Return the vector version of a scalar load node. | 379 // Return the vector version of a scalar load node. |
380 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, | 380 LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, |
381 Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { | 381 Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { |
382 const TypeVect* vt = TypeVect::make(bt, vlen); | 382 const TypeVect* vt = TypeVect::make(bt, vlen); |
383 return new (C, 3) LoadVectorNode(ctl, mem, adr, atyp, vt); | 383 return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt); |
384 return NULL; | 384 return NULL; |
385 } | 385 } |
386 | 386 |
387 // Return the vector version of a scalar store node. | 387 // Return the vector version of a scalar store node. |
388 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, | 388 StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, |
389 Node* adr, const TypePtr* atyp, Node* val, | 389 Node* adr, const TypePtr* atyp, Node* val, |
390 uint vlen) { | 390 uint vlen) { |
391 return new (C, 4) StoreVectorNode(ctl, mem, adr, atyp, val); | 391 return new (C) StoreVectorNode(ctl, mem, adr, atyp, val); |
392 } | 392 } |
393 | 393 |
394 // Extract a scalar element of vector. | 394 // Extract a scalar element of vector. |
395 Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) { | 395 Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) { |
396 assert((int)position < Matcher::max_vector_size(bt), "pos in range"); | 396 assert((int)position < Matcher::max_vector_size(bt), "pos in range"); |
397 ConINode* pos = ConINode::make(C, (int)position); | 397 ConINode* pos = ConINode::make(C, (int)position); |
398 switch (bt) { | 398 switch (bt) { |
399 case T_BOOLEAN: | 399 case T_BOOLEAN: |
400 return new (C, 3) ExtractUBNode(v, pos); | 400 return new (C) ExtractUBNode(v, pos); |
401 case T_BYTE: | 401 case T_BYTE: |
402 return new (C, 3) ExtractBNode(v, pos); | 402 return new (C) ExtractBNode(v, pos); |
403 case T_CHAR: | 403 case T_CHAR: |
404 return new (C, 3) ExtractCNode(v, pos); | 404 return new (C) ExtractCNode(v, pos); |
405 case T_SHORT: | 405 case T_SHORT: |
406 return new (C, 3) ExtractSNode(v, pos); | 406 return new (C) ExtractSNode(v, pos); |
407 case T_INT: | 407 case T_INT: |
408 return new (C, 3) ExtractINode(v, pos); | 408 return new (C) ExtractINode(v, pos); |
409 case T_LONG: | 409 case T_LONG: |
410 return new (C, 3) ExtractLNode(v, pos); | 410 return new (C) ExtractLNode(v, pos); |
411 case T_FLOAT: | 411 case T_FLOAT: |
412 return new (C, 3) ExtractFNode(v, pos); | 412 return new (C) ExtractFNode(v, pos); |
413 case T_DOUBLE: | 413 case T_DOUBLE: |
414 return new (C, 3) ExtractDNode(v, pos); | 414 return new (C) ExtractDNode(v, pos); |
415 } | 415 } |
416 ShouldNotReachHere(); | 416 ShouldNotReachHere(); |
417 return NULL; | 417 return NULL; |
418 } | 418 } |
419 | 419 |