Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/memnode.cpp @ 708:f2049ae95c3d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr") Summary: Delay a memory node transformation if its control or address on IGVN worklist. Reviewed-by: never
author kvn
date Tue, 07 Apr 2009 19:04:24 -0700
parents fbde8ec322d0
children 685e959d09ea
comparison
equal deleted inserted replaced
707:4ec1257180ec 708:f2049ae95c3d
216 return this; 216 return this;
217 ctl = in(MemNode::Control); 217 ctl = in(MemNode::Control);
218 // Don't bother trying to transform a dead node 218 // Don't bother trying to transform a dead node
219 if( ctl && ctl->is_top() ) return NodeSentinel; 219 if( ctl && ctl->is_top() ) return NodeSentinel;
220 220
221 PhaseIterGVN *igvn = phase->is_IterGVN();
222 // Wait if control on the worklist.
223 if (ctl && can_reshape && igvn != NULL) {
224 Node* bol = NULL;
225 Node* cmp = NULL;
226 if (ctl->in(0)->is_If()) {
227 assert(ctl->is_IfTrue() || ctl->is_IfFalse(), "sanity");
228 bol = ctl->in(0)->in(1);
229 if (bol->is_Bool())
230 cmp = ctl->in(0)->in(1)->in(1);
231 }
232 if (igvn->_worklist.member(ctl) ||
233 (bol != NULL && igvn->_worklist.member(bol)) ||
234 (cmp != NULL && igvn->_worklist.member(cmp)) ) {
235 // This control path may be dead.
236 // Delay this memory node transformation until the control is processed.
237 phase->is_IterGVN()->_worklist.push(this);
238 return NodeSentinel; // caller will return NULL
239 }
240 }
221 // Ignore if memory is dead, or self-loop 241 // Ignore if memory is dead, or self-loop
222 Node *mem = in(MemNode::Memory); 242 Node *mem = in(MemNode::Memory);
223 if( phase->type( mem ) == Type::TOP ) return NodeSentinel; // caller will return NULL 243 if( phase->type( mem ) == Type::TOP ) return NodeSentinel; // caller will return NULL
224 assert( mem != this, "dead loop in MemNode::Ideal" ); 244 assert( mem != this, "dead loop in MemNode::Ideal" );
225 245
226 Node *address = in(MemNode::Address); 246 Node *address = in(MemNode::Address);
227 const Type *t_adr = phase->type( address ); 247 const Type *t_adr = phase->type( address );
228 if( t_adr == Type::TOP ) return NodeSentinel; // caller will return NULL 248 if( t_adr == Type::TOP ) return NodeSentinel; // caller will return NULL
229 249
230 PhaseIterGVN *igvn = phase->is_IterGVN(); 250 if( can_reshape && igvn != NULL &&
231 if( can_reshape && igvn != NULL && igvn->_worklist.member(address) ) { 251 (igvn->_worklist.member(address) || phase->type(address) != adr_type()) ) {
232 // The address's base and type may change when the address is processed. 252 // The address's base and type may change when the address is processed.
233 // Delay this mem node transformation until the address is processed. 253 // Delay this mem node transformation until the address is processed.
234 phase->is_IterGVN()->_worklist.push(this); 254 phase->is_IterGVN()->_worklist.push(this);
235 return NodeSentinel; // caller will return NULL 255 return NodeSentinel; // caller will return NULL
236 } 256 }
257
258 #ifdef ASSERT
259 Node* base = NULL;
260 if (address->is_AddP())
261 base = address->in(AddPNode::Base);
262 assert(base == NULL || t_adr->isa_rawptr() ||
263 !phase->type(base)->higher_equal(TypePtr::NULL_PTR), "NULL+offs not RAW address?");
264 #endif
237 265
238 // Avoid independent memory operations 266 // Avoid independent memory operations
239 Node* old_mem = mem; 267 Node* old_mem = mem;
240 268
241 // The code which unhooks non-raw memories from complete (macro-expanded) 269 // The code which unhooks non-raw memories from complete (macro-expanded)
1305 phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw ) { 1333 phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw ) {
1306 ctrl = ctrl->in(0); 1334 ctrl = ctrl->in(0);
1307 set_req(MemNode::Control,ctrl); 1335 set_req(MemNode::Control,ctrl);
1308 } 1336 }
1309 1337
1310 // Check for useless control edge in some common special cases 1338 intptr_t ignore = 0;
1311 if (in(MemNode::Control) != NULL) { 1339 Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore);
1312 intptr_t ignore = 0; 1340 if (base != NULL
1313 Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore); 1341 && phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw) {
1314 if (base != NULL 1342 // Check for useless control edge in some common special cases
1343 if (in(MemNode::Control) != NULL
1315 && phase->type(base)->higher_equal(TypePtr::NOTNULL) 1344 && phase->type(base)->higher_equal(TypePtr::NOTNULL)
1316 && phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw
1317 && all_controls_dominate(base, phase->C->start())) { 1345 && all_controls_dominate(base, phase->C->start())) {
1318 // A method-invariant, non-null address (constant or 'this' argument). 1346 // A method-invariant, non-null address (constant or 'this' argument).
1319 set_req(MemNode::Control, NULL); 1347 set_req(MemNode::Control, NULL);
1320 } 1348 }
1321 } 1349
1322 1350 if (EliminateAutoBox && can_reshape) {
1323 if (EliminateAutoBox && can_reshape && in(Address)->is_AddP()) { 1351 assert(!phase->type(base)->higher_equal(TypePtr::NULL_PTR), "the autobox pointer should be non-null");
1324 Node* base = in(Address)->in(AddPNode::Base);
1325 if (base != NULL) {
1326 Compile::AliasType* atp = phase->C->alias_type(adr_type()); 1352 Compile::AliasType* atp = phase->C->alias_type(adr_type());
1327 if (is_autobox_object(atp)) { 1353 if (is_autobox_object(atp)) {
1328 Node* result = eliminate_autobox(phase); 1354 Node* result = eliminate_autobox(phase);
1329 if (result != NULL) return result; 1355 if (result != NULL) return result;
1330 } 1356 }
1453 if (jt->empty() && !t->empty()) { 1479 if (jt->empty() && !t->empty()) {
1454 // This can happen if a interface-typed array narrows to a class type. 1480 // This can happen if a interface-typed array narrows to a class type.
1455 jt = _type; 1481 jt = _type;
1456 } 1482 }
1457 1483
1458 if (EliminateAutoBox) { 1484 if (EliminateAutoBox && adr->is_AddP()) {
1459 // The pointers in the autobox arrays are always non-null 1485 // The pointers in the autobox arrays are always non-null
1460 Node* base = in(Address)->in(AddPNode::Base); 1486 Node* base = adr->in(AddPNode::Base);
1461 if (base != NULL) { 1487 if (base != NULL &&
1488 !phase->type(base)->higher_equal(TypePtr::NULL_PTR)) {
1462 Compile::AliasType* atp = phase->C->alias_type(base->adr_type()); 1489 Compile::AliasType* atp = phase->C->alias_type(base->adr_type());
1463 if (is_autobox_cache(atp)) { 1490 if (is_autobox_cache(atp)) {
1464 return jt->join(TypePtr::NOTNULL)->is_ptr(); 1491 return jt->join(TypePtr::NOTNULL)->is_ptr();
1465 } 1492 }
1466 } 1493 }