Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Cranelift: x64: branch on flags for usub/sadd/ssub_overflow (#14717)

Satti Vamsi Krishna Reddy046148a04b92
diff --git a/cranelift/codegen/src/isa/x64/inst.isle b/cranelift/codegen/src/isa/x64/inst.isle
index 25ac578eb2..ec2fe71e0a 100644
--- a/cranelift/codegen/src/isa/x64/inst.isle
+++ b/cranelift/codegen/src/isa/x64/inst.isle
@@ -3892,8 +3892,10 @@
(rule 2 (is_nonzero (band _ a @ (value_type (ty_int (fits_in_64 ty))) b))
(is_nonzero_band ty a b))
-;; Using the flags output of `uadd_overflow` can produce a `CC` and give an
-;; opportunistic def of the other output.
+;; Using the flags output of `uadd_overflow`, `usub_overflow`, `sadd_overflow`
+;; or `ssub_overflow` can produce a `CC` and give an opportunistic def of the
+;; other output. The `add`/`sub` itself sets the flags: CF is the carry or
+;; borrow (unsigned overflow, `CC.B`) and OF is signed overflow (`CC.O`).
(rule 3
(is_nonzero
(is_second_result uadd @ (uadd_overflow (fits_in_64 ty) x y)))
@@ -3903,6 +3905,33 @@
(produces_flags_opportunistic_def producer sum_value)
(CC.B))))
+(rule 3
+ (is_nonzero
+ (is_second_result usub @ (usub_overflow (fits_in_64 ty) x y)))
+ (if-let (first_result diff_value) usub)
+ (let ((producer ProducesFlags (x64_sub_with_flags_paired ty x y)))
+ (CondResult.CC
+ (produces_flags_opportunistic_def producer diff_value)
+ (CC.B))))
+
+(rule 3
+ (is_nonzero
+ (is_second_result sadd @ (sadd_overflow (fits_in_64 ty) x y)))
+ (if-let (first_result sum_value) sadd)
+ (let ((producer ProducesFlags (x64_add_with_flags_paired ty x y)))
+ (CondResult.CC
+ (produces_flags_opportunistic_def producer sum_value)
+ (CC.O))))
+
+(rule 3
+ (is_nonzero
+ (is_second_result ssub @ (ssub_overflow (fits_in_64 ty) x y)))
+ (if-let (first_result diff_value) ssub)
+ (let ((producer ProducesFlags (x64_sub_with_flags_paired ty x y)))
+ (CondResult.CC
+ (produces_flags_opportunistic_def producer diff_value)
+ (CC.O))))
+
;; Using the flags output of `umul_overflow`/`smul_overflow` can produce a
;; `CC` and give an opportunistic def of the other output. The multiply
;; itself sets the overflow flag (OF for `imul`; OF==CF for the unsigned
diff --git a/cranelift/codegen/src/isa/x64/lower.isle b/cranelift/codegen/src/isa/x64/lower.isle
index 4286be5fc8..453cbe654d 100644
--- a/cranelift/codegen/src/isa/x64/lower.isle
+++ b/cranelift/codegen/src/isa/x64/lower.isle
@@ -204,6 +204,12 @@
;;;; Rules for `sadd_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; As for `uadd_overflow`: no `setcc` when the flags have no non-folded uses.
+(rule 3 (lower i @ (sadd_overflow (fits_in_64 ty) x y))
+ (if-let (second_result flags) i)
+ (if-let false (value_used flags))
+ (output_pair (value_reg (x64_add ty x y)) (value_regs_invalid)))
+
(rule 1 (lower (sadd_overflow _ x y @ (value_type (fits_in_64 ty))))
(construct_overflow_op_alu ty (CC.O) (ProduceFlagsOp.Add) x y))
@@ -212,6 +218,12 @@
;;;; Rules for `usub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; As for `uadd_overflow`: no `setcc` when the flags have no non-folded uses.
+(rule 3 (lower i @ (usub_overflow (fits_in_64 ty) x y))
+ (if-let (second_result flags) i)
+ (if-let false (value_used flags))
+ (output_pair (value_reg (x64_sub ty x y)) (value_regs_invalid)))
+
(rule 1 (lower (usub_overflow _ x y @ (value_type (fits_in_64 ty))))
(construct_overflow_op_alu ty (CC.B) (ProduceFlagsOp.Sub) x y))
@@ -220,6 +232,12 @@
;;;; Rules for `ssub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; As for `uadd_overflow`: no `setcc` when the flags have no non-folded uses.
+(rule 3 (lower i @ (ssub_overflow (fits_in_64 ty) x y))
+ (if-let (second_result flags) i)
+ (if-let false (value_used flags))
+ (output_pair (value_reg (x64_sub ty x y)) (value_regs_invalid)))
+
(rule 1 (lower (ssub_overflow _ x y @ (value_type (fits_in_64 ty))))
(construct_overflow_op_alu ty (CC.O) (ProduceFlagsOp.Sub) x y))
diff --git a/cranelift/filetests/filetests/isa/x64/sadd_ssub_usub_overflow_brif.clif b/cranelift/filetests/filetests/isa/x64/sadd_ssub_usub_overflow_brif.clif
new file mode 100644
index 0000000000..5ff2a43b00
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/sadd_ssub_usub_overflow_brif.clif
@@ -0,0 +1,716 @@
+test compile precise-output
+set opt_level=speed
+target x86_64
+
+function %usub_bool_unused_i64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i64 1
+ return v4
+
+block2:
+ v5 = iconst.i64 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; subq %rsi, %rdi
+; jb label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; subq %rsi, %rdi
+; jb 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %usub_bool_unused_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v4
+
+block2:
+ v5 = iconst.i8 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; subb %sil, %dil
+; jb label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; subb %sil, %dil
+; jb 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %sadd_bool_unused_i64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i64 1
+ return v4
+
+block2:
+ v5 = iconst.i64 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; addq %rsi, %rdi
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; addq %rsi, %rdi
+; jo 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %sadd_bool_unused_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v4
+
+block2:
+ v5 = iconst.i8 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; addb %sil, %dil
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; addb %sil, %dil
+; jo 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %ssub_bool_unused_i64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i64 1
+ return v4
+
+block2:
+ v5 = iconst.i64 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; subq %rsi, %rdi
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; subq %rsi, %rdi
+; jo 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %ssub_bool_unused_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v4
+
+block2:
+ v5 = iconst.i8 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; subb %sil, %dil
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movl $0x1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; subb %sil, %dil
+; jo 0x17
+; block2: ; offset 0xd
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x17
+; movl $1, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %usub_used_in_dominated_block(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iadd v2, v0
+ return v4
+
+block2:
+ v5 = iconst.i32 2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq %rdi, %r8
+; subl %esi, %r8d
+; jb label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; leal (%r8, %rdi), %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq %rdi, %r8
+; subl %esi, %r8d
+; jb 0x1a
+; block2: ; offset 0x10
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x1a
+; leal (%r8, %rdi), %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %sadd_used_between_def_and_branch(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+ v2, v3 = sadd_overflow v0, v1
+ store.i64 v2, v1
+ brif v3, block1, block2
+
+block1:
+ return v2
+
+block2:
+ v6 = iconst.i64 2
+ return v6
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq %rdi, %rax
+; addq %rsi, %rax
+; movq %rax, (%rsi)
+; addq %rsi, %rdi
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq %rdi, %rax
+; addq %rsi, %rax
+; movq %rax, (%rsi) ; trap: heap_oob
+; addq %rsi, %rdi
+; jo 0x20
+; block2: ; offset 0x16
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x20
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %ssub_flags_materialized(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+ v3, v4 = ssub_overflow v0, v1
+ v5 = uextend.i64 v4
+ v6 = iadd v5, v2
+ brif v4, block1, block2
+
+block1:
+ v7 = iadd v3, v6
+ return v7
+
+block2:
+ v8 = iconst.i64 2
+ return v8
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq %rdi, %r9
+; subq %rsi, %r9
+; seto %r11b
+; subq %rsi, %rdi
+; jo label2; j label1
+; block1:
+; movl $0x2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movzbq %r11b, %rax
+; leaq (%rax, %rdx), %rax
+; leaq (%r9, %rax), %rax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq %rdi, %r9
+; subq %rsi, %r9
+; seto %r11b
+; subq %rsi, %rdi
+; jo 0x21
+; block2: ; offset 0x17
+; movl $2, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x21
+; movzbq %r11b, %rax
+; addq %rdx, %rax
+; addq %r9, %rax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %usub_branch_in_different_block(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+ v2, v3 = usub_overflow v0, v1
+ v4 = iadd v2, v0
+ jump block2
+
+block1:
+ return v4
+
+block2:
+ brif v3, block1, block3
+
+block3:
+ return v2
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq %rdi, %rax
+; subl %esi, %eax
+; jmp label1
+; block1:
+; movq %rdi, %r8
+; subl %esi, %r8d
+; jb label3; j label2
+; block2:
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3:
+; leal (%rax, %rdi), %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq %rdi, %rax
+; subl %esi, %eax
+; block2: ; offset 0x9
+; movq %rdi, %r8
+; subl %esi, %r8d
+; jb 0x1a
+; block3: ; offset 0x15
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block4: ; offset 0x1a
+; addl %edi, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %usub_no_load_sinking(i64) -> i8 {
+block0(v0: i64):
+ v1 = load.i64 v0
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1(v3), block2
+
+block1(v4: i8):
+ return v4
+
+block2:
+ v5 = iconst.i8 42
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq (%rdi), %rsi
+; movq %rdi, %r8
+; subq %rsi, %r8
+; setb %al
+; subq %rsi, %rdi
+; jb label2; j label1
+; block1:
+; movl $0x2a, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq (%rdi), %rsi ; trap: heap_oob
+; movq %rdi, %r8
+; subq %rsi, %r8
+; setb %al
+; subq %rsi, %rdi
+; jb 0x23
+; block2: ; offset 0x19
+; movl $0x2a, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x23
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %ssub_no_load_sinking(i64) -> i8 {
+block0(v0: i64):
+ v1 = load.i64 v0
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1(v3), block2
+
+block1(v4: i8):
+ return v4
+
+block2:
+ v5 = iconst.i8 42
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movq (%rdi), %rsi
+; movq %rdi, %r8
+; subq %rsi, %r8
+; seto %al
+; subq %rsi, %rdi
+; jo label2; j label1
+; block1:
+; movl $0x2a, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movq (%rdi), %rsi ; trap: heap_oob
+; movq %rdi, %r8
+; subq %rsi, %r8
+; seto %al
+; subq %rsi, %rdi
+; jo 0x23
+; block2: ; offset 0x19
+; movl $0x2a, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x23
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %sadd_no_load_sinking_sum_used_between(i64, i32) -> i32 {
+block0(v0: i64, v1: i32):
+ v2 = load.i32 v0
+ v3, v4 = sadd_overflow v1, v2
+ v5 = iadd v3, v1
+ brif v4, block1(v5), block2
+
+block1(v6: i32):
+ return v6
+
+block2:
+ return v1
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; movl (%rdi), %edi
+; movq %rsi, %r8
+; addl %edi, %r8d
+; movq %rsi, %rax
+; jo label2; j label1
+; block1:
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block2:
+; leal (%r8, %rax), %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; movl (%rdi), %edi ; trap: heap_oob
+; movq %rsi, %r8
+; addl %edi, %r8d
+; movq %rsi, %rax
+; jo 0x1a
+; block2: ; offset 0x15
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; block3: ; offset 0x1a
+; addl %r8d, %eax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+
+function %usub_flags_trapz(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+ v3, v4 = usub_overflow v0, v1
+ trapz v4, user1
+ v5 = iadd v3, v2
+ return v5
+}
+
+; VCode:
+; pushq %rbp
+; movq %rsp, %rbp
+; block0:
+; subq %rsi, %rdi
+; jnb #trap=user1
+; leaq (%rdi, %rdx), %rax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+;
+; Disassembled:
+; block0: ; offset 0x0
+; pushq %rbp
+; movq %rsp, %rbp
+; block1: ; offset 0x4
+; subq %rsi, %rdi
+; jae 0x16
+; leaq (%rdi, %rdx), %rax
+; movq %rbp, %rsp
+; popq %rbp
+; retq
+; ud2 ; trap: user1
+
diff --git a/cranelift/filetests/filetests/runtests/sadd_ssub_usub_overflow_brif.clif b/cranelift/filetests/filetests/runtests/sadd_ssub_usub_overflow_brif.clif
new file mode 100644
index 0000000000..57a863e4b3
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/sadd_ssub_usub_overflow_brif.clif
@@ -0,0 +1,313 @@
+test interpret
+test run
+target x86_64
+
+;; These tests execute the folded lowerings of `usub_overflow`,
+;; `sadd_overflow` and `ssub_overflow` where the flags output is consumed
+;; by a `brif` instead of being materialized as a bool.
+
+function %usubof_brif_i64(i64, i64) -> i64, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %usubof_brif_i64(1, 0) == [1, 0]
+; run: %usubof_brif_i64(0, 1) == [-1, 1]
+; run: %usubof_brif_i64(0x80000000_00000000, 0x7FFFFFFF_FFFFFFFF) == [1, 0]
+; run: %usubof_brif_i64(0x7FFFFFFF_FFFFFFFF, 0x80000000_00000000) == [-1, 1]
+; run: %usubof_brif_i64(-1, -1) == [0, 0]
+; run: %usubof_brif_i64(0, -1) == [1, 1]
+
+function %usubof_brif_i32(i32, i32) -> i32, i8 {
+block0(v0: i32, v1: i32):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %usubof_brif_i32(1, 0) == [1, 0]
+; run: %usubof_brif_i32(0, 1) == [-1, 1]
+; run: %usubof_brif_i32(0x80000000, 0x7FFFFFFF) == [1, 0]
+; run: %usubof_brif_i32(0x7FFFFFFF, 0x80000000) == [-1, 1]
+; run: %usubof_brif_i32(-1, -1) == [0, 0]
+; run: %usubof_brif_i32(0, -1) == [1, 1]
+
+function %usubof_brif_i16(i16, i16) -> i16, i8 {
+block0(v0: i16, v1: i16):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %usubof_brif_i16(1, 0) == [1, 0]
+; run: %usubof_brif_i16(0, 1) == [-1, 1]
+; run: %usubof_brif_i16(0x8000, 0x7FFF) == [1, 0]
+; run: %usubof_brif_i16(0x7FFF, 0x8000) == [-1, 1]
+; run: %usubof_brif_i16(-1, -1) == [0, 0]
+; run: %usubof_brif_i16(0, -1) == [1, 1]
+
+function %usubof_brif_i8(i8, i8) -> i8, i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %usubof_brif_i8(1, 0) == [1, 0]
+; run: %usubof_brif_i8(0, 1) == [-1, 1]
+; run: %usubof_brif_i8(0x80, 0x7F) == [1, 0]
+; run: %usubof_brif_i8(0x7F, 0x80) == [-1, 1]
+; run: %usubof_brif_i8(-1, -1) == [0, 0]
+; run: %usubof_brif_i8(0, -1) == [1, 1]
+
+function %saddof_brif_i64(i64, i64) -> i64, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %saddof_brif_i64(0, 1) == [1, 0]
+; run: %saddof_brif_i64(0x7FFFFFFF_FFFFFFFF, 1) == [0x80000000_00000000, 1]
+; run: %saddof_brif_i64(0x80000000_00000000, -1) == [0x7FFFFFFF_FFFFFFFF, 1]
+; run: %saddof_brif_i64(-1, -1) == [-2, 0]
+; run: %saddof_brif_i64(0x7FFFFFFF_FFFFFFFF, 0x80000000_00000000) == [-1, 0]
+; run: %saddof_brif_i64(0x80000000_00000000, 0x80000000_00000000) == [0, 1]
+
+function %saddof_brif_i32(i32, i32) -> i32, i8 {
+block0(v0: i32, v1: i32):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %saddof_brif_i32(0, 1) == [1, 0]
+; run: %saddof_brif_i32(0x7FFFFFFF, 1) == [0x80000000, 1]
+; run: %saddof_brif_i32(0x80000000, -1) == [0x7FFFFFFF, 1]
+; run: %saddof_brif_i32(-1, -1) == [-2, 0]
+; run: %saddof_brif_i32(0x7FFFFFFF, 0x80000000) == [-1, 0]
+; run: %saddof_brif_i32(0x80000000, 0x80000000) == [0, 1]
+
+function %saddof_brif_i16(i16, i16) -> i16, i8 {
+block0(v0: i16, v1: i16):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %saddof_brif_i16(0, 1) == [1, 0]
+; run: %saddof_brif_i16(0x7FFF, 1) == [0x8000, 1]
+; run: %saddof_brif_i16(0x8000, -1) == [0x7FFF, 1]
+; run: %saddof_brif_i16(-1, -1) == [-2, 0]
+; run: %saddof_brif_i16(0x7FFF, 0x8000) == [-1, 0]
+; run: %saddof_brif_i16(0x8000, 0x8000) == [0, 1]
+
+function %saddof_brif_i8(i8, i8) -> i8, i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %saddof_brif_i8(0, 1) == [1, 0]
+; run: %saddof_brif_i8(0x7F, 1) == [0x80, 1]
+; run: %saddof_brif_i8(0x80, -1) == [0x7F, 1]
+; run: %saddof_brif_i8(-1, -1) == [-2, 0]
+; run: %saddof_brif_i8(0x7F, 0x80) == [-1, 0]
+; run: %saddof_brif_i8(0x80, 0x80) == [0, 1]
+
+function %ssubof_brif_i64(i64, i64) -> i64, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %ssubof_brif_i64(1, 0) == [1, 0]
+; run: %ssubof_brif_i64(0x80000000_00000000, 1) == [0x7FFFFFFF_FFFFFFFF, 1]
+; run: %ssubof_brif_i64(0x7FFFFFFF_FFFFFFFF, -1) == [0x80000000_00000000, 1]
+; run: %ssubof_brif_i64(-1, 0x7FFFFFFF_FFFFFFFF) == [0x80000000_00000000, 0]
+; run: %ssubof_brif_i64(-1, -1) == [0, 0]
+; run: %ssubof_brif_i64(0, 0x80000000_00000000) == [0x80000000_00000000, 1]
+
+function %ssubof_brif_i32(i32, i32) -> i32, i8 {
+block0(v0: i32, v1: i32):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %ssubof_brif_i32(1, 0) == [1, 0]
+; run: %ssubof_brif_i32(0x80000000, 1) == [0x7FFFFFFF, 1]
+; run: %ssubof_brif_i32(0x7FFFFFFF, -1) == [0x80000000, 1]
+; run: %ssubof_brif_i32(-1, 0x7FFFFFFF) == [0x80000000, 0]
+; run: %ssubof_brif_i32(-1, -1) == [0, 0]
+; run: %ssubof_brif_i32(0, 0x80000000) == [0x80000000, 1]
+
+function %ssubof_brif_i16(i16, i16) -> i16, i8 {
+block0(v0: i16, v1: i16):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %ssubof_brif_i16(1, 0) == [1, 0]
+; run: %ssubof_brif_i16(0x8000, 1) == [0x7FFF, 1]
+; run: %ssubof_brif_i16(0x7FFF, -1) == [0x8000, 1]
+; run: %ssubof_brif_i16(-1, 0x7FFF) == [0x8000, 0]
+; run: %ssubof_brif_i16(-1, -1) == [0, 0]
+; run: %ssubof_brif_i16(0, 0x8000) == [0x8000, 1]
+
+function %ssubof_brif_i8(i8, i8) -> i8, i8 {
+block0(v0: i8, v1: i8):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v2, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v2, v5
+}
+
+; run: %ssubof_brif_i8(1, 0) == [1, 0]
+; run: %ssubof_brif_i8(0x80, 1) == [0x7F, 1]
+; run: %ssubof_brif_i8(0x7F, -1) == [0x80, 1]
+; run: %ssubof_brif_i8(-1, 0x7F) == [0x80, 0]
+; run: %ssubof_brif_i8(-1, -1) == [0, 0]
+; run: %ssubof_brif_i8(0, 0x80) == [0x80, 1]
+
+function %usubof_brif_and_materialized_i64(i64, i64) -> i8, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = usub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v3, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v3, v5
+}
+
+; run: %usubof_brif_and_materialized_i64(1, 0) == [0, 0]
+; run: %usubof_brif_and_materialized_i64(0, 1) == [1, 1]
+; run: %usubof_brif_and_materialized_i64(0x80000000_00000000, 0x7FFFFFFF_FFFFFFFF) == [0, 0]
+
+function %saddof_brif_and_materialized_i64(i64, i64) -> i8, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = sadd_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v3, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v3, v5
+}
+
+; run: %saddof_brif_and_materialized_i64(0, 1) == [0, 0]
+; run: %saddof_brif_and_materialized_i64(0x7FFFFFFF_FFFFFFFF, 1) == [1, 1]
+; run: %saddof_brif_and_materialized_i64(0x80000000_00000000, -1) == [1, 1]
+
+function %ssubof_brif_and_materialized_i64(i64, i64) -> i8, i8 {
+block0(v0: i64, v1: i64):
+ v2, v3 = ssub_overflow v0, v1
+ brif v3, block1, block2
+
+block1:
+ v4 = iconst.i8 1
+ return v3, v4
+
+block2:
+ v5 = iconst.i8 0
+ return v3, v5
+}
+
+; run: %ssubof_brif_and_materialized_i64(1, 0) == [0, 0]
+; run: %ssubof_brif_and_materialized_i64(0x80000000_00000000, 1) == [1, 1]
+; run: %ssubof_brif_and_materialized_i64(0x7FFFFFFF_FFFFFFFF, -1) == [1, 1]