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

comparison src/share/vm/opto/memnode.cpp @ 628:7bb995fbd3c0

Merge

author	trims
date	Thu, 12 Mar 2009 18:16:36 -0700
parents	0fbdb4381b99 337400e7a5dd
children	fbde8ec322d0

comparison

equal deleted inserted replaced

-:ce2272390558
+:7bb995fbd3c0
 Node *prev = NULL;
 Node *result = mchain;
 while (prev != result) {
 prev = result;
 if (result == start_mem)
-break;  // hit one of our sentinals
+break;  // hit one of our sentinels
 // skip over a call which does not affect this memory slice
 if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) {
 Node *proj_in = result->in(0);
 if (proj_in->is_Allocate() && proj_in->_idx == instance_id) {
-break;  // hit one of our sentinals
+break;  // hit one of our sentinels
 } else if (proj_in->is_Call()) {
 CallNode *call = proj_in->as_Call();
 if (!call->may_modify(t_adr, phase)) {
 result = call->in(TypeFunc::Memory);
 }
 tinst->offset() == Type::OffsetBot) ) {
 // compress paths and change unreachable cycles to TOP
 // If not, we can update the input infinitely along a MergeMem cycle
 // Equivalent code in PhiNode::Ideal
 Node* m  = phase->transform(mmem);
-// If tranformed to a MergeMem, get the desired slice
+// If transformed to a MergeMem, get the desired slice
 // Otherwise the returned node represents memory for every slice
 mem = (m->is_MergeMem())? m->as_MergeMem()->memory_at(alias_idx) : m;
 // Update input if it is progress over what we have now
 }
 return mem;
 "use LoadKlassNode instead");
 assert(!(adr_type->isa_aryptr() &&
 adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
 "use LoadRangeNode instead");
 switch (bt) {
-case T_BOOLEAN:
+case T_BOOLEAN: return new (C, 3) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int()    );
 case T_BYTE:    return new (C, 3) LoadBNode (ctl, mem, adr, adr_type, rt->is_int()    );
 case T_INT:     return new (C, 3) LoadINode (ctl, mem, adr, adr_type, rt->is_int()    );
 case T_CHAR:    return new (C, 3) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int()    );
 case T_SHORT:   return new (C, 3) LoadSNode (ctl, mem, adr, adr_type, rt->is_int()    );
 case T_LONG:    return new (C, 3) LoadLNode (ctl, mem, adr, adr_type, rt->is_long()   );
 // usually runs first, producing the singleton type of the Con.)
 return value;
 }
 // Search for an existing data phi which was generated before for the same
-// instance's field to avoid infinite genertion of phis in a loop.
+// instance's field to avoid infinite generation of phis in a loop.
 Node *region = mem->in(0);
 if (is_instance_field_load_with_local_phi(region)) {
 const TypePtr *addr_t = in(MemNode::Address)->bottom_type()->isa_ptr();
 int this_index  = phase->C->get_alias_index(addr_t);
 int this_offset = addr_t->offset();
 allocation_index = i;
 load_index = 3 - allocation_index;
 break;
 }
 }
-LoadNode* load = NULL;
+bool has_load = ( allocation != NULL &&
-if (allocation != NULL && base->in(load_index)->is_Load()) {
+(base->in(load_index)->is_Load() ||
-load = base->in(load_index)->as_Load();
+base->in(load_index)->is_DecodeN() &&
-}
+base->in(load_index)->in(1)->is_Load()) );
-if (load != NULL && in(Memory)->is_Phi() && in(Memory)->in(0) == base->in(0)) {
+if (has_load && in(Memory)->is_Phi() && in(Memory)->in(0) == base->in(0)) {
 // Push the loads from the phi that comes from valueOf up
 // through it to allow elimination of the loads and the recovery
 // of the original value.
 Node* mem_phi = in(Memory);
 Node* offset = in(Address)->in(AddPNode::Offset);
 PhiNode* result = PhiNode::make_blank(region, this);
 result->set_req(allocation_index, in1);
 result->set_req(load_index, in2);
 return result;
 }
-} else if (base->is_Load()) {
+} else if (base->is_Load() ||
+base->is_DecodeN() && base->in(1)->is_Load()) {
+if (base->is_DecodeN()) {
+// Get LoadN node which loads cached Integer object
+base = base->in(1);
+}
 // Eliminate the load of Integer.value for integers from the cache
 // array by deriving the value from the index into the array.
 // Capture the offset of the load and then reverse the computation.
 Node* load_base = base->in(Address)->in(AddPNode::Base);
+if (load_base->is_DecodeN()) {
+// Get LoadN node which loads IntegerCache.cache field
+load_base = load_base->in(1);
+}
 if (load_base != NULL) {
 Compile::AliasType* atp = phase->C->alias_type(load_base->adr_type());
 intptr_t cache_offset;
 int shift = -1;
 Node* cache = NULL;
 // Make sure that the type array is big enough for
 // our new node, even though we may throw the node away.
 // (This tweaking with igvn only works because x is a new node.)
 igvn->set_type(x, t);
 // If x is a TypeNode, capture any more-precise type permanently into Node
-// othewise it will be not updated during igvn->transform since
+// otherwise it will be not updated during igvn->transform since
 // igvn->type(x) is set to x->Value() already.
 x->raise_bottom_type(t);
 Node *y = x->Identity(igvn);
 if( y != x ) {
 wins++;
 }
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
+//--------------------------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
+//  needed, the replacement is done in LoadNode::Identity().
+//
+Node* LoadUBNode::Ideal(PhaseGVN* phase, bool can_reshape) {
+Node* mem = in(MemNode::Memory);
+Node* value = can_see_stored_value(mem, phase);
+if (value && !phase->type(value)->higher_equal(_type))
+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);
+}
 //--------------------------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
 // may also be created at that point to represent any required zeroing.
 // The InitializeNode is then marked 'complete', prohibiting further
 // capturing of nearby memory operations.
 //
 // During macro-expansion, all captured initializations which store
-// constant values of 32 bits or smaller are coalesced (if advantagous)
+// constant values of 32 bits or smaller are coalesced (if advantageous)
 // into larger 'tiles' 32 or 64 bits.  This allows an object to be
 // initialized in fewer memory operations.  Memory words which are
 // covered by neither tiles nor non-constant stores are pre-zeroed
 // by explicit stores of zero.  (The code shape happens to do all
 // zeroing first, then all other stores, with both sequences occurring
 new_mem = (new_base == this || new_base == empty_mem)? empty_mem : new_base;
 }
 else if (old_mmem != NULL) {
 new_mem = old_mmem->memory_at(i);
 }
-// else preceeding memory was not a MergeMem
+// else preceding memory was not a MergeMem
 // replace equivalent phis (unfortunately, they do not GVN together)
 if (new_mem != NULL && new_mem != new_base &&
 new_mem->req() == phi_len && new_mem->in(0) == phi_reg) {
 if (new_mem->is_Phi()) {

Mercurial > hg > truffle

comparison src/share/vm/opto/memnode.cpp @ 628:7bb995fbd3c0