Lines Matching defs:base
214 if( tp->base() != Type::AnyPtr &&
282 // The address's base and type may change when the address is processed.
296 Node* base = NULL;
298 base = address->in(AddPNode::Base);
299 if (base != NULL && phase->type(base)->higher_equal(TypePtr::NULL_PTR) &&
301 // Note: raw address has TOP base and top->higher_equal(TypePtr::NULL_PTR) is true.
309 if (C->is_dead_node(base->_idx)) tty->print_cr("'base' is dead");
311 base->dump(1);
316 tty->print("phase->type(base): "); phase->type(address)->dump(); tty->cr();
319 assert(base == NULL || t_adr->isa_rawptr() ||
320 !phase->type(base)->higher_equal(TypePtr::NULL_PTR), "NULL+offs not RAW address?");
454 // Used by MemNode::find_previous_store to prove that two base
496 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
497 AllocateNode* alloc = AllocateNode::Ideal_allocation(base, phase);
532 if (st_base != base &&
533 detect_ptr_independence(base, alloc,
544 if (st_base == base && st_offset == offset) {
867 return Matcher::base2reg[_type->base()];
1138 // Fetch the base value in the autobox array
1148 // Fetch the box object at the base of the array and get its value
1185 Node* base = in(Address)->in(AddPNode::Base);
1186 if (base->is_Phi() && base->req() == 3) {
1190 for (uint i = 1; i < base->req(); i++) {
1191 allocation = AllocateNode::Ideal_allocation(base->in(i), phase);
1199 (base->in(load_index)->is_Load() ||
1200 base->in(load_index)->is_DecodeN() &&
1201 base->in(load_index)->in(1)->is_Load()) );
1202 if (has_load && in(Memory)->is_Phi() && in(Memory)->in(0) == base->in(0)) {
1208 Node* region = base->in(0);
1212 in1_addr->set_req(AddPNode::Base, base->in(allocation_index));
1213 in1_addr->set_req(AddPNode::Address, base->in(allocation_index));
1221 in2_addr->set_req(AddPNode::Base, base->in(load_index));
1222 in2_addr->set_req(AddPNode::Address, base->in(load_index));
1238 } else if (base->is_Load() ||
1239 base->is_DecodeN() && base->in(1)->is_Load()) {
1240 if (base->is_DecodeN()) {
1242 base = base->in(1);
1247 Node* load_base = base->in(Address)->in(AddPNode::Base);
1261 if (cache != NULL && base->in(Address)->is_AddP()) {
1263 int count = base->in(Address)->as_AddP()->unpack_offsets(elements, ARRAY_SIZE(elements));
1417 // If the offset is constant and the base is an object allocation,
1435 Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore);
1436 if (base != NULL
1440 && phase->type(base)->higher_equal(TypePtr::NOTNULL)
1441 && all_controls_dominate(base, phase->C->start())) {
1447 assert(!phase->type(base)->higher_equal(TypePtr::NULL_PTR), "the autobox pointer should be non-null");
1482 // Check for prior store with a different base or offset; make Load
1551 if (tp->base() == Type::AryPtr) {
1576 // We choose T_BYTE as an example base type that is least restrictive
1578 // possible base offset.
1590 Node* base = adr->in(AddPNode::Base);
1591 if (base != NULL &&
1592 !phase->type(base)->higher_equal(TypePtr::NULL_PTR)) {
1593 Compile::AliasType* atp = C->alias_type(base->adr_type());
1602 } else if (tp->base() == Type::InstPtr) {
1616 Node* base = adr->in(AddPNode::Base);
1617 const TypeOopPtr* t = phase->type(base)->isa_oopptr();
1661 } else if (tp->base() == Type::KlassPtr) {
2077 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2078 if (base == NULL) return this;
2085 Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
2106 if (base->is_Load()) {
2107 Node* adr2 = base->in(MemNode::Address);
2176 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2177 if (base == NULL) return NULL;
2184 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(base, phase);
2208 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2209 if (base == NULL) return this;
2216 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(base, phase);
2590 return Matcher::base2reg[_type->base()];
2656 // Get base for derived pointer purposes
2658 Node *base = adr->in(1);
2666 adr = phase->transform(new (phase->C) AddPNode(base,adr,off));
3091 Node* base = AddPNode::Ideal_base_and_offset(st->in(MemNode::Address),
3093 if (base == NULL) return -1; // something is dead,
3225 Node* base = other_adr;
3226 assert(base->is_AddP(), err_msg_res("should be addp but is %s", base->Name()));
3227 base = base->in(AddPNode::Base);
3228 if (base != NULL) {
3229 base = base->uncast();
3230 if (base->is_Proj() && base->in(0) == alloc) {
3973 // it returns the base memory. To prevent bugs, memory_at does not accept <Top>
3984 // that "emerges though" the base memory will be marked as excluding the alias types
4026 // Make a new, untransformed MergeMem with the same base as 'mem'.
4079 // simplify stacked MergeMems in base memory
4082 // the base memory might contribute new slices beyond my req()
4085 // Look carefully at the base node if it is a phi.
4232 assert(progress || verify_sparse(), "please, no dups of base");
4344 // Give it a pass: It is a mostly harmless repetition of the base.