Mercurial > hg > graal-compiler
comparison src/share/vm/opto/memnode.cpp @ 708:f2049ae95c3d
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 } |