From ec4cfe9db9afc1d1c633a922174f5bb0685b0c32 Mon Sep 17 00:00:00 2001 From: lemon Date: Fri, 21 Nov 2025 16:49:53 +0100 Subject: change op names to match 285063eba44 --- amd64/emit.c | 48 ++++++++++---------- amd64/isel.c | 26 +++++------ amd64/sysv.c | 22 ++++----- c/c.c | 40 ++++++++-------- io.c | 2 +- ir/abi0.c | 26 +++++------ ir/builder.c | 10 ++-- ir/fold.c | 32 ++++++------- ir/intrin.c | 4 +- ir/ir.h | 4 +- ir/op.def | 144 +++++++++++++++++++++++++++++----------------------------- ir/optmem.c | 42 ++++++++--------- ir/regalloc.c | 22 ++++----- 13 files changed, 211 insertions(+), 211 deletions(-) diff --git a/amd64/emit.c b/amd64/emit.c index 6ef6df3..a7bf542 100644 --- a/amd64/emit.c +++ b/amd64/emit.c @@ -953,36 +953,36 @@ emitinstr(uchar **pcode, struct function *fn, struct block *blk, int curi, struc default: fatal(NULL, "amd64: in %y; unimplemented instr '%s'", fn->name, opnames[ins->op]); case Onop: break; - case Ostore1: cls = KI32, X = Xmovb; goto Store; - case Ostore2: cls = KI32, X = Xmovw; goto Store; - case Ostore4: cls = KI32, X = Xmov; goto Store; - case Ostore8: cls = KI64, X = Xmov; + case Ostore8: cls = KI32, X = Xmovb; goto Store; + case Ostore16: cls = KI32, X = Xmovw; goto Store; + case Ostore32: cls = KI32, X = Xmov; goto Store; + case Ostore64: cls = KI64, X = Xmov; Store: src = mkimmregoper(ins->r); if (cls == KI32 && src.t == OREG && src.reg >= XMM0) cls = KF32; if (cls == KI64 && src.t == OREG && src.reg >= XMM0) cls = KF64; X(pcode, cls, mkmemoper(ins->l), src); break; - case Oexts1: src = mkregoper(ins->l); goto Movsxb; - case Oextu1: src = mkregoper(ins->l); goto Movzxb; - case Oexts2: src = mkregoper(ins->l); goto Movsxw; - case Oextu2: src = mkregoper(ins->l); goto Movzxw; - case Oexts4: src = mkregoper(ins->l); goto Movsxl; - case Oextu4: src = mkregoper(ins->l); goto Movzxl; - case Oloads1: src = mkmemoper(ins->l); Movsxb: Xmovsxb(pcode, cls, reg2oper(ins->reg-1), src); break; - case Oloadu1: src = mkmemoper(ins->l); Movzxb: Xmovzxb(pcode, cls, reg2oper(ins->reg-1), src); break; - case Oloads2: src = mkmemoper(ins->l); Movsxw: Xmovsxw(pcode, cls, reg2oper(ins->reg-1), src); break; - case Oloadu2: src = mkmemoper(ins->l); Movzxw: Xmovzxw(pcode, cls, reg2oper(ins->reg-1), src); break; - case Oloads4: src = mkmemoper(ins->l); Movsxl: Xmovsxl(pcode, cls, reg2oper(ins->reg-1), src); break; - case Oloadu4: src = mkmemoper(ins->l); Movzxl: Xmov(pcode, KI32, reg2oper(ins->reg-1), src); break; - case Oloadf4: case Oloadf8: Xmov(pcode, cls, reg2oper(ins->reg-1), mkmemoper(ins->l)); break; - case Oloadi8: Xmov(pcode, KI64, reg2oper(ins->reg-1), mkmemoper(ins->l)); break; - case Ocvtf4f8: X = Xcvtss2sd; goto FloatsCvt; - case Ocvtf8f4: X = Xcvtsd2ss; goto FloatsCvt; - case Ocvtf4s: X = Xcvttss2si; goto FloatsCvt; - case Ocvtf8s: X = Xcvttsd2si; goto FloatsCvt; - case Ocvts4f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI32; goto FloatsCvt; - case Ocvts8f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI64; goto FloatsCvt; + case Oexts8: src = mkregoper(ins->l); goto Movsxb; + case Oextu8: src = mkregoper(ins->l); goto Movzxb; + case Oexts16: src = mkregoper(ins->l); goto Movsxw; + case Oextu16: src = mkregoper(ins->l); goto Movzxw; + case Oexts32: src = mkregoper(ins->l); goto Movsxl; + case Oextu32: src = mkregoper(ins->l); goto Movzxl; + case Oloads8: src = mkmemoper(ins->l); Movsxb: Xmovsxb(pcode, cls, reg2oper(ins->reg-1), src); break; + case Oloadu8: src = mkmemoper(ins->l); Movzxb: Xmovzxb(pcode, cls, reg2oper(ins->reg-1), src); break; + case Oloads16: src = mkmemoper(ins->l); Movsxw: Xmovsxw(pcode, cls, reg2oper(ins->reg-1), src); break; + case Oloadu16: src = mkmemoper(ins->l); Movzxw: Xmovzxw(pcode, cls, reg2oper(ins->reg-1), src); break; + case Oloads32: src = mkmemoper(ins->l); Movsxl: Xmovsxl(pcode, cls, reg2oper(ins->reg-1), src); break; + case Oloadu32: src = mkmemoper(ins->l); Movzxl: Xmov(pcode, KI32, reg2oper(ins->reg-1), src); break; + case Oloadf32: case Oloadf64: Xmov(pcode, cls, reg2oper(ins->reg-1), mkmemoper(ins->l)); break; + case Oloadi64: Xmov(pcode, KI64, reg2oper(ins->reg-1), mkmemoper(ins->l)); break; + case Ocvtf32f64: X = Xcvtss2sd; goto FloatsCvt; + case Ocvtf64f32: X = Xcvtsd2ss; goto FloatsCvt; + case Ocvtf32s: X = Xcvttss2si; goto FloatsCvt; + case Ocvtf64s: X = Xcvttsd2si; goto FloatsCvt; + case Ocvts32f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI32; goto FloatsCvt; + case Ocvts64f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI64; goto FloatsCvt; FloatsCvt: X(pcode, cls, reg2oper(ins->reg-1), mkdatregoper(ins->l)); break; diff --git a/amd64/isel.c b/amd64/isel.c index 904fdbd..b17e541 100644 --- a/amd64/isel.c +++ b/amd64/isel.c @@ -139,7 +139,7 @@ selcall(struct function *fn, struct instr *ins, struct block *blk, int *curi) *arg = mkinstr(Omove, call->abiarg[i].ty.cls, mkref(RREG, abi.reg), arg->r); } else { union ref adr = mkaddr((struct addr){mkref(RREG, RSP), .disp = abi.stk}); - *arg = mkinstr(Ostore1+ilog2(cls2siz[abi.ty.cls]), 0, adr, arg->r); + *arg = mkinstr(Ostore8+ilog2(cls2siz[abi.ty.cls]), 0, adr, arg->r); } } if (call->argstksiz) { @@ -485,32 +485,32 @@ sel(struct function *fn, struct instr *ins, struct block *blk, int *curi) if (op == Oadd && isaddrcon(ins->r,1)) /* no 3-address add if rhs is mem */ ins->inplace = 1; break; - case Oloads1: case Oloadu1: case Oloads2: case Oloadu2: - case Oloads4: case Oloadu4: case Oloadi8: case Oloadf4: case Oloadf8: + case Oloads8: case Oloadu8: case Oloads16: case Oloadu16: + case Oloads32: case Oloadu32: case Oloadi64: case Oloadf32: case Oloadf64: loadstoreaddr(blk, &ins->l, curi); break; - case Ostore1: case Ostore2: case Ostore4: case Ostore8: + case Ostore8: case Ostore16: case Ostore32: case Ostore64: loadstoreaddr(blk, &ins->l, curi); if (isaddrcon(ins->r,1) || ins->r.t == RADDR) ins->r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, KPTR, ins->r)); else fixarg(&ins->r, ins, blk, curi); break; - case Ocvtu4f: + case Ocvtu32f: fixarg(&ins->l, ins, blk, curi); - ins->l = insertinstr(blk, (*curi)++, mkinstr(Oextu4, KI64, ins->l)); - ins->op = Ocvts8f; + ins->l = insertinstr(blk, (*curi)++, mkinstr(Oextu32, KI64, ins->l)); + ins->op = Ocvts64f; break; - case Ocvtf4u: case Ocvtf8u: + case Ocvtf32u: case Ocvtf64u: fixarg(&ins->l, ins, blk, curi); if (ins->cls == KI32) { - ins->l = insertinstr(blk, (*curi)++, mkinstr(ins->op == Ocvtf4u ? Ocvtf4s : Ocvtf8s, KI64, ins->l)); - ins->op = Oextu4; + ins->l = insertinstr(blk, (*curi)++, mkinstr(ins->op == Ocvtf32u ? Ocvtf32s : Ocvtf64s, KI64, ins->l)); + ins->op = Oextu32; } else assert(!"nyi flt -> u64"); break; - case Ocvtf4f8: case Ocvtf8f4: case Ocvtf4s: case Ocvtf8s: case Ocvts4f: case Ocvts8f: - case Ocvtu8f: - case Oexts1: case Oextu1: case Oexts2: case Oextu2: case Oexts4: case Oextu4: + case Ocvtf32f64: case Ocvtf64f32: case Ocvtf32s: case Ocvtf64s: case Ocvts32f: case Ocvts64f: + case Ocvtu64f: + case Oexts8: case Oextu8: case Oexts16: case Oextu16: case Oexts32: case Oextu32: if (isnumcon(ins->l)) { union ref it; bool ok = foldunop(&it, ins->op, ins->cls, ins->l); diff --git a/amd64/sysv.c b/amd64/sysv.c index e69797b..7410499 100644 --- a/amd64/sysv.c +++ b/amd64/sysv.c @@ -195,16 +195,16 @@ vastart(struct function *fn, struct block *blk, int *curi) *ins = mkinstr(Oadd, KPTR, ap, mkref(RICON, 16)); dst = mkref(RTMP, ins - instrtab); int i = *curi + 1; - insertinstr(blk, i++, mkinstr(Ostore8, 0, dst, rsave)); + insertinstr(blk, i++, mkinstr(Ostore64, 0, dst, rsave)); /* set ap->overflow_arg_area */ src = insertinstr(blk, i++, mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkref(RICON, 16+stk0))); dst = insertinstr(blk, i++, mkinstr(Oadd, KPTR, ap, mkref(RICON, 8))); - insertinstr(blk, i++, mkinstr(Ostore8, 0, dst, src)); + insertinstr(blk, i++, mkinstr(Ostore64, 0, dst, src)); /* set ap->gp_offset */ - insertinstr(blk, i++, mkinstr(Ostore4, 0, ap, mkref(RICON, gpr0*8))); + insertinstr(blk, i++, mkinstr(Ostore32, 0, ap, mkref(RICON, gpr0*8))); /* set ap->fp_offset */ dst = insertinstr(blk, i++, mkinstr(Oadd, KPTR, ap, mkref(RICON, 4))); - insertinstr(blk, i++, mkinstr(Ostore4, 0, dst, mkref(RICON, 6*8 + fpr0*8))); + insertinstr(blk, i++, mkinstr(Ostore32, 0, dst, mkref(RICON, 6*8 + fpr0*8))); *curi = i; } @@ -230,7 +230,7 @@ vaarg(struct function *fn, struct block *blk, int *curi) union ref phi, phiargs[2]; if (ni) { /* l->gp_offset < 48 - num_gp * 8 */ - tmp = insertinstr(blk, (*curi)++, mkinstr(Oloadu4, KI32, ap)); + tmp = insertinstr(blk, (*curi)++, mkinstr(Oloadu32, KI32, ap)); tmp = insertinstr(blk, (*curi)++, mkinstr(Oulte, KI32, tmp, mkref(RICON, 48 - ni*8))); merge = blksplitafter(fn, blk, *curi); blk->jmp.t = 0; @@ -239,12 +239,12 @@ vaarg(struct function *fn, struct block *blk, int *curi) useblk(fn, blk->s1); { /* phi0: &l->reg_save_area[l->gp_offset] */ - union ref sav = addinstr(fn, mkinstr(Oloadi8, KPTR, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 16)))); - union ref gpoff = addinstr(fn, mkinstr(Oloadu4, KI32, ap)); + union ref sav = addinstr(fn, mkinstr(Oloadi64, KPTR, irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 16)))); + union ref gpoff = addinstr(fn, mkinstr(Oloadu32, KI32, ap)); phiargs[0] = irbinop(fn, Oadd, KPTR, sav, gpoff); /* l->gp_offset += num_gp * 8 */ gpoff = irbinop(fn, Oadd, KI32, gpoff, mkref(RICON, ni * 8)); - addinstr(fn, mkinstr(Ostore4, 0, ap, gpoff)); + addinstr(fn, mkinstr(Ostore32, 0, ap, gpoff)); assert(merge->npred == 1); blkpred(merge, 0) = blk->s1; blk->s1->jmp.t = Jb; @@ -254,13 +254,13 @@ vaarg(struct function *fn, struct block *blk, int *curi) { /* phi1: l->overflow_arg_area */ union ref adr = irbinop(fn, Oadd, KPTR, ap, mkref(RICON, 8)); - union ref ovf = addinstr(fn, mkinstr(Oloadi8, KPTR, adr)); + union ref ovf = addinstr(fn, mkinstr(Oloadi64, KPTR, adr)); /* align no-op */ phiargs[1] = ovf; /* update l->overflow_arg_area += num_gp*8 */ int siz = 8; - addinstr(fn, mkinstr(Ostore8, 0, adr, irbinop(fn, Oadd, KPTR, ovf, mkref(RICON, siz)))); + addinstr(fn, mkinstr(Ostore64, 0, adr, irbinop(fn, Oadd, KPTR, ovf, mkref(RICON, siz)))); putbranch(fn, merge); } assert(merge->npred == 2); @@ -269,7 +269,7 @@ vaarg(struct function *fn, struct block *blk, int *curi) merge->ins.p[0] = var; phi = insertphi(merge, KPTR); memcpy(phitab.p[instrtab[phi.i].l.i], phiargs, sizeof phiargs); - instrtab[var] = mkinstr(cls[0] == KI32 ? Oloads4 : Oloadi8, cls[0], phi); + instrtab[var] = mkinstr(cls[0] == KI32 ? Oloads32 : Oloadi64, cls[0], phi); } else { assert(0&&nf); } diff --git a/c/c.c b/c/c.c index c45b1fc..cc82950 100644 --- a/c/c.c +++ b/c/c.c @@ -2703,10 +2703,10 @@ genload(struct function *fn, union type t, union ref ref, bool volatyl) ins.cls = type2cls[scalartypet(t)]; assert(ins.cls); switch (typesize(t)) { - case 1: ins.op = issigned(t) ? Oloads1 : Oloadu1; break; - case 2: ins.op = issigned(t) ? Oloads2 : Oloadu2; break; - case 4: ins.op = isflt(t) ? Oloadf4 : issigned(t) ? Oloads4 : Oloadu4; break; - case 8: ins.op = isflt(t) ? Oloadf8 : Oloadi8; break; + case 1: ins.op = issigned(t) ? Oloads8 : Oloadu8; break; + case 2: ins.op = issigned(t) ? Oloads16 : Oloadu16; break; + case 4: ins.op = isflt(t) ? Oloadf32 : issigned(t) ? Oloads32 : Oloadu32; break; + case 8: ins.op = isflt(t) ? Oloadf64 : Oloadi64; break; default: assert(0); } ins.l = ref; @@ -2721,10 +2721,10 @@ genstore(struct function *fn, union type t, union ref ptr, union ref val) assert(isscalar(t)); switch (typesize(t)) { - case 1: ins.op = Ostore1; break; - case 2: ins.op = Ostore2; break; - case 4: ins.op = Ostore4; break; - case 8: ins.op = Ostore8; break; + case 1: ins.op = Ostore8; break; + case 2: ins.op = Ostore16; break; + case 4: ins.op = Ostore32; break; + case 8: ins.op = Ostore64; break; default: assert(0); } ins.l = ptr; @@ -2758,7 +2758,7 @@ geninit(struct function *fn, union type t, union ref dst, const struct expr *src /* write individual zeros at non initialized gaps */ for (uint i = 0; bsiter(&i, azero, arraylength(azero)) && i < siz; i += align) { adr = irbinop(fn, Oadd, KPTR, dst, mkref(RICON, i)); - addinstr(fn, mkinstr(Ostore1 + ilog2(align), 0, .l = adr, .r = ZEROREF)); + addinstr(fn, mkinstr(Ostore8 + ilog2(align), 0, .l = adr, .r = ZEROREF)); } } else { goto Memset0; @@ -2837,7 +2837,7 @@ isboollike(struct function *fn, union ref r) } if (in_range(ins->op, Oand, Oxor)) return isboollike(fn, ins->l) && isboollike(fn, ins->r); - if (ins->op == Ocopy || in_range(ins->op, Oexts1, Oextu4)) + if (ins->op == Ocopy || in_range(ins->op, Oexts8, Oextu32)) return isboollike(fn, ins->l); if (ins->op == Oparam) return typedata[fn->fnty.dat].param[ins->l.i].t == TYBOOL; @@ -2858,13 +2858,13 @@ cvt(struct function *fn, union type to, union type from, union ref ref) assert(kisflt(kto) && kisint(kfrom)); return mkfltcon(kto, kto == KF32 ? (float)ref.i : (double)ref.i); } - if (kisflt(kto) && kfrom == KI32) op = issigned(from) ? Ocvts4f : Ocvtu4f; + if (kisflt(kto) && kfrom == KI32) op = issigned(from) ? Ocvts32f : Ocvtu32f; else if (to.t == TYBOOL && kisflt(kfrom)) return irbinop(fn, Oneq, kfrom, ref, mkfltcon(kfrom, 0.0)); - else if (kisflt(kto) && kfrom == KI64) op = issigned(from) ? Ocvts8f : Ocvtu8f; - else if (kto == KF64 && kfrom == KF32) op = Ocvtf4f8; - else if (kto == KF32 && kfrom == KF64) op = Ocvtf8f4; - else if (kfrom == KF32) op = issigned(to) ? Ocvtf4s : Ocvtf4u; - else if (kfrom == KF64) op = issigned(to) ? Ocvtf8s : Ocvtf8u; + else if (kisflt(kto) && kfrom == KI64) op = issigned(from) ? Ocvts64f : Ocvtu64f; + else if (kto == KF64 && kfrom == KF32) op = Ocvtf32f64; + else if (kto == KF32 && kfrom == KF64) op = Ocvtf64f32; + else if (kfrom == KF32) op = issigned(to) ? Ocvtf32s : Ocvtf32u; + else if (kfrom == KF64) op = issigned(to) ? Ocvtf64s : Ocvtf64u; else assert(0); } else { if (to.t == TYBOOL) { @@ -2873,8 +2873,8 @@ cvt(struct function *fn, union type to, union type from, union ref ref) return kfrom == KI32 ? ref : cvt(fn, mktype(TYINT), from, ref); return irbinop(fn, Oneq, kfrom, ref, ZEROREF); } - else if (kfrom == KI32 && issigned(from)) op = Oexts4; - else if (kfrom == KI32) op = Oextu4; + else if (kfrom == KI32 && issigned(from)) op = Oexts32; + else if (kfrom == KI32) op = Oextu32; else if (kto == KI32 && isintcon(ref)) return issigned(to) ? mkintcon(kto, (int)intconval(ref)) : mkintcon(kto, (uint)intconval(ref)); else op = Ocopy; @@ -2891,10 +2891,10 @@ narrow(struct function *fn, enum irclass to, union type t, union ref ref, uint b enum op op; if (isfltt(tt)) { assert(to == KF32 && tt >= TYDOUBLE); - op = Ocvtf8f4; + op = Ocvtf64f32; } else { static const enum op ext[5][2] = { - [1] = {Oextu1, Oexts1}, [2] = {Oextu2, Oexts2}, [4] = {Oextu4, Oexts4} + [1] = {Oextu8, Oexts8}, [2] = {Oextu16, Oexts16}, [4] = {Oextu32, Oexts32} }; op = ext[targ_primsizes[tt]][issignedt(tt)]; } diff --git a/io.c b/io.c index 77380c3..5bf11df 100644 --- a/io.c +++ b/io.c @@ -442,7 +442,7 @@ vbfmt(struct wbuf *out, const char *fmt, va_list ap) } if (!umod && i < 0) { n += bputc(buf, '-'); - i = -i; + i = -(uvlong)i; } n += putuint(prec > 0 ? &tmp2 : buf, i, base, lower); if (prec > 0) { diff --git a/ir/abi0.c b/ir/abi0.c index 2e7966e..895277c 100644 --- a/ir/abi0.c +++ b/ir/abi0.c @@ -69,10 +69,10 @@ copyparam(struct function *fn, int *curi, int param, struct abiarg abi) if (abi.ty.cls == KPTR) abi.ty.cls = siz2intcls[cls2siz[abi.ty.cls]]; switch (abi.ty.cls) { default: assert(0); - case KI32: ld = Oloadu4; break; - case KI64: ld = Oloadi8; break; - case KF32: ld = Oloadf4; break; - case KF64: ld = Oloadf8; break; + case KI32: ld = Oloadu32; break; + case KI64: ld = Oloadi64; break; + case KF32: ld = Oloadf32; break; + case KF64: ld = Oloadf64; break; } return mkinstr(ld, abi.ty.cls, insertinstr(fn->entry, (*curi)++, par)); } else { /* aggregate in stack */ @@ -120,11 +120,11 @@ patchparam(struct function *fn, int *curi, int *param, int tydat, int nabi, stru * store* %x, %a * store* %x + N, %b */ - st = mkinstr(Ostore1 + ilog2(cls2siz[abi[0].ty.cls]), 0, alloc, r[0]); + st = mkinstr(Ostore8 + ilog2(cls2siz[abi[0].ty.cls]), 0, alloc, r[0]); insertinstr(blk, ++*curi, st); if (nabi > 1) { struct instr tmp = mkinstr(Oadd, KPTR, alloc, mkref(RICON, cls2siz[abi[0].ty.cls])); - st = mkinstr(Ostore1 + ilog2(cls2siz[abi[1].ty.cls]), 0, insertinstr(blk, ++*curi, tmp), r[1]); + st = mkinstr(Ostore8 + ilog2(cls2siz[abi[1].ty.cls]), 0, insertinstr(blk, ++*curi, tmp), r[1]); insertinstr(blk, ++*curi, st); } } @@ -156,10 +156,10 @@ load2regs(union ref out[2], union irtype typ, union ref src, int nabi, struct ab union ref temp; switch (ins.cls = abi[i].ty.cls) { default: assert(0); - case KI32: ins.op = Oloadu4; break; - case KI64: ins.op = Oloadi8; break; - case KF32: ins.op = Oloadf4; break; - case KF64: ins.op = Oloadf8; break; + case KI32: ins.op = Oloadu32; break; + case KI64: ins.op = Oloadi64; break; + case KF32: ins.op = Oloadf32; break; + case KF64: ins.op = Oloadf64; break; } if (i == 0) ins.l = src; @@ -177,7 +177,7 @@ load2regs(union ref out[2], union irtype typ, union ref src, int nabi, struct ab union ref reg, temp; uint n = cls2siz[abi[i].ty.cls] / align; assert(n > 0); - ld.op = Oloadu1 + ilog2(align)*2; + ld.op = Oloadu8 + ilog2(align)*2; ld.cls = abi[i].ty.cls; for (int o = 0; o < n && (i*cls2siz[ld.cls])+o*align < siz; ++o) { if (i+o == 0) @@ -304,8 +304,8 @@ abi0_call(struct function *fn, struct instr *ins, struct block *blk, int *curi) int iref, iuser; switch (call->abiret[i].ty.cls) { default: assert(0); - case KF32: case KI32: store.op = Ostore4; break; - case KI64: case KF64: store.op = Ostore8; break; + case KF32: case KI32: store.op = Ostore32; break; + case KI64: case KF64: store.op = Ostore64; break; } if (i == 0) { store.l = retmem; diff --git a/ir/builder.c b/ir/builder.c index 02664c3..9c6a0ef 100644 --- a/ir/builder.c +++ b/ir/builder.c @@ -112,11 +112,11 @@ irunop(struct function *fn, enum op op, enum irclass k, union ref a) if (ins && ins->op == Onot) /* ~(~x) ==> x */ return ins->l; break; - case Ocvtf4s: case Ocvtf4u: case Ocvtf4f8: case Ocvtf8s: - case Ocvtf8u: case Ocvtf8f4: case Ocvts4f: case Ocvtu4f: - case Ocvts8f: case Ocvtu8f: - case Oexts1: case Oextu1: case Oexts2: case Oextu2: - case Oexts4: case Oextu4: + case Ocvtf32s: case Ocvtf32u: case Ocvtf32f64: case Ocvtf64s: + case Ocvtf64u: case Ocvtf64f32: case Ocvts32f: case Ocvtu32f: + case Ocvts64f: case Ocvtu64f: + case Oexts8: case Oextu8: case Oexts16: case Oextu16: + case Oexts32: case Oextu32: case Ocopy: break; default: assert(!"unop?"); diff --git a/ir/fold.c b/ir/fold.c index bad0373..751583e 100644 --- a/ir/fold.c +++ b/ir/fold.c @@ -14,16 +14,16 @@ foldint(enum op op, enum irclass k, union ref lr, union ref rr) case Ocopy: x = l.s; break; case Oneg: x = -l.s; break; case Onot: x = ~l.s; break; - case Ocvtf4s: x = (int)(float)fltconval(lr); break; - case Ocvtf4u: x = (uint)(float)fltconval(lr); break; - case Ocvtf8s: x = (vlong)fltconval(lr); break; - case Ocvtf8u: x = (uvlong)fltconval(lr); break; - case Oexts1: x = (schar)l.s; break; - case Oextu1: x = (uchar)l.s; break; - case Oexts2: x = (short)l.s; break; - case Oextu2: x = (ushort)l.s; break; - case Oexts4: x = (int)l.s; break; - case Oextu4: x = (uint)l.s; break; + case Ocvtf32s: x = (int)(float)fltconval(lr); break; + case Ocvtf32u: x = (uint)(float)fltconval(lr); break; + case Ocvtf64s: x = (vlong)fltconval(lr); break; + case Ocvtf64u: x = (uvlong)fltconval(lr); break; + case Oexts8: x = (schar)l.s; break; + case Oextu8: x = (uchar)l.s; break; + case Oexts16: x = (short)l.s; break; + case Oextu16: x = (ushort)l.s; break; + case Oexts32: x = (int)l.s; break; + case Oextu32: x = (uint)l.s; break; case Oadd: x = l.u + r.u; break; case Osub: x = l.u - r.u; break; case Omul: x = l.u * r.u; break; @@ -63,12 +63,12 @@ foldflt(enum op op, enum irclass k, union ref lr, union ref rr) switch (op) { case Ocopy: x = l; break; case Oneg: x = -l; break; - case Ocvtf4f8: x = (float)l; break; - case Ocvtf8f4: x = (float)l; break; - case Ocvts4f: x = (int)intconval(lr); break; - case Ocvtu4f: x = (int)intconval(lr); break; - case Ocvts8f: x = (vlong)intconval(lr); break; - case Ocvtu8f: x = (uvlong)intconval(lr); break; + case Ocvtf32f64: x = (float)l; break; + case Ocvtf64f32: x = (float)l; break; + case Ocvts32f: x = (int)intconval(lr); break; + case Ocvtu32f: x = (int)intconval(lr); break; + case Ocvts64f: x = (vlong)intconval(lr); break; + case Ocvtu64f: x = (uvlong)intconval(lr); break; case Oadd: x = l + r; break; case Osub: x = l - r; break; case Omul: x = l * r; break; diff --git a/ir/intrin.c b/ir/intrin.c index 3edf931..8c1a128 100644 --- a/ir/intrin.c +++ b/ir/intrin.c @@ -36,8 +36,8 @@ intrin(struct block *blk, int *curi, enum intrin in, struct arg *args, int narg, pdst = insertinstr(blk, ++*curi, mkinstr(Oadd, KPTR, *args[0].arg, mkref(RICON, off))); psrc = insertinstr(blk, ++*curi, mkinstr(Oadd, KPTR, *args[1].arg, mkref(RICON, off))); } - src = insertinstr(blk, ++*curi, mkinstr(Oloads1 + 2*ilog2(step), step < 8 ? KI32 : KI64, psrc)); - insertinstr(blk, ++*curi, mkinstr(Ostore1 + ilog2(step), 0, pdst, src)); + src = insertinstr(blk, ++*curi, mkinstr(Oloads8 + 2*ilog2(step), step < 8 ? KI32 : KI64, psrc)); + insertinstr(blk, ++*curi, mkinstr(Ostore8 + ilog2(step), 0, pdst, src)); } return 1; } diff --git a/ir/ir.h b/ir/ir.h index e1cd88b..0879b86 100644 --- a/ir/ir.h +++ b/ir/ir.h @@ -93,8 +93,8 @@ enum op { #define oiscmp(o) in_range(o, Oequ, Ougte) #define oisarith(o) in_range(o, Oneg, Ougte) #define oisalloca(o) in_range(o, Oalloca1, Oalloca16) -#define oisstore(o) in_range(o, Ostore1, Ostore8) -#define oisload(o) in_range(o, Oloads1, Oloadf8) +#define oisstore(o) in_range(o, Ostore8, Ostore64) +#define oisload(o) in_range(o, Oloads8, Oloadf64) extern const char *opnames[]; extern const uchar opnarg[]; diff --git a/ir/op.def b/ir/op.def index 7bcaad1..b3d237c 100644 --- a/ir/op.def +++ b/ir/op.def @@ -1,76 +1,76 @@ /* OP NARG */ -_(nop, 0) -_(copy, 1) -_(move, 2) -_(neg, 1) -_(not, 1) -_(cvtf4s, 1) -_(cvtf4u, 1) -_(cvtf4f8, 1) -_(cvtf8s, 1) -_(cvtf8u, 1) -_(cvtf8f4, 1) -_(cvts4f, 1) -_(cvtu4f, 1) -_(cvts8f, 1) -_(cvtu8f, 1) -_(exts1, 1) -_(extu1, 1) -_(exts2, 1) -_(extu2, 1) -_(exts4, 1) -_(extu4, 1) -_(add, 2) -_(sub, 2) -_(mul, 2) -_(umul, 2) -_(div, 2) -_(udiv, 2) -_(rem, 2) -_(urem, 2) -_(and, 2) -_(ior, 2) -_(xor, 2) -_(shl, 2) -_(sar, 2) -_(slr, 2) -_(equ, 2) -_(neq, 2) -_(lth, 2) -_(gth, 2) -_(lte, 2) -_(gte, 2) -_(ulth, 2) -_(ugth, 2) -_(ulte, 2) -_(ugte, 2) -_(alloca1, 1) -_(alloca2, 1) -_(alloca4, 1) -_(alloca8, 1) -_(alloca16, 1) -_(loads1, 1) -_(loadu1, 1) -_(loads2, 1) -_(loadu2, 1) -_(loads4, 1) -_(loadu4, 1) -_(loadi8, 1) -_(loadf4, 1) -_(loadf8, 1) -_(store1, 2) -_(store2, 2) -_(store4, 2) -_(store8, 2) -_(param, 2) -_(arg, 2) -_(call, 2) -_(call2r, 1) -_(intrin, 2) -_(phi, 1) -_(swap, 2) -_(vastart, 1) -_(vaarg, 2) +_(nop, 0) +_(copy, 1) +_(move, 2) +_(neg, 1) +_(not, 1) +_(cvtf32s, 1) +_(cvtf32u, 1) +_(cvtf32f64, 1) +_(cvtf64s, 1) +_(cvtf64u, 1) +_(cvtf64f32, 1) +_(cvts32f, 1) +_(cvtu32f, 1) +_(cvts64f, 1) +_(cvtu64f, 1) +_(exts8, 1) +_(extu8, 1) +_(exts16, 1) +_(extu16, 1) +_(exts32, 1) +_(extu32, 1) +_(add, 2) +_(sub, 2) +_(mul, 2) +_(umul, 2) +_(div, 2) +_(udiv, 2) +_(rem, 2) +_(urem, 2) +_(and, 2) +_(ior, 2) +_(xor, 2) +_(shl, 2) +_(sar, 2) +_(slr, 2) +_(equ, 2) +_(neq, 2) +_(lth, 2) +_(gth, 2) +_(lte, 2) +_(gte, 2) +_(ulth, 2) +_(ugth, 2) +_(ulte, 2) +_(ugte, 2) +_(alloca1, 1) +_(alloca2, 1) +_(alloca4, 1) +_(alloca8, 1) +_(alloca16, 1) +_(loads8, 1) +_(loadu8, 1) +_(loads16, 1) +_(loadu16, 1) +_(loads32, 1) +_(loadu32, 1) +_(loadi64, 1) +_(loadf32, 1) +_(loadf64, 1) +_(store8, 2) +_(store16, 2) +_(store32, 2) +_(store64, 2) +_(param, 2) +_(arg, 2) +_(call, 2) +_(call2r, 1) +_(intrin, 2) +_(phi, 1) +_(swap, 2) +_(vastart, 1) +_(vaarg, 2) /* machine-specific instructions */ _(xvaprologue, 1) _(xsave, 1) diff --git a/ir/optmem.c b/ir/optmem.c index 41d123a..d28ea53 100644 --- a/ir/optmem.c +++ b/ir/optmem.c @@ -2,23 +2,23 @@ #include /* qsort */ static const uchar loadszcls[] = { - [Oloads1 - Oloads1] = 1|KI32<<4, [Oloadu1 - Oloads1] = 1|KI32<<4, - [Oloads2 - Oloads1] = 2|KI32<<4, [Oloadu2 - Oloads1] = 2|KI32<<4, - [Oloads4 - Oloads1] = 4|KI32<<4, [Oloadu4 - Oloads1] = 4|KI32<<4, - [Oloadi8 - Oloads1] = 8|KI64<<4, - [Oloadf4 - Oloads1] = 4|KF32<<4, - [Oloadf8 - Oloads1] = 8|KF64<<4, + [Oloads8 - Oloads8] = 1|KI32<<4, [Oloadu8 - Oloads8] = 1|KI32<<4, + [Oloads16 - Oloads8] = 2|KI32<<4, [Oloadu16 - Oloads8] = 2|KI32<<4, + [Oloads32 - Oloads8] = 4|KI32<<4, [Oloadu32 - Oloads8] = 4|KI32<<4, + [Oloadi64 - Oloads8] = 8|KI64<<4, + [Oloadf32 - Oloads8] = 4|KF32<<4, + [Oloadf64 - Oloads8] = 8|KF64<<4, }; static const uchar load2ext[] = { - [Oloads1 - Oloads1] = Oexts1, [Oloadu1 - Oloads1] = Oextu1, - [Oloads2 - Oloads1] = Oexts2, [Oloadu2 - Oloads1] = Oextu2, - [Oloads4 - Oloads1] = Oexts4, [Oloadu4 - Oloads1] = Oextu4, - [Oloadi8 - Oloads1] = Ocopy, + [Oloads8 - Oloads8] = Oexts8, [Oloadu8 - Oloads8] = Oextu8, + [Oloads16 - Oloads8] = Oexts16, [Oloadu16 - Oloads8] = Oextu16, + [Oloads32 - Oloads8] = Oexts32, [Oloadu32 - Oloads8] = Oextu32, + [Oloadi64 - Oloads8] = Ocopy, }; -#define loadsz(o) (loadszcls[(o) - Oloads1] & 0xF) -#define loadcls(o) (loadszcls[(o) - Oloads1] >> 4) -#define load2ext(o) (load2ext[(o) - Oloads1]) -#define storesz(o) (1 << ((o) - Ostore1)) +#define loadsz(o) (loadszcls[(o) - Oloads8] & 0xF) +#define loadcls(o) (loadszcls[(o) - Oloads8] >> 4) +#define load2ext(o) (load2ext[(o) - Oloads8]) +#define storesz(o) (1 << ((o) - Ostore8)) /* Implements algorithm in 'Simple and Efficient Construction of Static Single Assignment' (Braun et al) */ @@ -291,19 +291,19 @@ mem2reg(struct function *fn) if (!val.bits) { /* var is used uninitialized */ /* TODO emit diagnostic */ /* load some garbage */ - *m = mkinstr(kisflt(k) ? Oloadf4 + (k==KF64) : Oloads1+ilog2(sz)*2, + *m = mkinstr(kisflt(k) ? Oloadf32 + (k==KF64) : Oloads8+ilog2(sz)*2, k, mkref(RREG, mctarg->bpr)); } else { adduse(use->blk, use->u, val); if (isintcon(val) && ext != Ocopy) { vlong x = intconval(val); switch (ext) { - case Oexts1: x = (schar)x; break; - case Oextu1: x = (uchar)x; break; - case Oexts2: x = (short)x; break; - case Oextu2: x = (ushort)x; break; - case Oexts4: x = (int)x; break; - case Oextu4: x = (uint)x; break; + case Oexts8: x = (schar)x; break; + case Oextu8: x = (uchar)x; break; + case Oexts16: x = (short)x; break; + case Oextu16: x = (ushort)x; break; + case Oexts32: x = (int)x; break; + case Oextu32: x = (uint)x; break; default: assert(0); } val = mkintcon(k, x); diff --git a/ir/regalloc.c b/ir/regalloc.c index df40ad4..8c8b39c 100644 --- a/ir/regalloc.c +++ b/ir/regalloc.c @@ -251,11 +251,11 @@ emitmove(enum irclass k, struct alloc dst, struct alloc src, struct block *blk, if (src.t == ASTACK) { switch (mv.cls = k) { default: assert(0); - case KI32: mv.op = Oloads4; break; - case KI64: mv.op = Oloadi8; break; - case KPTR: mv.op = targ_64bit ? Oloadi8 : Oloads4; break; - case KF32: mv.op = Oloadf4; break; - case KF64: mv.op = Oloadf8; break; + case KI32: mv.op = Oloads32; break; + case KI64: mv.op = Oloadi64; break; + case KPTR: mv.op = targ_64bit ? Oloadi64 : Oloads32; break; + case KF32: mv.op = Oloadf32; break; + case KF64: mv.op = Oloadf64; break; } if (dst.t == AREG) reg = dst.a; @@ -265,7 +265,7 @@ emitmove(enum irclass k, struct alloc dst, struct alloc src, struct block *blk, addstkslotref(insertinstr(blk, curi, mv).i, src.a*8); } else reg = src.a; if (dst.t == ASTACK) { - mv = mkinstr(Ostore1+ilog2(cls2siz[k]), 0, .r = mkref(RREG, reg)); + mv = mkinstr(Ostore8+ilog2(cls2siz[k]), 0, .r = mkref(RREG, reg)); addstkslotref(insertinstr(blk, curi, mv).i, dst.a*8); } } @@ -976,9 +976,9 @@ devirt(struct rega *ra, struct block *blk) for (int i = 0; i < nargref; ++i) { static uchar cls2load[] = { - [KI32] = Oloads4, [KI64] = Oloadi8, [KF32] = Oloadf4, [KF64] = Oloadf8, [KPTR] = 0 + [KI32] = Oloads32, [KI64] = Oloadi64, [KF32] = Oloadf32, [KF64] = Oloadf64, [KPTR] = 0 }; - cls2load[KPTR] = targ_64bit ? Oloadi8 : Oloads4; + cls2load[KPTR] = targ_64bit ? Oloadi64 : Oloads32; union ref *r = argref[i]; int tr; if (r->t == RTMP) { @@ -1044,7 +1044,7 @@ devirt(struct rega *ra, struct block *blk) alloc = temp < ra->intervals.ntemps && (it = &ra->intervals.temps[temp]) && it->nrange ? &it->alloc : NULL; if (alloc && alloc->t == ASTACK) { enum irclass cls = insrescls(*ins); - int store = Ostore1 + ilog2(cls2siz[cls]); + int store = Ostore8 + ilog2(cls2siz[cls]); /* t was spilled, gen store */ if (ins->op == Ocopy && ins->l.t != RADDR) { ins->op = store; @@ -1075,7 +1075,7 @@ devirt(struct rega *ra, struct block *blk) } } } - if (!ins->reg && insrescls(*ins) && ins->op != Omove && !ins->keep && !in_range(ins->op, Ostore1, Ostore8)) { + if (!ins->reg && insrescls(*ins) && ins->op != Omove && !ins->keep && !in_range(ins->op, Ostore8, Ostore64)) { /* dead */ Nop: ins->op = Onop; @@ -1095,7 +1095,7 @@ devirt(struct rega *ra, struct block *blk) ++curi; ins->l.i = ins->reg-1; } - if (!ins->reg && in_range(ins->op, Oloads1, Oloadf8)) { + if (!ins->reg && in_range(ins->op, Oloads8, Oloadf64)) { assert(ins->keep); ins->reg = kisint(ins->cls) ? mctarg->gprscratch+1 : mctarg->fprscratch+1; } -- cgit v1.2.3