aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--amd64/emit.c48
-rw-r--r--amd64/isel.c26
-rw-r--r--amd64/sysv.c22
-rw-r--r--c/c.c40
-rw-r--r--io.c2
-rw-r--r--ir/abi0.c26
-rw-r--r--ir/builder.c10
-rw-r--r--ir/fold.c32
-rw-r--r--ir/intrin.c4
-rw-r--r--ir/ir.h4
-rw-r--r--ir/op.def144
-rw-r--r--ir/optmem.c42
-rw-r--r--ir/regalloc.c22
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 <stdlib.h> /* 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;
}
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-02 03:11:39 +0000