rename IR classes to reflect bitsize

3 files changed, 47 insertions, 47 deletions

diff --git a/amd64/emit.c b/amd64/emit.c
index df735e1..6ef6df3 100644
--- a/amd64/emit.c
+++ b/amd64/emit.c
@@ -46,7 +46,7 @@ ref2oper(union ref r)
    case RREG: return reg2oper(r.i);
    case RICON: return mkoper(OIMM, .imm = r.i);
    case RXCON:
-      if (conht[r.i].cls == KI4)
+      if (conht[r.i].cls == KI32)
          return mkoper(OIMM, .imm = conht[r.i].i);
       else if (!conht[r.i].cls)
          return mkoper(OSYM, .con = r.i, .cindex = NOINDEX);
@@ -85,7 +85,7 @@ mkregoper(union ref r)
 static inline struct oper
 mkimmoper(union ref r)
 {
-   assert(iscon(r) && concls(r) == KI4);
+   assert(iscon(r) && concls(r) == KI32);
    return mkoper(OIMM, .imm = intconval(r));
 }
 
@@ -95,7 +95,7 @@ mkimmoper(union ref r)
 static inline struct oper
 mkimmregoper(union ref r)
 {
-   assert(isregref(r) || (iscon(r) && concls(r) == KI4));
+   assert(isregref(r) || (iscon(r) && concls(r) == KI32));
    return ref2oper(r);
 }
 
@@ -109,7 +109,7 @@ mkdatregoper(union ref r)
 static inline struct oper
 mkimmdatregoper(union ref r)
 {
-   assert(isregref(r) || r.t == RICON || (r.t == RXCON && (conht[r.i].cls == KI4 || conht[r.i].deref)));
+   assert(isregref(r) || r.t == RICON || (r.t == RXCON && (conht[r.i].cls == KI32 || conht[r.i].deref)));
    return ref2oper(r);
 }
 
@@ -286,7 +286,7 @@ encode(uchar **pcode, const struct desc *tab, int ntab, enum irclass k, struct o
    /* mandatory prefixes go before REX */
    if (*opc == 0x66 || *opc == 0xF2 || *opc == 0xF3)
       B(*opc++), --nopc;
-   rex = in_range(k, KI8, KPTR) << 3; /* REX.W */
+   rex = in_range(k, KI64, KPTR) << 3; /* REX.W */
    if (en->norexw) rex = 0;
    switch (en->operenc) {
    case EN_RR: /* mod = 11; reg = dst; rm = src */
@@ -489,10 +489,10 @@ static void Xmov(uchar **pcode, enum irclass k, struct oper dst, struct oper src
       {4|8, PGPR, PFPR, "\x66\x0F\x7E", EN_RRX}, /* MOVD/Q r64/32, xmm */
    };
    static const uchar k2off[] = {
-      [KI4] = 0,
-      [KI8] = 1, [KPTR] = 1,
-      [KF4] = 7,
-      [KF8] = 10,
+      [KI32] = 0,
+      [KI64] = 1, [KPTR] = 1,
+      [KF32] = 7,
+      [KF64] = 10,
    };
    encode(pcode, all + k2off[k], arraylength(all) - k2off[k], k, dst, src);
 }
@@ -865,7 +865,7 @@ gencopy(uchar **pcode, enum irclass cls, struct block *blk, int curi, struct ope
       Xlea(pcode, cls, dst, ref2oper(val));
    } else if (val.bits == ZEROREF.bits && dst.t == OREG && (kisflt(cls) || !flagslivep(blk, curi))) {
       /* dst = 0 -> xor dst, dst; but only if it is ok to clobber flags */
-      Xxor(pcode, kisint(cls) ? KI4 : cls, dst, dst);
+      Xxor(pcode, kisint(cls) ? KI32 : cls, dst, dst);
    } else if (isaddrcon(val,0)) {
       if (ccopt.pic) GOTLoad:
          /* for  mov reg, [rip(sym@GOTPCREL)] */
@@ -873,7 +873,7 @@ gencopy(uchar **pcode, enum irclass cls, struct block *blk, int curi, struct ope
       else
          /* for  lea reg, [rip(sym)] */
          Xlea(pcode, cls, dst, mkoper(OSYM, .con = val.i, .cindex = NOINDEX));
-   } else if (val.t == RXCON && in_range(concls(val), KI8, KPTR)) {
+   } else if (val.t == RXCON && in_range(concls(val), KI64, KPTR)) {
       /* movabs */
       assert(dst.t == OREG && in_range(dst.reg, RAX, R15));
       B(0x48 | (dst.reg >> 3));       /* REX.W (+ REX.B)   */
@@ -883,7 +883,7 @@ gencopy(uchar **pcode, enum irclass cls, struct block *blk, int curi, struct ope
    } else {
       struct oper src = mkimmdatregoper(val);
       if (memcmp(&dst, &src, sizeof dst) != 0)
-         Xmov(pcode, cls == KF8 && src.t == OREG && src.reg < XMM0 ? KI8 : cls, dst, src);
+         Xmov(pcode, cls == KF64 && src.t == OREG && src.reg < XMM0 ? KI64 : cls, dst, src);
    }
 }
 
@@ -903,7 +903,7 @@ Xvaprologue(uchar **pcode, struct function *fn, struct oper sav)
    for (int r = 0; r < 6; ++r) {
       static const char reg[] = {RDI,RSI,RDX,RCX,R8,R9};
       if (r >= gpr0)
-         Xmov(pcode, KI8, sav, reg2oper(reg[r]));
+         Xmov(pcode, KI64, sav, reg2oper(reg[r]));
       sav.disp += 8;
    }
 
@@ -915,7 +915,7 @@ Xvaprologue(uchar **pcode, struct function *fn, struct oper sav)
    }
    for (int r = 0; r < 8; ++r) {
       if (r >= fpr0)
-         Xmovaps(pcode, KF8, sav, reg2oper(XMM0 + r));     
+         Xmovaps(pcode, KF64, sav, reg2oper(XMM0 + r));     
       sav.disp += 16;
    }
    if (fpr0 < 8) {/* patch relative jump */
@@ -953,14 +953,14 @@ 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 = KI4, X = Xmovb; goto Store;
-   case Ostore2: cls = KI4, X = Xmovw; goto Store;
-   case Ostore4: cls = KI4, X = Xmov; goto Store;
-   case Ostore8: cls = KI8, X = Xmov;
+   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;
    Store:
       src = mkimmregoper(ins->r);
-      if (cls == KI4 && src.t == OREG && src.reg >= XMM0) cls = KF4;
-      if (cls == KI8 && src.t == OREG && src.reg >= XMM0) cls = KF8;
+      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;
@@ -974,15 +974,15 @@ emitinstr(uchar **pcode, struct function *fn, struct block *blk, int curi, struc
    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, KI4, 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, KI8, 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 == KF4 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI4; goto FloatsCvt;
-   case Ocvts8f: X = cls == KF4 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI8; goto FloatsCvt;
+   case Ocvts4f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI32; goto FloatsCvt;
+   case Ocvts8f: X = cls == KF32 ? Xcvtsi2ss : Xcvtsi2sd; cls = KI64; goto FloatsCvt;
    FloatsCvt:
       X(pcode, cls, reg2oper(ins->reg-1), mkdatregoper(ins->l));
       break;
@@ -1050,12 +1050,12 @@ emitinstr(uchar **pcode, struct function *fn, struct block *blk, int curi, struc
       switch (cls) {
       default: assert(0);
       case KPTR:
-      case KI8: B(0x48); /* REX.W */
-      case KI4: B(0x99); /* CDQ/CQO */
+      case KI64: B(0x48); /* REX.W */
+      case KI32: B(0x99); /* CDQ/CQO */
                 assert(mkregoper(ins->l).reg == RAX);
                 Xidiv(pcode, cls, mkdatregoper(ins->r));
                 break;
-      case KF4: case KF8:
+      case KF32: case KF64:
                 Xdivf(pcode, cls, reg2oper(ins->reg-1), mkdatregoper(ins->r));
                 break;
       }
@@ -1075,7 +1075,7 @@ emitinstr(uchar **pcode, struct function *fn, struct block *blk, int curi, struc
          /* can zero output reg before test instruction (differs from both inputs) */
          /* XXX this doesn't check if a source operand is an addr containing the register */
          struct oper dst = reg2oper(ins->reg-1);
-         Xxor(pcode, KI4, dst, dst);
+         Xxor(pcode, KI32, dst, dst);
          regzeroed = 1;
       }
       if (kisint(ins->cls) && ins->r.bits == ZEROREF.bits)
@@ -1092,7 +1092,7 @@ emitinstr(uchar **pcode, struct function *fn, struct block *blk, int curi, struc
          }
          Xsetcc(pcode, cc, dst.reg);
          if (!regzeroed)
-            Xmovzxb(pcode, KI4, dst, dst);
+            Xmovzxb(pcode, KI32, dst, dst);
       }
       break;
    case Omove:
diff --git a/amd64/isel.c b/amd64/isel.c
index 649c393..904fdbd 100644
--- a/amd64/isel.c
+++ b/amd64/isel.c
@@ -68,23 +68,23 @@ fixarg(union ref *r, struct instr *ins, struct block *blk, int *curi)
       } else if (in_range(op, Oadd, Osub) && con->i == 2147483648 && r == &ins->r) {
          /* add X, INT32MAX+1 -> sub X, INT32MIN */
          ins->op = Oadd + (op == Oadd);
-         *r = mkintcon(KI4, -2147483648);
+         *r = mkintcon(KI32, -2147483648);
       } else if (kisflt(con->cls) && con->f == 0) {
          /* copy of float zero -> regular zero, that emit() will turn into xor x,x */
          if (in_range(op, Ocopy, Omove) || op == Ophi)
             *r = ZEROREF;
          else
             *r = insertinstr(blk, (*curi)++, mkinstr(Ocopy, con->cls, ZEROREF));
-      } else if (con->cls >= KI8) {
+      } else if (con->cls >= KI64) {
          /* float immediates & 64bit immediates are loaded from memory */
          uchar data[8];
          uint ksiz = cls2siz[con->cls];
          union type ctype;
          if (con->cls <= KPTR && in_range(ins->op, Ocopy, Omove)) /* in this case we can use movabs */
             return;
-         if (con->cls != KF4) {
+         if (con->cls != KF32) {
             wr64le(data, con->i);
-            ctype = mktype(con->cls == KF8 ? TYDOUBLE : TYVLONG);
+            ctype = mktype(con->cls == KF64 ? TYDOUBLE : TYVLONG);
          } else {
             union { float f; int i; } pun = { con->f };
             wr32le(data, pun.i);
@@ -107,7 +107,7 @@ fixarg(union ref *r, struct instr *ins, struct block *blk, int *curi)
    ShiftImm: /* shift immediate is always 8bit */
       *r = mkref(RICON, sh & 255);
    } else if (isstkslot(*r)) {
-      struct instr adr = mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkintcon(KI4, -stkslots[r->i]));
+      struct instr adr = mkinstr(Oadd, KPTR, mkref(RREG, RBP), mkintcon(KI32, -stkslots[r->i]));
       if (in_range(op, Ocopy, Omove))
          *ins = adr;
       else
@@ -162,7 +162,7 @@ selcall(struct function *fn, struct instr *ins, struct block *blk, int *curi)
    }
 }
 
-#define isimm32(r) (iscon(r) && concls(r) == KI4)
+#define isimm32(r) (iscon(r) && concls(r) == KI32)
 
 static bool
 aimm(struct addr *addr, int disp)
@@ -389,7 +389,7 @@ sel(struct function *fn, struct instr *ins, struct block *blk, int *curi)
    case Oshl: case Osar: case Oslr:
       if (!iscon(ins->r)) {
          /* shift amount register is always CL */
-         insertinstr(blk, (*curi)++, mkinstr(Omove, KI4, mkref(RREG, RCX), ins->r));
+         insertinstr(blk, (*curi)++, mkinstr(Omove, KI32, mkref(RREG, RCX), ins->r));
          ins->r = mkref(RREG, RCX);
       }
       goto ALU;
@@ -498,13 +498,13 @@ sel(struct function *fn, struct instr *ins, struct block *blk, int *curi)
       break;
    case Ocvtu4f:
       fixarg(&ins->l, ins, blk, curi);
-      ins->l = insertinstr(blk, (*curi)++, mkinstr(Oextu4, KI8, ins->l));
+      ins->l = insertinstr(blk, (*curi)++, mkinstr(Oextu4, KI64, ins->l));
       ins->op = Ocvts8f;
       break;
    case Ocvtf4u: case Ocvtf8u:
       fixarg(&ins->l, ins, blk, curi);
-      if (ins->cls == KI4) {
-         ins->l = insertinstr(blk, (*curi)++, mkinstr(ins->op == Ocvtf4u ? Ocvtf4s : Ocvtf8s, KI8, ins->l));
+      if (ins->cls == KI32) {
+         ins->l = insertinstr(blk, (*curi)++, mkinstr(ins->op == Ocvtf4u ? Ocvtf4s : Ocvtf8s, KI64, ins->l));
          ins->op = Oextu4;
      } else assert(!"nyi flt -> u64");
       break;
@@ -541,7 +541,7 @@ seljmp(struct function *fn, struct block *blk)
    if (blk->jmp.t == Jb && blk->jmp.arg[0].bits) {
       union ref c = blk->jmp.arg[0];
       if (c.t != RTMP) {
-         enum irclass cls = c.t == RICON ? KI4 : c.t == RXCON && conht[c.i].cls ? conht[c.i].cls : KPTR;
+         enum irclass cls = c.t == RICON ? KI32 : c.t == RXCON && conht[c.i].cls ? conht[c.i].cls : KPTR;
          int curi = blk->ins.n;
 
          c = insertinstr(blk, blk->ins.n, mkinstr(Ocopy, cls, c));
diff --git a/amd64/sysv.c b/amd64/sysv.c
index db88692..e69797b 100644
--- a/amd64/sysv.c
+++ b/amd64/sysv.c
@@ -8,7 +8,7 @@ clsscalar(uchar cls[2], uint off, union type ty)
    enum irclass k = type2cls[scalartypet(ty)];
    uchar *fcls = &cls[off/8];
    if (isflt(ty)) { /* SSE */
-      if (!*fcls || (*fcls == KF4 && k > *fcls))
+      if (!*fcls || (*fcls == KF32 && k > *fcls))
          *fcls = k;
    } else { /* INTEGER */
       assert(isint(ty) || ty.t == TYPTR);
@@ -16,7 +16,7 @@ clsscalar(uchar cls[2], uint off, union type ty)
          *fcls = k;
    }
    if (off % 8 >= 4 && cls2siz[*fcls] < 8)
-      *fcls = kisint(*fcls) ? KI8 : KF8;
+      *fcls = kisint(*fcls) ? KI64 : KF64;
 }
 
 static int
@@ -230,8 +230,8 @@ 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, KI4, ap));
-         tmp = insertinstr(blk, (*curi)++, mkinstr(Oulte, KI4, tmp, mkref(RICON, 48 - ni*8)));
+         tmp = insertinstr(blk, (*curi)++, mkinstr(Oloadu4, KI32, ap));
+         tmp = insertinstr(blk, (*curi)++, mkinstr(Oulte, KI32, tmp, mkref(RICON, 48 - ni*8)));
          merge = blksplitafter(fn, blk, *curi);
          blk->jmp.t = 0;
          useblk(fn, blk);
@@ -240,10 +240,10 @@ vaarg(struct function *fn, struct block *blk, int *curi)
          {
             /* 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, KI4, ap));
+            union ref gpoff = addinstr(fn, mkinstr(Oloadu4, KI32, ap));
             phiargs[0] = irbinop(fn, Oadd, KPTR, sav, gpoff);
             /* l->gp_offset += num_gp * 8 */
-            gpoff = irbinop(fn, Oadd, KI4, gpoff, mkref(RICON, ni * 8));
+            gpoff = irbinop(fn, Oadd, KI32, gpoff, mkref(RICON, ni * 8));
             addinstr(fn, mkinstr(Ostore4, 0, ap, gpoff));
             assert(merge->npred == 1);
             blkpred(merge, 0) = blk->s1;
@@ -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] == KI4 ? Oloads4 : Oloadi8, cls[0], phi);
+         instrtab[var] = mkinstr(cls[0] == KI32 ? Oloads4 : Oloadi8, cls[0], phi);
       } else {
          assert(0&&nf);
       }