Legalize several i8 insts (#380)

* Legalize several i8 insts

* X86: implement regmove.{i8,i16}

* Legalize bnot

* Remove comments

* Nicer type param binding in legalize.py

* Legalize sdiv_imm.i8

* Hopefully fix mypy error

* Add missing trailing newlines

* Fix tests

lib/codegen/meta/base/legalize.py

@@ -10,6 +10,7 @@ from __future__ import absolute_import
 from .immediates import intcc, imm64, ieee32, ieee64
 from . import instructions as insts
 from . import types
+from .instructions import uextend, sextend, ireduce
 from .instructions import iadd, iadd_cout, iadd_cin, iadd_carry, iadd_imm
 from .instructions import isub, isub_bin, isub_bout, isub_borrow, irsub_imm
 from .instructions import imul, imul_imm
@@ -23,6 +24,8 @@ from .instructions import iconst, bint, select
 from .instructions import ishl, ishl_imm, sshr, sshr_imm, ushr, ushr_imm
 from .instructions import rotl, rotl_imm, rotr, rotr_imm
 from .instructions import f32const, f64const
+from .instructions import store, load
+from .instructions import br_table
 from cdsl.ast import Var
 from cdsl.xform import Rtl, XFormGroup
 
@@ -41,8 +44,6 @@ widen = XFormGroup('widen', """
 
         The transformations in the 'widen' group work by expressing
         instructions in terms of larger types.
-
-        This group is not yet implemented.
         """)
 
 expand = XFormGroup('expand', """
@@ -99,6 +100,7 @@ c1 = Var('c1')
 c2 = Var('c2')
 c_in = Var('c_in')
 c_int = Var('c_int')
+d = Var('d')
 xl = Var('xl')
 xh = Var('xh')
 yl = Var('yl')
@@ -106,6 +108,10 @@ yh = Var('yh')
 al = Var('al')
 ah = Var('ah')
 cc = Var('cc')
+ptr = Var('ptr')
+flags = Var('flags')
+offset = Var('off')
+ss = Var('ss')
 
 narrow.legalize(
         a << iadd(x, y),
@@ -148,6 +154,108 @@ narrow.legalize(
             a << iconcat(al, ah)
         ))
 
+for int_ty in [types.i8, types.i16]:
+    widen.legalize(
+        a << iconst.bind(int_ty)(b),
+        Rtl(
+            c << iconst.i32(b),
+            a << ireduce.bind(int_ty)(c)
+        ))
+
+widen.legalize(
+    store.i8(flags, a, ptr, offset),
+    Rtl(
+        b << uextend.i32(a),
+        insts.istore8(flags, b, ptr, offset)
+    ))
+
+widen.legalize(
+    store.i16(flags, a, ptr, offset),
+    Rtl(
+        b << uextend.i32(a),
+        insts.istore16(flags, b, ptr, offset)
+    ))
+
+widen.legalize(
+    a << load.i8(flags, ptr, offset),
+    Rtl(
+        b << insts.uload8.i32(flags, ptr, offset),
+        a << ireduce(b)
+    ))
+
+widen.legalize(
+    a << load.i16(flags, ptr, offset),
+    Rtl(
+        b << insts.uload16.i32(flags, ptr, offset),
+        a << ireduce(b)
+    ))
+
+for binop in [iadd, isub, imul, udiv, band, bor, bxor]:
+    for int_ty in [types.i8, types.i16]:
+        widen.legalize(
+            a << binop.bind(int_ty)(x, y),
+            Rtl(
+                b << uextend.i32(x),
+                c << uextend.i32(y),
+                d << binop(b, c),
+                a << ireduce(d)
+            )
+        )
+
+for binop in [sdiv]:
+    for int_ty in [types.i8, types.i16]:
+        widen.legalize(
+            a << binop.bind(int_ty)(x, y),
+            Rtl(
+                b << sextend.i32(x),
+                c << sextend.i32(y),
+                d << binop(b, c),
+                a << ireduce(d)
+            )
+        )
+
+for unop in [bnot]:
+    for int_ty in [types.i8, types.i16]:
+        widen.legalize(
+            a << unop.bind(int_ty)(x),
+            Rtl(
+                b << sextend.i32(x),
+                d << unop(b),
+                a << ireduce(d)
+            )
+        )
+
+for binop in [iadd_imm, imul_imm, udiv_imm]:
+    for int_ty in [types.i8, types.i16]:
+        widen.legalize(
+            a << binop.bind(int_ty)(x, y),
+            Rtl(
+                b << uextend.i32(x),
+                c << binop(b, y),
+                a << ireduce(c)
+            )
+        )
+
+for binop in [sdiv_imm]:
+    for int_ty in [types.i8, types.i16]:
+        widen.legalize(
+            a << binop.bind(int_ty)(x, y),
+            Rtl(
+                b << sextend.i32(x),
+                c << binop(b, y),
+                a << ireduce(c)
+            )
+        )
+
+for int_ty in [types.i8, types.i16]:
+    widen.legalize(
+        br_table.bind(int_ty)(x, y),
+        Rtl(
+            b << uextend.i32(x),
+            br_table(b, y),
+        )
+    )
+
 # Expand integer operations with carry for RISC architectures that don't have
 # the flags.
 expand.legalize(

lib/codegen/meta/isa/x86/encodings.py

@@ -6,6 +6,7 @@ from cdsl.predicates import IsZero32BitFloat, IsZero64BitFloat
 from cdsl.predicates import IsUnsignedInt, Not, And
 from base.predicates import IsColocatedFunc, IsColocatedData, LengthEquals
 from base import instructions as base
+from base import types
 from base.formats import UnaryIeee32, UnaryIeee64, UnaryImm
 from base.formats import FuncAddr, Call, LoadComplex, StoreComplex
 from .defs import X86_64, X86_32
@@ -13,7 +14,7 @@ from . import recipes as r
 from . import settings as cfg
 from . import instructions as x86
 from .legalize import x86_expand
-from base.legalize import narrow, expand_flags
+from base.legalize import narrow, widen, expand_flags
 from base.settings import allones_funcaddrs, is_pic
 from .settings import use_sse41
 
@@ -30,6 +31,8 @@ X86_32.legalize_monomorphic(expand_flags)
 X86_32.legalize_type(
     default=narrow,
     b1=expand_flags,
+    i8=widen,
+    i16=widen,
     i32=x86_expand,
     f32=x86_expand,
     f64=x86_expand)
@@ -38,6 +41,8 @@ X86_64.legalize_monomorphic(expand_flags)
 X86_64.legalize_type(
     default=narrow,
     b1=expand_flags,
+    i8=widen,
+    i16=widen,
     i32=x86_expand,
     i64=x86_expand,
     f32=x86_expand,
@@ -172,8 +177,9 @@ enc_both(base.copy.b1, r.umr, 0x89)
 
 # For x86-64, only define REX forms for now, since we can't describe the
 # special regunit immediate operands with the current constraint language.
-X86_32.enc(base.regmove.i32, *r.rmov(0x89))
-X86_64.enc(base.regmove.i32, *r.rmov.rex(0x89))
+for ty in [types.i8, types.i16, types.i32]:
+    X86_32.enc(base.regmove.bind(ty), *r.rmov(0x89))
+    X86_64.enc(base.regmove.bind(ty), *r.rmov.rex(0x89))
 X86_64.enc(base.regmove.i64, *r.rmov.rex(0x89, w=1))
 
 enc_both(base.regmove.b1, r.rmov, 0x89)