/* Alias analysis for XLOAD/XSTORE. */
static AliasRet aa_xref(jit_State *J, IRIns *refa, IRIns *xa, IRIns *xb)
{
ptrdiff_t ofsa = 0, ofsb = 0;
IRIns *refb = IR(xb->op1);
IRIns *basea = refa, *baseb = refb;
if (refa == refb && irt_sametype(xa->t, xb->t))
return ALIAS_MUST; /* Shortcut for same refs with identical type. */
/* Offset-based disambiguation. */
if (refa->o == IR_ADD && irref_isk(refa->op2)) {
IRIns *irk = IR(refa->op2);
basea = IR(refa->op1);
ofsa = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
(ptrdiff_t)irk->i;
}
if (refb->o == IR_ADD && irref_isk(refb->op2)) {
IRIns *irk = IR(refb->op2);
baseb = IR(refb->op1);
ofsb = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
(ptrdiff_t)irk->i;
}
/* Treat constified pointers like base vs. base+offset. */
if (basea->o == IR_KPTR && baseb->o == IR_KPTR) {
ofsb += (char *)ir_kptr(baseb) - (char *)ir_kptr(basea);
baseb = basea;
}
/* This implements (very) strict aliasing rules.
** Different types do NOT alias, except for differences in signedness.
** Type punning through unions is allowed (but forces a reload).
*/
if (basea == baseb) {
ptrdiff_t sza = irt_size(xa->t), szb = irt_size(xb->t);
if (ofsa == ofsb) {
if (sza == szb && irt_isfp(xa->t) == irt_isfp(xb->t))
return ALIAS_MUST; /* Same-sized, same-kind. May need to convert. */
} else if (ofsa + sza <= ofsb || ofsb + szb <= ofsa) {
return ALIAS_NO; /* Non-overlapping base+-o1 vs. base+-o2. */
}
/* NYI: extract, extend or reinterpret bits (int <-> fp). */
return ALIAS_MAY; /* Overlapping or type punning: force reload. */
}
if (!irt_sametype(xa->t, xb->t) &&
!(irt_typerange(xa->t, IRT_I8, IRT_U64) &&
((xa->t.irt - IRT_I8) ^ (xb->t.irt - IRT_I8)) == 1))
return ALIAS_NO;
/* NYI: structural disambiguation. */
return aa_cnew(J, basea, baseb); /* Try to disambiguate allocations. */
}
/* Alias analysis for XLOAD/XSTORE. */
static AliasRet aa_xref(jit_State *J, IRIns *refa, IRIns *xa, IRIns *xb)
{
ptrdiff_t ofsa = 0, ofsb = 0;
IRIns *refb = IR(xb->op1);
IRIns *basea = refa, *baseb = refb;
/* This implements (very) strict aliasing rules.
** Different types do NOT alias, except for differences in signedness.
** NYI: this also prevents type punning through unions.
*/
if (irt_sametype(xa->t, xb->t)) {
if (refa == refb)
return ALIAS_MUST; /* Shortcut for same refs with identical type. */
} else if (!(irt_typerange(xa->t, IRT_I8, IRT_U64) &&
((xa->t.irt - IRT_I8) ^ (xb->t.irt - IRT_I8)) == 1)) {
return ALIAS_NO;
}
/* Offset-based disambiguation. */
if (refa->o == IR_ADD && irref_isk(refa->op2)) {
IRIns *irk = IR(refa->op2);
basea = IR(refa->op1);
ofsa = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
(ptrdiff_t)irk->i;
if (basea == refb && ofsa != 0)
return ALIAS_NO; /* base+-ofs vs. base. */
}
if (refb->o == IR_ADD && irref_isk(refb->op2)) {
IRIns *irk = IR(refb->op2);
baseb = IR(refb->op1);
ofsb = (LJ_64 && irk->o == IR_KINT64) ? (ptrdiff_t)ir_k64(irk)->u64 :
(ptrdiff_t)irk->i;
if (refa == baseb && ofsb != 0)
return ALIAS_NO; /* base vs. base+-ofs. */
}
if (basea == baseb) {
/* This assumes strictly-typed, non-overlapping accesses. */
if (ofsa != ofsb)
return ALIAS_NO; /* base+-o1 vs. base+-o2 and o1 != o2. */
return ALIAS_MUST; /* Unsigned vs. signed access to the same address. */
}
/* NYI: structural disambiguation. */
return aa_cnew(J, basea, baseb); /* Try to disambiguate allocations. */
}
