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.isleindex 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 unsigneddiff --git a/cranelift/codegen/src/isa/x64/lower.isle b/cranelift/codegen/src/isa/x64/lower.isleindex 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.clifnew file mode 100644index 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.clifnew file mode 100644index 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]