Lines Matching refs:address
169 // clone the Phi with our address type
275 Node *address = in(MemNode::Address);
276 const Type *t_adr = phase->type(address);
280 (igvn->_worklist.member(address) ||
282 // The address's base and type may change when the address is processed.
283 // Delay this mem node transformation until the address is processed.
297 if (address->is_AddP())
298 base = address->in(AddPNode::Base);
301 // Note: raw address has TOP base and top->higher_equal(TypePtr::NULL_PTR) is true.
304 tty->print_cr("===== NULL+offs not RAW address =====");
308 if (C->is_dead_node(address->_idx)) tty->print_cr("'address' is dead");
315 tty->print("phase->type(address): "); t_adr->dump(); tty->cr();
316 tty->print("phase->type(base): "); phase->type(address)->dump(); tty->cr();
320 !phase->type(base)->higher_equal(TypePtr::NULL_PTR), "NULL+offs not RAW address?");
618 // Helper function. Notices when the given type of address hits top or bottom.
619 // Also, asserts a cross-check of the type against the expected address type.
642 // The type of the address must be contained in the adr_type,
647 "real address must not escape from expected memory type");
795 // These usually stick around to change address type, however a
1079 // Loads are identity if previous store is to same address
1082 // to the same address, then we are equal to the value stored.
1267 // Add up all the offsets making of the address of the load
1272 // Remove the constant offset from the address and then
1297 Node* address = in(MemNode::Address);
1298 const TypePtr *addr_t = phase->type(address)->isa_ptr();
1337 // Skip the split if the region dominates some control edge of the address.
1338 if (!MemNode::all_controls_dominate(address, region))
1424 Node* address = in(MemNode::Address);
1429 phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw ) {
1435 Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore);
1437 && phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw) {
1442 // A method-invariant, non-null address (constant or 'this' argument).
1457 const TypePtr *addr_t = phase->type(address)->isa_ptr();
1781 // Do we Match on this edge index or not? Match only the address.
1788 // If the previous store is to the same address as this load,
1820 // If the previous store is to the same address as this load,
1850 // If the previous store is to the same address as this load,
1880 // If the previous store is to the same address as this load,
2073 // Take apart the address into an oop and and offset.
2172 // Take apart the address into an oop and and offset.
2204 // Take apart the address into an oop and and offset.
2296 Node* address = in(MemNode::Address);
2298 // Back-to-back stores to same address? Fold em up. Generally
2302 if (mem->is_Store() && mem->in(MemNode::Address)->eqv_uncast(address) &&
2471 // address stored to, not just for loads of the value stored by this node.
2479 return false; // if not a distinct instance, there may be aliases of the address
2653 // adjust atp to be the correct array element address type
2958 // derived from the raw address produced by AllocateNode, and with
2991 // new oop address associated with the allocation/initialization.
2993 // A write to the memory state, if it matches control and address,
3162 return FAIL; // inscrutable address
3334 // Create, as a raw pointer, an address within my new object at 'offset'.
3413 address addr = (address)tiles + st_off;
3414 assert(st_off >= 0 && addr+st_size <= (address)&tiles[num_tiles], "oob");
3565 jint con0, con1; // split the constant, address-wise
3566 jint init0, init1; // split the init map, address-wise
3939 // REPRESENTATION OF MEMORY MERGES: The indexes used to address the Node::in array
4332 || n->adr_type() == NULL // address is TOP