Add narrowing legalization patterns for bitwise ops.

RISC-V 32-bit tests for band.i64, bor.i64, bxor.i64.

cranelift/filetests/isa/riscv/legalize-i64.cton

@@ -0,0 +1,42 @@
+; Test the legalization of i64 arithmetic instructions.
+test legalizer
+isa riscv supports_m=1
+
+function bitwise_and(i64, i64) -> i64 {
+ebb0(v1: i64, v2: i64):
+    v3 = band v1, v2
+    return v3
+}
+; regex: V=v\d+
+; regex: VX=vx\d+
+; check: $(v1l=$V), $(v1h=$VX) = isplit_lohi $v1
+; check: $(v2l=$V), $(v2h=$VX) = isplit_lohi $v2
+; check: $(v3l=$V) = band $v1l, $v2l
+; check: $(v3h=$V) = band $v1h, $v2h
+; check: $v3 = iconcat_lohi $v3l, $v3h
+
+function bitwise_or(i64, i64) -> i64 {
+ebb0(v1: i64, v2: i64):
+    v3 = bor v1, v2
+    return v3
+}
+; regex: V=v\d+
+; regex: VX=vx\d+
+; check: $(v1l=$V), $(v1h=$VX) = isplit_lohi $v1
+; check: $(v2l=$V), $(v2h=$VX) = isplit_lohi $v2
+; check: $(v3l=$V) = bor $v1l, $v2l
+; check: $(v3h=$V) = bor $v1h, $v2h
+; check: $v3 = iconcat_lohi $v3l, $v3h
+
+function bitwise_xor(i64, i64) -> i64 {
+ebb0(v1: i64, v2: i64):
+    v3 = bxor v1, v2
+    return v3
+}
+; regex: V=v\d+
+; regex: VX=vx\d+
+; check: $(v1l=$V), $(v1h=$VX) = isplit_lohi $v1
+; check: $(v2l=$V), $(v2h=$VX) = isplit_lohi $v2
+; check: $(v3l=$V) = bxor $v1l, $v2l
+; check: $(v3h=$V) = bxor $v1h, $v2h
+; check: $v3 = iconcat_lohi $v3l, $v3h

lib/cretonne/meta/cretonne/legalize.py

@@ -9,7 +9,7 @@ instructions that are legal.
 from __future__ import absolute_import
 from .base import iadd, iadd_cout, iadd_cin, iadd_carry
 from .base import isub, isub_bin, isub_bout, isub_borrow
-from .base import bor, isplit_lohi, iconcat_lohi
+from .base import band, bor, bxor, isplit_lohi, iconcat_lohi
 from .base import icmp
 from .ast import Var
 from .xform import Rtl, XFormGroup
@@ -71,6 +71,17 @@ narrow.legalize(
             a << iconcat_lohi(al, ah)
         ))
 
+for bitop in [band, bor, bxor]:
+    narrow.legalize(
+            a << bitop(x, y),
+            Rtl(
+                (xl, xh) << isplit_lohi(x),
+                (yl, yh) << isplit_lohi(y),
+                al << bitop(xl, yl),
+                ah << bitop(xh, yh),
+                a << iconcat_lohi(al, ah)
+            ))
+
 # Expand integer operations with carry for RISC architectures that don't have
 # the flags.
 expand.legalize(