truffle: src/share/vm/opto/memnode.cpp comparison

comparison src/share/vm/opto/memnode.cpp @ 4815:53a127075045

7131302: connode.cpp:205 Error: ShouldNotReachHere() Summary: Add Value() methods to short and byte Load nodes to truncate constants which does not fit. Reviewed-by: jrose

author	kvn
date	Fri, 20 Jan 2012 09:43:06 -0800
parents	35acf8f0a2e4
children	52474ec73861

comparison

equal deleted inserted replaced

-:50d9b7a0072c
+:53a127075045
 // (Also allow a variable load from a fresh array to produce zero.)
 const TypeOopPtr *tinst = tp->isa_oopptr();
 bool is_instance = (tinst != NULL) && tinst->is_known_instance_field();
 if (ReduceFieldZeroing || is_instance) {
 Node* value = can_see_stored_value(mem,phase);
-if (value != NULL && value->is_Con())
+if (value != NULL && value->is_Con()) {
+assert(value->bottom_type()->higher_equal(_type),"sanity");
 return value->bottom_type();
+}
 }
 if (is_instance) {
 // If we have an instance type and our memory input is the
 // programs's initial memory state, there is no matching store,
 }
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
+const Type* LoadBNode::Value(PhaseTransform *phase) const {
+Node* mem = in(MemNode::Memory);
+Node* value = can_see_stored_value(mem,phase);
+if (value != NULL && value->is_Con()) {
+// If the input to the store does not fit with the load's result type,
+// it must be truncated. We can't delay until Ideal call since
+// a singleton Value is needed for split_thru_phi optimization.
+int con = value->get_int();
+return TypeInt::make((con << 24) >> 24);
+}
+return LoadNode::Value(phase);
+}
 //--------------------------LoadUBNode::Ideal-------------------------------------
 //
 //  If the previous store is to the same address as this load,
 //  and the value stored was larger than a byte, replace this load
 //  with the value stored truncated to a byte.  If no truncation is
 return new (phase->C, 3) AndINode(value, phase->intcon(0xFF));
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
+const Type* LoadUBNode::Value(PhaseTransform *phase) const {
+Node* mem = in(MemNode::Memory);
+Node* value = can_see_stored_value(mem,phase);
+if (value != NULL && value->is_Con()) {
+// If the input to the store does not fit with the load's result type,
+// it must be truncated. We can't delay until Ideal call since
+// a singleton Value is needed for split_thru_phi optimization.
+int con = value->get_int();
+return TypeInt::make(con & 0xFF);
+}
+return LoadNode::Value(phase);
+}
 //--------------------------LoadUSNode::Ideal-------------------------------------
 //
 //  If the previous store is to the same address as this load,
 //  and the value stored was larger than a char, replace this load
 //  with the value stored truncated to a char.  If no truncation is
 return new (phase->C, 3) AndINode(value,phase->intcon(0xFFFF));
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
+const Type* LoadUSNode::Value(PhaseTransform *phase) const {
+Node* mem = in(MemNode::Memory);
+Node* value = can_see_stored_value(mem,phase);
+if (value != NULL && value->is_Con()) {
+// If the input to the store does not fit with the load's result type,
+// it must be truncated. We can't delay until Ideal call since
+// a singleton Value is needed for split_thru_phi optimization.
+int con = value->get_int();
+return TypeInt::make(con & 0xFFFF);
+}
+return LoadNode::Value(phase);
+}
 //--------------------------LoadSNode::Ideal--------------------------------------
 //
 //  If the previous store is to the same address as this load,
 //  and the value stored was larger than a short, replace this load
 //  with the value stored truncated to a short.  If no truncation is
 Node *result = phase->transform( new (phase->C, 3) LShiftINode(value, phase->intcon(16)) );
 return new (phase->C, 3) RShiftINode(result, phase->intcon(16));
 }
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
+}
+const Type* LoadSNode::Value(PhaseTransform *phase) const {
+Node* mem = in(MemNode::Memory);
+Node* value = can_see_stored_value(mem,phase);
+if (value != NULL && value->is_Con()) {
+// If the input to the store does not fit with the load's result type,
+// it must be truncated. We can't delay until Ideal call since
+// a singleton Value is needed for split_thru_phi optimization.
+int con = value->get_int();
+return TypeInt::make((con << 16) >> 16);
+}
+return LoadNode::Value(phase);
 }
 //=============================================================================
 //----------------------------LoadKlassNode::make------------------------------
 // Polymorphic factory method:

Mercurial > hg > truffle

comparison src/share/vm/opto/memnode.cpp @ 4815:53a127075045