Crashing loads of uninitialized memory proved to be a problem when implementing unions using qbe. This patch introduces a new UNDEF Ref to represent data that is known to be uninitialized. Optimization passes can make use of it to eliminate some code. In the last compilation stages, UNDEF is treated as the constant 0xdeaddead.
Unified · Split
| @@ -90,10 +90,11 @@ enum { · 89 unmodified lines | ||
| 90 | 90 | RMem, |
| 91 | 91 | }; |
| 92 | 92 | |
| 93 | −#define R (Ref){0, 0} | |
| 93 | +#define R (Ref){RTmp, 0} | |
| 94 | +#define UNDEF (Ref){RCon, 0} /* represents uninitialized data */ | |
| 95 | +#define CON_Z (Ref){RCon, 1} | |
| 94 | 96 | #define TMP(x) (Ref){RTmp, x} |
| 95 | 97 | #define CON(x) (Ref){RCon, x} |
| 96 | −#define CON_Z CON(0) /* reserved zero constant */ | |
| 97 | 98 | #define SLOT(x) (Ref){RSlot, (x)&0x1fffffff} |
| 98 | 99 | #define TYPE(x) (Ref){RType, x} |
| 99 | 100 | #define CALL(x) (Ref){RCall, x} |
| @@ -482,7 +482,7 @@ seljmp(Blk *b, Fn *fn) · 481 unmodified lines | ||
| 482 | 482 | } |
| 483 | 483 | fi = flagi(b->ins, &b->ins[b->nins]); |
| 484 | 484 | if (!fi || !req(fi->to, r)) { |
| 485 | − selcmp((Ref[2]){r, CON_Z}, Kw, 0, fn); /* todo, long jnz */ | |
| 485 | + selcmp((Ref[2]){r, CON_Z}, Kw, 0, fn); | |
| 486 | 486 | b->jmp.type = Jjf + Cine; |
| 487 | 487 | } |
| 488 | 488 | else if (iscmp(fi->op, &k, &c) |
| @@ -125,7 +125,7 @@ subst(Ref *pr, Ref *cpy) · 124 unmodified lines | ||
| 125 | 125 | *pr = copyof(*pr, cpy); |
| 126 | 126 | } |
| 127 | 127 | |
| 128 | −/* requires use and rpo, breaks use */ | |
| 128 | +/* requires use and dom, breaks use */ | |
| 129 | 129 | void |
| 130 | 130 | copy(Fn *fn) |
| 131 | 131 | { |
| @@ -155,12 +155,16 @@ copy(Fn *fn) · 23 unmodified lines | ||
| 155 | 155 | for (a=0; a<p->narg; a++) |
| 156 | 156 | if (p->blk[a]->id < n) { |
| 157 | 157 | r1 = copyof(p->arg[a], cpy); |
| 158 | − if (req(r, R) || req(r1, r)) | |
| 158 | + if (req(r, R) || req(r, UNDEF)) | |
| 159 | + r = r1; | |
| 160 | + if (req(r1, r) || req(r1, UNDEF)) | |
| 159 | 161 | eq++; |
| 160 | − r = r1; | |
| 161 | 162 | } |
| 162 | 163 | assert(!req(r, R)); |
| 163 | − if (eq == p->narg) | |
| 164 | + if (rtype(r) == RTmp | |
| 165 | + && !dom(fn->rpo[fn->tmp[r.val].bid], b)) | |
| 166 | + cpy[p->to.val] = p->to; | |
| 167 | + else if (eq == p->narg) | |
| 164 | 168 | cpy[p->to.val] = r; |
| 165 | 169 | else { |
| 166 | 170 | cpy[p->to.val] = p->to; |
| @@ -1,8 +1,8 @@ | ||
| 1 | 1 | #include "all.h" |
| 2 | 2 | |
| 3 | 3 | enum { |
| 4 | − Bot = -2, /* lattice bottom */ | |
| 5 | − Top = -1, /* lattice top */ | |
| 4 | + Bot = -1, /* lattice bottom */ | |
| 5 | + Top = 0, /* lattice top (matches UNDEF) */ | |
| 6 | 6 | }; |
| 7 | 7 | |
| 8 | 8 | typedef struct Edge Edge; |
| @@ -126,7 +126,6 @@ visitjmp(Blk *b, int n, Fn *fn) · 117 unmodified lines | ||
| 126 | 126 | switch (b->jmp.type) { |
| 127 | 127 | case Jjnz: |
| 128 | 128 | l = latval(b->jmp.arg); |
| 129 | − assert(l != Top && "ssa invariant broken"); | |
| 130 | 129 | if (l == Bot) { |
| 131 | 130 | edge[n][1].work = flowrk; |
| 132 | 131 | edge[n][0].work = &edge[n][1]; |
| @@ -174,7 +173,6 @@ renref(Ref *r) · 41 unmodified lines | ||
| 174 | 173 | |
| 175 | 174 | if (rtype(*r) == RTmp) |
| 176 | 175 | if ((l=val[r->val]) != Bot) { |
| 177 | − assert(l != Top && "ssa invariant broken"); | |
| 178 | 176 | *r = CON(l); |
| 179 | 177 | return 1; |
| 180 | 178 | } |
| @@ -294,9 +292,13 @@ fold(Fn *fn) · 113 unmodified lines | ||
| 294 | 292 | for (i=b->ins; i<&b->ins[b->nins]; i++) |
| 295 | 293 | if (renref(&i->to)) |
| 296 | 294 | *i = (Ins){.op = Onop}; |
| 297 | − else | |
| 295 | + else { | |
| 298 | 296 | for (n=0; n<2; n++) |
| 299 | 297 | renref(&i->arg[n]); |
| 298 | + if (isstore(i->op)) | |
| 299 | + if (req(i->arg[0], UNDEF)) | |
| 300 | + *i = (Ins){.op = Onop}; | |
| 301 | + } | |
| 300 | 302 | renref(&b->jmp.arg); |
| 301 | 303 | if (b->jmp.type == Jjnz && rtype(b->jmp.arg) == RCon) { |
| 302 | 304 | if (iscon(&fn->con[b->jmp.arg.val], 0, 0)) { |
| @@ -201,7 +201,7 @@ coalesce(Fn *fn) · 200 unmodified lines | ||
| 201 | 201 | Ref *arg; |
| 202 | 202 | bits x; |
| 203 | 203 | int64_t off0, off1; |
| 204 | − int n, m, sz, nsl, nbl, ip, *stk; | |
| 204 | + int n, m, ip, sz, nsl, nbl, *stk; | |
| 205 | 205 | uint total, freed, fused; |
| 206 | 206 | |
| 207 | 207 | /* minimize the stack usage |
| @@ -317,26 +317,31 @@ coalesce(Fn *fn) · 109 unmodified lines | ||
| 317 | 317 | while (n--) { |
| 318 | 318 | t = &fn->tmp[stk[n]]; |
| 319 | 319 | assert(t->ndef == 1 && t->def); |
| 320 | − *t->def = (Ins){.op = Onop}; | |
| 320 | + i = t->def; | |
| 321 | + if (isload(i->op)) { | |
| 322 | + i->op = Ocopy; | |
| 323 | + i->arg[0] = UNDEF; | |
| 324 | + continue; | |
| 325 | + } | |
| 326 | + *i = (Ins){.op = Onop}; | |
| 321 | 327 | for (u=t->use; u<&t->use[t->nuse]; u++) { |
| 322 | 328 | if (u->type == UJmp) { |
| 323 | 329 | b = fn->rpo[u->bid]; |
| 324 | − b->jmp.arg = CON_Z; | |
| 330 | + assert(isret(b->jmp.type)); | |
| 331 | + b->jmp.type = Jret0; | |
| 332 | + b->jmp.arg = R; | |
| 325 | 333 | continue; |
| 326 | 334 | } |
| 327 | 335 | assert(u->type == UIns); |
| 328 | 336 | i = u->u.ins; |
| 329 | − /* make loads crash */ | |
| 330 | − if (isload(i->op)) | |
| 331 | − i->arg[0] = CON_Z; | |
| 332 | − else if (i->op == Oargc) | |
| 333 | − i->arg[1] = CON_Z; | |
| 334 | − else if (!req(i->to, R)) { | |
| 337 | + if (!req(i->to, R)) { | |
| 335 | 338 | assert(rtype(i->to) == RTmp); |
| 336 | 339 | vgrow(&stk, ++n); |
| 337 | 340 | stk[n-1] = i->to.val; |
| 341 | + } else if (isarg(i->op)) { | |
| 342 | + assert(i->op == Oargc); | |
| 343 | + i->arg[1] = CON_Z; /* crash */ | |
| 338 | 344 | } else { |
| 339 | − assert(!isarg(i->op)); | |
| 340 | 345 | if (i->op == Oblit0) |
| 341 | 346 | *(i+1) = (Ins){.op = Onop}; |
| 342 | 347 | *i = (Ins){.op = Onop}; |
| @@ -867,7 +867,7 @@ parsefn(Lnk *lnk) · 866 unmodified lines | ||
| 867 | 867 | curi = insb; |
| 868 | 868 | curf = alloc(sizeof *curf); |
| 869 | 869 | curf->ntmp = 0; |
| 870 | − curf->ncon = 1; /* first constant must be 0 */ | |
| 870 | + curf->ncon = 2; | |
| 871 | 871 | curf->tmp = vnew(curf->ntmp, sizeof curf->tmp[0], PFn); |
| 872 | 872 | curf->con = vnew(curf->ncon, sizeof curf->con[0], PFn); |
| 873 | 873 | for (i=0; i<Tmp0; ++i) |
| @@ -876,6 +876,8 @@ parsefn(Lnk *lnk) · 2 unmodified lines | ||
| 876 | 876 | else |
| 877 | 877 | newtmp(0, Kl, curf); |
| 878 | 878 | curf->con[0].type = CBits; |
| 879 | + curf->con[0].bits.i = 0xdeaddead; /* UNDEF */ | |
| 880 | + curf->con[1].type = CBits; | |
| 879 | 881 | curf->lnk = *lnk; |
| 880 | 882 | blink = &curf->start; |
| 881 | 883 | curf->retty = Kx; |
| @@ -1230,7 +1232,10 @@ printref(Ref r, Fn *fn, FILE *f) · 348 unmodified lines | ||
| 1230 | 1232 | fprintf(f, "%%%s", fn->tmp[r.val].name); |
| 1231 | 1233 | break; |
| 1232 | 1234 | case RCon: |
| 1233 | − printcon(&fn->con[r.val], f); | |
| 1235 | + if (req(r, UNDEF)) | |
| 1236 | + fprintf(f, "UNDEF"); | |
| 1237 | + else | |
| 1238 | + printcon(&fn->con[r.val], f); | |
| 1234 | 1239 | break; |
| 1235 | 1240 | case RSlot: |
| 1236 | 1241 | fprintf(f, "S%d", rsval(r)); |
| @@ -264,7 +264,7 @@ getstk(int t, Blk *b, Name **stk) · 263 unmodified lines | ||
| 264 | 264 | stk[t] = n; |
| 265 | 265 | if (!n) { |
| 266 | 266 | /* uh, oh, warn */ |
| 267 | − return CON_Z; | |
| 267 | + return UNDEF; | |
| 268 | 268 | } else |
| 269 | 269 | return n->r; |
| 270 | 270 | } |
| @@ -361,7 +361,7 @@ newcon(Con *c0, Fn *fn) · 360 unmodified lines | ||
| 361 | 361 | Con *c1; |
| 362 | 362 | int i; |
| 363 | 363 | |
| 364 | − for (i=0; i<fn->ncon; i++) { | |
| 364 | + for (i=1; i<fn->ncon; i++) { | |
| 365 | 365 | c1 = &fn->con[i]; |
| 366 | 366 | if (c0->type == c1->type |
| 367 | 367 | && symeq(c0->sym, c1->sym) |
| @@ -378,8 +378,9 @@ getcon(int64_t val, Fn *fn) · 10 unmodified lines | ||
| 378 | 378 | { |
| 379 | 379 | int c; |
| 380 | 380 | |
| 381 | − for (c=0; c<fn->ncon; c++) | |
| 382 | − if (fn->con[c].type == CBits && fn->con[c].bits.i == val) | |
| 381 | + for (c=1; c<fn->ncon; c++) | |
| 382 | + if (fn->con[c].type == CBits | |
| 383 | + && fn->con[c].bits.i == val) | |
| 383 | 384 | return CON(c); |
| 384 | 385 | vgrow(&fn->con, ++fn->ncon); |
| 385 | 386 | fn->con[c] = (Con){.type = CBits, .bits.i = val}; |