Lines Matching refs:mem
74 void MemNode::dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st) {
180 Node *mem = mmem;
225 mem = (m->is_MergeMem())? m->as_MergeMem()->memory_at(alias_idx) : m;
228 return mem;
264 Node *mem = in(MemNode::Memory);
265 if (phase->type( mem ) == Type::TOP) return NodeSentinel; // caller will return NULL
266 assert(mem != this, "dead loop in MemNode::Ideal");
268 if (can_reshape && igvn != NULL && igvn->_worklist.member(mem)) {
270 // Delay this mem node transformation until the memory is processed.
283 // Delay this mem node transformation until the address is processed.
307 if (C->is_dead_node(mem->_idx)) tty->print_cr("'mem' is dead");
324 Node* old_mem = mem;
334 if (mem->is_MergeMem()) {
335 MergeMemNode* mmem = mem->as_MergeMem();
338 mem = step_through_mergemem(phase, mmem, tp, adr_type(), tty);
341 if (mem != old_mem) {
342 set_req(MemNode::Memory, mem);
346 if (phase->type( mem ) == Type::TOP) return NodeSentinel;
506 Node* mem = in(MemNode::Memory); // start searching here...
512 if (mem->is_Store()) {
513 Node* st_adr = mem->in(MemNode::Address);
522 st_offset <= offset - mem->as_Store()->memory_size()) {
528 mem = mem->in(MemNode::Memory);
538 mem = mem->in(MemNode::Memory);
543 // since we have not managed to prove 'this' and 'mem' independent.
545 return mem; // let caller handle steps (c), (d)
548 } else if (mem->is_Proj() && mem->in(0)->is_Initialize()) {
549 InitializeNode* st_init = mem->in(0)->as_Initialize();
568 mem = st_alloc->in(TypeFunc::Memory);
570 mem = st_init->memory(alias_idx);
579 return mem; // let caller handle steps (c), (d)
584 if (mem->is_Proj() && mem->in(0)->is_Call()) {
585 CallNode *call = mem->in(0)->as_Call();
587 mem = call->in(TypeFunc::Memory);
590 } else if (mem->is_Proj() && mem->in(0)->is_MemBar()) {
591 mem = mem->in(0)->in(TypeFunc::Memory);
593 } else if (mem->is_ClearArray()) {
594 if (ClearArrayNode::step_through(&mem, (uint)addr_t->instance_id(), phase)) {
595 // (the call updated 'mem' value)
600 return mem;
602 } else if (mem->is_MergeMem()) {
604 mem = mem->as_MergeMem()->memory_at(alias_idx);
610 // because 'mem' is an inscrutable memory state (e.g., a call).
790 // No obvious dominating point. The mem op is pinned below the Phi
792 // then the mem op can float, but not indefinitely. It must be pinned
893 Node *LoadNode::make( PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypePtr* adr_type, const Type *rt, BasicType bt ) {
909 case T_BOOLEAN: return new (C) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int() );
910 case T_BYTE: return new (C) LoadBNode (ctl, mem, adr, adr_type, rt->is_int() );
911 case T_INT: return new (C) LoadINode (ctl, mem, adr, adr_type, rt->is_int() );
912 case T_CHAR: return new (C) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int() );
913 case T_SHORT: return new (C) LoadSNode (ctl, mem, adr, adr_type, rt->is_int() );
914 case T_LONG: return new (C) LoadLNode (ctl, mem, adr, adr_type, rt->is_long() );
915 case T_FLOAT: return new (C) LoadFNode (ctl, mem, adr, adr_type, rt );
916 case T_DOUBLE: return new (C) LoadDNode (ctl, mem, adr, adr_type, rt );
917 case T_ADDRESS: return new (C) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr() );
921 Node* load = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
927 return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
934 LoadLNode* LoadLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt) {
936 return new (C) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), require_atomic);
977 Node* mem = current->in(0)->in(TypeFunc::Memory);
978 if (mem->is_MergeMem()) {
979 MergeMemNode* merge = mem->as_MergeMem();
1083 Node* mem = in(MemNode::Memory);
1084 Node* value = can_see_stored_value(mem, phase);
1103 Node *region = mem->in(0);
1112 if (phi->is_Phi() && phi != mem &&
1296 Node* mem = in(MemNode::Memory);
1301 assert(mem->is_Phi() && (t_oop != NULL) &&
1304 Node *region = mem->in(0);
1308 uint cnt = mem->req();
1313 Node *in = mem->in(i);
1321 Node *in = mem->in(i);
1323 if (m == mem) {
1324 set_req(MemNode::Memory, mem->in(cnt - i)); // Skip this phi.
1456 Node* mem = in(MemNode::Memory);
1461 Node* opt_mem = MemNode::optimize_memory_chain(mem, addr_t, phase);
1462 if (opt_mem != mem) {
1540 Node* mem = in(MemNode::Memory);
1541 const Type *t1 = phase->type(mem);
1760 Node* value = can_see_stored_value(mem,phase);
1771 Node *mem = in(MemNode::Memory);
1772 if (mem->is_Parm() && mem->in(0)->is_Start()) {
1773 assert(mem->as_Parm()->_con == TypeFunc::Memory, "must be memory Parm");
1794 Node* mem = in(MemNode::Memory);
1795 Node* value = can_see_stored_value(mem,phase);
1805 Node* mem = in(MemNode::Memory);
1806 Node* value = can_see_stored_value(mem,phase);
1826 Node* mem = in(MemNode::Memory);
1827 Node* value = can_see_stored_value(mem, phase);
1835 Node* mem = in(MemNode::Memory);
1836 Node* value = can_see_stored_value(mem,phase);
1856 Node* mem = in(MemNode::Memory);
1857 Node* value = can_see_stored_value(mem,phase);
1865 Node* mem = in(MemNode::Memory);
1866 Node* value = can_see_stored_value(mem,phase);
1886 Node* mem = in(MemNode::Memory);
1887 Node* value = can_see_stored_value(mem,phase);
1897 Node* mem = in(MemNode::Memory);
1898 Node* value = can_see_stored_value(mem,phase);
1913 Node *LoadKlassNode::make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* at, const TypeKlassPtr *tk ) {
1921 Node* load_klass = gvn.transform(new (C) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowoop()));
1926 return new (C) LoadKlassNode(ctl, mem, adr, at, tk);
2235 StoreNode* StoreNode::make( PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, BasicType bt ) {
2242 case T_BYTE: return new (C) StoreBNode(ctl, mem, adr, adr_type, val);
2243 case T_INT: return new (C) StoreINode(ctl, mem, adr, adr_type, val);
2245 case T_SHORT: return new (C) StoreCNode(ctl, mem, adr, adr_type, val);
2246 case T_LONG: return new (C) StoreLNode(ctl, mem, adr, adr_type, val);
2247 case T_FLOAT: return new (C) StoreFNode(ctl, mem, adr, adr_type, val);
2248 case T_DOUBLE: return new (C) StoreDNode(ctl, mem, adr, adr_type, val);
2256 return new (C) StoreNNode(ctl, mem, adr, adr_type, val);
2260 return new (C) StorePNode(ctl, mem, adr, adr_type, val);
2267 StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val) {
2269 return new (C) StoreLNode(ctl, mem, adr, adr_type, val, require_atomic);
2295 Node* mem = in(MemNode::Memory);
2302 if (mem->is_Store() && mem->in(MemNode::Address)->eqv_uncast(address) &&
2303 mem->Opcode() != Op_StoreCM) {
2305 assert(mem != mem->in(MemNode::Memory), "dead loop in StoreNode::Ideal");
2307 assert(Opcode() == mem->Opcode() ||
2311 if (mem->outcnt() == 1 && // check for intervening uses
2312 mem->as_Store()->memory_size() <= this->memory_size()) {
2313 // If anybody other than 'this' uses 'mem', we cannot fold 'mem' away.
2314 // For example, 'mem' might be the final state at a conditional return.
2315 // Or, 'mem' might be used by some node which is live at the same time
2317 // ONE user, the 'this' store, until such time as we clone 'mem' for
2318 // each of 'mem's uses (thus making the exactly-1-user-rule hold true).
2320 set_req_X(MemNode::Memory, mem->in(MemNode::Memory),
2325 set_req(MemNode::Memory, mem->in(MemNode::Memory));
2334 mem->is_Proj() && mem->in(0)->is_Initialize()) {
2335 InitializeNode* init = mem->in(0)->as_Initialize();
2343 mem = MergeMemNode::make(phase->C, mem);
2344 return mem; // fold me away
2369 Node* mem = in(MemNode::Memory);
2376 val->in(MemNode::Memory )->eqv_uncast(mem) &&
2378 return mem;
2382 if (mem->is_Store() &&
2383 mem->in(MemNode::Address)->eqv_uncast(adr) &&
2384 mem->in(MemNode::ValueIn)->eqv_uncast(val) &&
2385 mem->Opcode() == Opcode()) {
2386 return mem;
2394 if (mem->is_Proj() && mem->in(0)->is_Allocate()) {
2395 return mem;
2406 return mem;
2543 Node* mem = my_store->as_MergeMem()->memory_at(oop_alias_idx());
2544 set_req(MemNode::OopStore, mem);
2577 LoadStoreNode::LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required )
2583 init_req(MemNode::Memory , mem);
2606 LoadStoreConditionalNode::LoadStoreConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex ) : LoadStoreNode(c, mem, adr, val, NULL, TypeInt::BOOL, 5) {
2647 Node *mem = in(1);
2648 if( phase->type(mem)==Type::TOP ) return NULL;
2662 mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero);
2665 mem = phase->transform(mem);
2667 mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero);
2669 return mem;
2699 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
2711 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
2712 mem = phase->transform(mem);
2718 return clear_memory(ctl, mem, dest, phase->MakeConX(offset), end_offset, phase);
2721 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
2727 return mem;
2745 mem = new (C) ClearArrayNode(ctl, mem, zsize, adr);
2746 return phase->transform(mem);
2749 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
2755 return mem;
2765 mem = clear_memory(ctl, mem, dest,
2772 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
2773 mem = phase->transform(mem);
2777 return mem;
2795 Node* mem = phase->transform(in(MemNode::Memory));
2798 mem = mem->is_MergeMem() ? mem->as_MergeMem()->memory_at(alias_idx) : mem;
2799 if (mem != in(MemNode::Memory)) {
2800 set_req(MemNode::Memory, mem);
2928 // ctl = incoming control; mem* = incoming memory
2931 // alloc = (Allocate ctl mem* 16 #short[].klass ...)
2932 // ctl := alloc.Control; mem* := alloc.Memory*
2936 // ctl := init.Control; mem.SLICE(#short[*]) := init.Memory
2942 // mem.SLICE(#short[*]) := store2
3031 Node* mem = in(Memory);
3032 if (mem->is_MergeMem()) {
3033 return mem->as_MergeMem()->memory_at(alias_idx);
3036 return mem;
3155 Node* mem = st->in(MemNode::Memory);
3156 if (!(mem->is_Proj() && mem->in(0) == this))
3184 mems.push(mem);
4026 // Make a new, untransformed MergeMem with the same base as 'mem'.
4027 // If mem is itself a MergeMem, populate the result with the same edges.
4028 MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) {
4029 return new(C) MergeMemNode(mem);
4046 Node* mem = in(i);
4047 if (mem != empty_mem && mem != base_mem) {
4260 Node* mem = memory_at(i);
4261 if (mem == base_mem) { st->print(" -"); continue; }
4262 st->print( " N%d:", mem->_idx );
4421 bool MergeMemStream::match_memory(Node* mem, const MergeMemNode* mm, int idx) {
4424 if (mem == n) return true; // might be empty_memory()
4426 if (mem == n) return true;
4428 if (mem == n) return true;