< prev index next >

src/share/vm/opto/mulnode.cpp

Print this page




  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 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "opto/addnode.hpp"
  28 #include "opto/connode.hpp"
  29 #include "opto/memnode.hpp"
  30 #include "opto/mulnode.hpp"
  31 #include "opto/phaseX.hpp"
  32 #include "opto/subnode.hpp"




  33 
  34 // Portions of code courtesy of Clifford Click
  35 
  36 
  37 //=============================================================================
  38 //------------------------------hash-------------------------------------------
  39 // Hash function over MulNodes.  Needs to be commutative; i.e., I swap
  40 // (commute) inputs to MulNodes willy-nilly so the hash function must return
  41 // the same value in the presence of edge swapping.
  42 uint MulNode::hash() const {
  43   return (uintptr_t)in(1) + (uintptr_t)in(2) + Opcode();
  44 }
  45 
  46 //------------------------------Identity---------------------------------------
  47 // Multiplying a one preserves the other argument
  48 Node *MulNode::Identity( PhaseTransform *phase ) {
  49   register const Type *one = mul_id();  // The multiplicative identity
  50   if( phase->type( in(1) )->higher_equal( one ) ) return in(2);
  51   if( phase->type( in(2) )->higher_equal( one ) ) return in(1);
  52 


 455       if (t12 && t12->is_con()) {  // Shift is by a constant
 456         int shift = t12->get_con();
 457         shift &= BitsPerJavaInteger - 1;  // semantics of Java shifts
 458         int mask = max_juint >> shift;
 459         if ((mask & con) == mask)  // If AND is useless, skip it
 460           return in1;
 461       }
 462     }
 463   }
 464   return MulNode::Identity(phase);
 465 }
 466 
 467 //------------------------------Ideal------------------------------------------
 468 Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
 469   // Special case constant AND mask
 470   const TypeInt *t2 = phase->type( in(2) )->isa_int();
 471   if( !t2 || !t2->is_con() ) return MulNode::Ideal(phase, can_reshape);
 472   const int mask = t2->get_con();
 473   Node *load = in(1);
 474   uint lop = load->Opcode();









 475 
 476   // Masking bits off of a Character?  Hi bits are already zero.
 477   if( lop == Op_LoadUS &&
 478       (mask & 0xFFFF0000) )     // Can we make a smaller mask?
 479     return new (phase->C) AndINode(load,phase->intcon(mask&0xFFFF));
 480 
 481   // Masking bits off of a Short?  Loading a Character does some masking
 482   if (can_reshape &&
 483       load->outcnt() == 1 && load->unique_out() == this) {
 484     if (lop == Op_LoadS && (mask & 0xFFFF0000) == 0 ) {
 485       Node *ldus = new (phase->C) LoadUSNode(load->in(MemNode::Control),
 486                                              load->in(MemNode::Memory),
 487                                              load->in(MemNode::Address),
 488                                              load->adr_type(),
 489                                              TypeInt::CHAR, MemNode::unordered);
 490       ldus = phase->transform(ldus);
 491       return new (phase->C) AndINode(ldus, phase->intcon(mask & 0xFFFF));
 492     }
 493 
 494     // Masking sign bits off of a Byte?  Do an unsigned byte load plus




  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 
  25 #include "precompiled.hpp"
  26 #include "memory/allocation.inline.hpp"
  27 #include "opto/addnode.hpp"
  28 #include "opto/connode.hpp"
  29 #include "opto/memnode.hpp"
  30 #include "opto/mulnode.hpp"
  31 #include "opto/phaseX.hpp"
  32 #include "opto/subnode.hpp"
  33 #include "utilities/macros.hpp"
  34 #if INCLUDE_ALL_GCS
  35 #include "gc_implementation/shenandoah/c2/shenandoahSupport.hpp"
  36 #endif
  37 
  38 // Portions of code courtesy of Clifford Click
  39 
  40 
  41 //=============================================================================
  42 //------------------------------hash-------------------------------------------
  43 // Hash function over MulNodes.  Needs to be commutative; i.e., I swap
  44 // (commute) inputs to MulNodes willy-nilly so the hash function must return
  45 // the same value in the presence of edge swapping.
  46 uint MulNode::hash() const {
  47   return (uintptr_t)in(1) + (uintptr_t)in(2) + Opcode();
  48 }
  49 
  50 //------------------------------Identity---------------------------------------
  51 // Multiplying a one preserves the other argument
  52 Node *MulNode::Identity( PhaseTransform *phase ) {
  53   register const Type *one = mul_id();  // The multiplicative identity
  54   if( phase->type( in(1) )->higher_equal( one ) ) return in(2);
  55   if( phase->type( in(2) )->higher_equal( one ) ) return in(1);
  56 


 459       if (t12 && t12->is_con()) {  // Shift is by a constant
 460         int shift = t12->get_con();
 461         shift &= BitsPerJavaInteger - 1;  // semantics of Java shifts
 462         int mask = max_juint >> shift;
 463         if ((mask & con) == mask)  // If AND is useless, skip it
 464           return in1;
 465       }
 466     }
 467   }
 468   return MulNode::Identity(phase);
 469 }
 470 
 471 //------------------------------Ideal------------------------------------------
 472 Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
 473   // Special case constant AND mask
 474   const TypeInt *t2 = phase->type( in(2) )->isa_int();
 475   if( !t2 || !t2->is_con() ) return MulNode::Ideal(phase, can_reshape);
 476   const int mask = t2->get_con();
 477   Node *load = in(1);
 478   uint lop = load->Opcode();
 479 
 480 #if INCLUDE_ALL_GCS
 481   if (UseShenandoahGC && ShenandoahBarrierC2Support::is_gc_state_load(load)) {
 482     // Do not touch the load+mask, we would match the whole sequence exactly.
 483     // Converting the load to LoadUB/LoadUS would mismatch and waste a register
 484     // on the barrier fastpath.
 485     return NULL;
 486   }
 487 #endif
 488 
 489   // Masking bits off of a Character?  Hi bits are already zero.
 490   if( lop == Op_LoadUS &&
 491       (mask & 0xFFFF0000) )     // Can we make a smaller mask?
 492     return new (phase->C) AndINode(load,phase->intcon(mask&0xFFFF));
 493 
 494   // Masking bits off of a Short?  Loading a Character does some masking
 495   if (can_reshape &&
 496       load->outcnt() == 1 && load->unique_out() == this) {
 497     if (lop == Op_LoadS && (mask & 0xFFFF0000) == 0 ) {
 498       Node *ldus = new (phase->C) LoadUSNode(load->in(MemNode::Control),
 499                                              load->in(MemNode::Memory),
 500                                              load->in(MemNode::Address),
 501                                              load->adr_type(),
 502                                              TypeInt::CHAR, MemNode::unordered);
 503       ldus = phase->transform(ldus);
 504       return new (phase->C) AndINode(ldus, phase->intcon(mask & 0xFFFF));
 505     }
 506 
 507     // Masking sign bits off of a Byte?  Do an unsigned byte load plus


< prev index next >