Mercurial > hg > truffle

comparison src/share/vm/opto/vectornode.cpp @ 6804:e626685e9f6c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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