rename IR classes to reflect bitsize

9 files changed, 46 insertions, 46 deletions

diff --git a/ir/abi0.c b/ir/abi0.c
index 914e6d8..2e7966e 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 KI4: ld = Oloadu4; break;
-      case KI8: ld = Oloadi8; break;
-      case KF4: ld = Oloadf4; break;
-      case KF8: ld = Oloadf8; break;
+      case KI32: ld = Oloadu4; break;
+      case KI64: ld = Oloadi8; break;
+      case KF32: ld = Oloadf4; break;
+      case KF64: ld = Oloadf8; break;
       }
       return mkinstr(ld, abi.ty.cls, insertinstr(fn->entry, (*curi)++, par));
    } else { /* aggregate in stack */
@@ -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 KI4: ins.op = Oloadu4; break;
-         case KI8: ins.op = Oloadi8; break;
-         case KF4: ins.op = Oloadf4; break;
-         case KF8: ins.op = Oloadf8; break;
+         case KI32: ins.op = Oloadu4; break;
+         case KI64: ins.op = Oloadi8; break;
+         case KF32: ins.op = Oloadf4; break;
+         case KF64: ins.op = Oloadf8; break;
          }
          if (i == 0)
             ins.l = src;
@@ -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 KF4: case KI4: store.op = Ostore4; break;
-            case KI8: case KF8: store.op = Ostore8; break;
+            case KF32: case KI32: store.op = Ostore4; break;
+            case KI64: case KF64: store.op = Ostore8; break;
             }
             if (i == 0) {
                store.l = retmem;
diff --git a/ir/dump.c b/ir/dump.c
index 3d4338b..f7d005c 100644
--- a/ir/dump.c
+++ b/ir/dump.c
@@ -58,7 +58,7 @@ pridat(const struct irdat *dat)
 }
 
 static const char *clsname[] = {
-   "?", "i4", "i8", "ptr", "f4", "f8"
+   "?", "i32", "i64", "ptr", "f32", "f64"
 };
 
 static void
@@ -123,11 +123,11 @@ dumpref(enum op o, union ref ref)
             }
          }
       } else switch (con->cls) {
-      case KI4: bfmt(out, "%d", (int)con->i); break;
-      case KI8: bfmt(out, "%ld", con->i); break;
+      case KI32: bfmt(out, "%d", (int)con->i); break;
+      case KI64: bfmt(out, "%ld", con->i); break;
       case KPTR: bfmt(out, "%'lx", con->i); break;
-      case KF4: bfmt(out, "%fs", con->f); break;
-      case KF8: bfmt(out, "%fd", con->f); break;
+      case KF32: bfmt(out, "%fs", con->f); break;
+      case KF64: bfmt(out, "%fd", con->f); break;
       default: assert(0);
       }
       if (con->deref) bfmt(out, "]");
diff --git a/ir/fold.c b/ir/fold.c
index bfd78ff..bad0373 100644
--- a/ir/fold.c
+++ b/ir/fold.c
@@ -58,7 +58,7 @@ foldflt(enum op op, enum irclass k, union ref lr, union ref rr)
 {
    int xi;
    double x, l = fltconval(lr), r = fltconval(rr);
-   bool w = k == KF8;
+   bool w = k == KF64;
    if (in_range(op, Odiv, Ourem)) assert(r != 0.0);
    switch (op) {
    case Ocopy: x = l; break;
diff --git a/ir/intrin.c b/ir/intrin.c
index 9bb0bcb..3edf931 100644
--- a/ir/intrin.c
+++ b/ir/intrin.c
@@ -36,7 +36,7 @@ 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 ? KI4 : KI8, psrc));
+            src = insertinstr(blk, ++*curi, mkinstr(Oloads1 + 2*ilog2(step), step < 8 ? KI32 : KI64, psrc));
             insertinstr(blk, ++*curi, mkinstr(Ostore1 + ilog2(step), 0, pdst, src));
          }
          return 1;
diff --git a/ir/ir.c b/ir/ir.c
index a54b04e..6a40991 100644
--- a/ir/ir.c
+++ b/ir/ir.c
@@ -2,8 +2,8 @@
 #include "../obj/obj.h"
 
 uchar type2cls[NTYPETAG];
-uchar cls2siz[KF8+1];
-const uchar siz2intcls[] = { [1] = KI4, [2] = KI4, [4] = KI4, [8] = KI8 };
+uchar cls2siz[KF64+1];
+const uchar siz2intcls[] = { [1] = KI32, [2] = KI32, [4] = KI32, [8] = KI64 };
 
 const char *opnames[] = {
    "?\??",
@@ -54,15 +54,15 @@ irinit(struct function *fn)
    if (!type2cls[TYINT]) {
       for (int i = TYBOOL; i <= TYUVLONG; ++i) {
          int siz = targ_primsizes[i];
-         type2cls[i] = siz < 8 ? KI4 : KI8;
+         type2cls[i] = siz < 8 ? KI32 : KI64;
       }
-      type2cls[TYFLOAT] = KF4;
-      type2cls[TYDOUBLE] = KF8;
-      type2cls[TYLDOUBLE] = KF8;
+      type2cls[TYFLOAT] = KF32;
+      type2cls[TYDOUBLE] = KF64;
+      type2cls[TYLDOUBLE] = KF64;
       type2cls[TYPTR] = KPTR;
       type2cls[TYARRAY] = KPTR;
-      cls2siz[KI4] = cls2siz[KF4] = 4;
-      cls2siz[KI8] = cls2siz[KF8] = 8;
+      cls2siz[KI32] = cls2siz[KF32] = 4;
+      cls2siz[KI64] = cls2siz[KF64] = 8;
       cls2siz[KPTR] = targ_primsizes[TYPTR];
    }
    fn->entry = fn->curblk = allocz(fn->arena, sizeof(struct block), 0);
@@ -132,7 +132,7 @@ mkintcon(enum irclass k, vlong i)
 union ref
 mkfltcon(enum irclass k, double f)
 {
-   struct xcon con = { .cls = k, .f = k == KF4 ? (float) f : f };
+   struct xcon con = { .cls = k, .f = k == KF32 ? (float) f : f };
    return mkref(RXCON, addcon(&con));
 }
 
diff --git a/ir/ir.h b/ir/ir.h
index 1e9e578..e1cd88b 100644
--- a/ir/ir.h
+++ b/ir/ir.h
@@ -3,12 +3,12 @@
 
 enum irclass {
    KXXX,
-   KI4, KI8, KPTR,
-   KF4, KF8,
+   KI32, KI64, KPTR,
+   KF32, KF64,
 };
 
-#define kisint(k) in_range((k), KI4, KPTR)
-#define kisflt(k) in_range((k), KF4, KF8)
+#define kisint(k) in_range((k), KI32, KPTR)
+#define kisflt(k) in_range((k), KF32, KF64)
 
 union irtype {
    struct { ushort _     : 1, cls : 15; };
@@ -73,7 +73,7 @@ struct addr {
    int shift, disp;
 };
 
-#define insrescls(ins) (oiscmp((ins).op) ? KI4 : (ins).cls)
+#define insrescls(ins) (oiscmp((ins).op) ? KI32 : (ins).cls)
 #define NOREF ((union ref) {0})
 #define UNDREF ((union ref) {{ 0, -1 }})
 #define ZEROREF ((union ref) {{ RICON, 0 }})
@@ -107,7 +107,7 @@ enum intrin {
 
 struct instr {
    uchar op,
-         cls; /* operation data class; also result class except for cmp ops (always i4) */
+         cls; /* operation data class; also result class except for cmp ops (always i32) */
    uchar skip : 1, /* ignore during codegen: forms part of one machine instruction */
          keep : 1; /* for codegen, keep instr even if result seems unused */
    uchar inplace : 1; /* set (by isel) for instructions which modify its first arg in place */
@@ -233,7 +233,7 @@ union irtype mkirtype(union type);
 union ref mkintcon(enum irclass, vlong);
 union ref mkfltcon(enum irclass, double);
 #define iscon(r) in_range((r).t, RICON, RXCON)
-#define concls(r) ((r).t == RICON ? KI4 : conht[(r).i].cls)
+#define concls(r) ((r).t == RICON ? KI32 : conht[(r).i].cls)
 #define isintcon(r) (iscon(r) && kisint(concls(r)))
 #define isfltcon(r) ((r).t == RXCON && kisflt(conht[(r).i].cls))
 #define isnumcon(r) ((r).t == RICON || ((r).t == RXCON && conht[(r).i].cls))
diff --git a/ir/optmem.c b/ir/optmem.c
index d8783d5..41d123a 100644
--- a/ir/optmem.c
+++ b/ir/optmem.c
@@ -2,12 +2,12 @@
 #include <stdlib.h> /* qsort */
 
 static const uchar loadszcls[] = {
-   [Oloads1 - Oloads1] = 1|KI4<<4, [Oloadu1 - Oloads1] = 1|KI4<<4,
-   [Oloads2 - Oloads1] = 2|KI4<<4, [Oloadu2 - Oloads1] = 2|KI4<<4,
-   [Oloads4 - Oloads1] = 4|KI4<<4, [Oloadu4 - Oloads1] = 4|KI4<<4,
-   [Oloadi8 - Oloads1] = 8|KI8<<4,
-   [Oloadf4 - Oloads1] = 4|KF4<<4,
-   [Oloadf8 - Oloads1] = 8|KF8<<4,
+   [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,
 };
 static const uchar load2ext[] = {
    [Oloads1 - Oloads1] = Oexts1, [Oloadu1 - Oloads1] = Oextu1,
@@ -291,7 +291,7 @@ mem2reg(struct function *fn)
                if (!val.bits) { /* var is used uninitialized */
                   /* TODO emit diagnostic */
                   /* load some garbage */
-                  *m = mkinstr(kisflt(k) ? Oloadf4 + (k==KF8) : Oloads1+ilog2(sz)*2,
+                  *m = mkinstr(kisflt(k) ? Oloadf4 + (k==KF64) : Oloads1+ilog2(sz)*2,
                                k, mkref(RREG, mctarg->bpr));
                } else {
                   adduse(use->blk, use->u, val);
diff --git a/ir/regalloc.c b/ir/regalloc.c
index 9857d61..df40ad4 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 KI4: mv.op = Oloads4; break;
-      case KI8: mv.op = Oloadi8; break;
+      case KI32: mv.op = Oloads4; break;
+      case KI64: mv.op = Oloadi8; break;
       case KPTR: mv.op = targ_64bit ? Oloadi8 : Oloads4; break;
-      case KF4: mv.op = Oloadf4; break;
-      case KF8: mv.op = Oloadf8; break;
+      case KF32: mv.op = Oloadf4; break;
+      case KF64: mv.op = Oloadf8; break;
       }
       if (dst.t == AREG)
          reg = dst.a;
@@ -976,7 +976,7 @@ devirt(struct rega *ra, struct block *blk)
 
       for (int i = 0; i < nargref; ++i) {
          static uchar cls2load[] = {
-            [KI4] = Oloads4, [KI8] = Oloadi8, [KF4] = Oloadf4, [KF8] = Oloadf8, [KPTR] = 0
+            [KI32] = Oloads4, [KI64] = Oloadi8, [KF32] = Oloadf4, [KF64] = Oloadf8, [KPTR] = 0
          };
          cls2load[KPTR] = targ_64bit ? Oloadi8 : Oloads4;
          union ref *r = argref[i];
diff --git a/ir/ssa.c b/ir/ssa.c
index 9b89878..5a3db2f 100644
--- a/ir/ssa.c
+++ b/ir/ssa.c
@@ -15,7 +15,7 @@ copyopt(struct function *fn)
          if (ins->op == Ocopy) {
             union ref arg = ins->l;
             if (arg.t == RTMP) k = insrescls(instrtab[arg.i]);
-            else if (arg.t == RICON) k = cls2siz[ins->cls] == 4 ? KI4 : KI8;
+            else if (arg.t == RICON) k = cls2siz[ins->cls] == 4 ? KI32 : KI64;
             else if (arg.t == RXCON) k = isnumcon(arg) ? conht[arg.i].cls : KPTR;
             else continue;
             if (ins->cls != k) continue;