From 80acf74fb6f5e8a101dddb33973b559ccfb76ecb Mon Sep 17 00:00:00 2001 From: Ryan Ward Date: Thu, 1 Jan 2026 21:54:07 +1030 Subject: [PATCH 1/5] test: added codegen tests for permutations of `Option::or` --- .../issues/multiple-option-or-permutations.rs | 155 ++++++++++++++++++ 1 file changed, 155 insertions(+) create mode 100644 tests/codegen-llvm/issues/multiple-option-or-permutations.rs diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs new file mode 100644 index 000000000000..0106517c6fd5 --- /dev/null +++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs @@ -0,0 +1,155 @@ +// Tests output of multiple permutations of `Option::or` +//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled + +#![crate_type = "lib"] + +// CHECK-LABEL: @or_match_u8 +#[no_mangle] +pub fn or_match_u8(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: or i1 %0 + // CHECK-NEXT: select i1 %0 + // CHECK-NEXT: insertvalue { i1, i8 } + // CHECK-NEXT: insertvalue { i1, i8 } + // ret { i1, i8 } + match opta { + Some(x) => Some(x), + None => optb, + } +} + +// CHECK-LABEL: @or_match_alt_u8 +#[no_mangle] +pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: select i1 + // CHECK-NEXT: or i1 + // CHECK-NEXT: insertvalue { i1, i8 } + // CHECK-NEXT: insertvalue { i1, i8 } + // ret { i1, i8 } + match opta { + Some(_) => opta, + None => optb, + } +} + +// CHECK-LABEL: @option_or_u8 +#[no_mangle] +pub fn option_or_u8(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: select i1 + // CHECK-NEXT: or i1 + // CHECK-NEXT: insertvalue { i1, i8 } + // CHECK-NEXT: insertvalue { i1, i8 } + // ret { i1, i8 } + opta.or(optb) +} + +// CHECK-LABEL: @if_some_u8 +#[no_mangle] +pub fn if_some_u8(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: select i1 + // CHECK-NEXT: or i1 + // CHECK-NEXT: insertvalue { i1, i8 } + // CHECK-NEXT: insertvalue { i1, i8 } + // ret { i1, i8 } + if opta.is_some() { opta } else { optb } +} + +// CHECK-LABEL: @or_match_slice_u8 +#[no_mangle] +pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { + // CHECK: start: + // CHECK-NEXT: trunc i16 %0 to i1 + // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 + // ret i16 + match opta { + Some(x) => Some(x), + None => optb, + } +} + +// CHECK-LABEL: @or_match_slice_alt_u8 +#[no_mangle] +pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { + // CHECK: start: + // CHECK-NEXT: trunc i16 %0 to i1 + // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 + // ret i16 + match opta { + Some(_) => opta, + None => optb, + } +} + +// CHECK-LABEL: @option_or_slice_u8 +#[no_mangle] +pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { + // CHECK: start: + // CHECK-NEXT: trunc i16 %0 to i1 + // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 + // ret i16 + opta.or(optb) +} + +// CHECK-LABEL: @if_some_slice_u8 +#[no_mangle] +pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { + // CHECK: start: + // CHECK-NEXT: trunc i16 %0 to i1 + // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 + // ret i16 + if opta.is_some() { opta } else { optb } +} + +pub struct Test { + _a: u8, + _b: u8, +} + +// CHECK-LABEL: @or_match_type +#[no_mangle] +pub fn or_match_type(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: trunc i24 %0 to i1 + // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 + // ret i24 + match opta { + Some(x) => Some(x), + None => optb, + } +} + +// CHECK-LABEL: @or_match_alt_type +#[no_mangle] +pub fn or_match_alt_type(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: trunc i24 %0 to i1 + // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 + // ret i24 + match opta { + Some(_) => opta, + None => optb, + } +} + +// CHECK-LABEL: @option_or_type +#[no_mangle] +pub fn option_or_type(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: trunc i24 %0 to i1 + // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 + // ret i24 + opta.or(optb) +} + +// CHECK-LABEL: @if_some_type +#[no_mangle] +pub fn if_some_type(opta: Option, optb: Option) -> Option { + // CHECK: start: + // CHECK-NEXT: trunc i24 %0 to i1 + // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 + // ret i24 + if opta.is_some() { opta } else { optb } +} From bf2078bfcad890114e0aa17501e706e3bc1b4df0 Mon Sep 17 00:00:00 2001 From: Ryan <63398895+rwardd@users.noreply.github.com> Date: Fri, 2 Jan 2026 12:01:55 +1030 Subject: [PATCH 2/5] fix: add `CHECK-SAME` labels to verify generated function type for `u8` and `[u8; 1]` cases Co-authored-by: scottmcm --- tests/codegen-llvm/issues/multiple-option-or-permutations.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs index 0106517c6fd5..9fbd77166534 100644 --- a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs +++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs @@ -19,6 +19,7 @@ pub fn or_match_u8(opta: Option, optb: Option) -> Option { } // CHECK-LABEL: @or_match_alt_u8 +// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1) #[no_mangle] pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { // CHECK: start: @@ -58,6 +59,7 @@ pub fn if_some_u8(opta: Option, optb: Option) -> Option { } // CHECK-LABEL: @or_match_slice_u8 +// CHECK-SAME: (i16 %0, i16 %1) #[no_mangle] pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: From 66c4ead02dda94846a0801cc88c04fb04cc561fe Mon Sep 17 00:00:00 2001 From: Ryan Ward Date: Fri, 2 Jan 2026 12:52:42 +1030 Subject: [PATCH 3/5] fix: added further `CHECK-SAME` labels and replaced all `struct` input tests with `NonZero` input --- .../issues/multiple-option-or-permutations.rs | 82 +++++++++++-------- 1 file changed, 50 insertions(+), 32 deletions(-) diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs index 9fbd77166534..b45402f28a3a 100644 --- a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs +++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs @@ -3,12 +3,16 @@ #![crate_type = "lib"] +extern crate core; +use core::num::NonZero; + // CHECK-LABEL: @or_match_u8 +// CHECK-SAME: (i1{{.+}}%0, i8 %1, i1{{.+}}%optb.0, i8 %optb.1) #[no_mangle] pub fn or_match_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-NEXT: or i1 %0 - // CHECK-NEXT: select i1 %0 + // CHECK-DAG: or i1 %0 + // CHECK-DAG: select i1 %0 // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } @@ -23,8 +27,8 @@ pub fn or_match_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-NEXT: select i1 - // CHECK-NEXT: or i1 + // CHECK-DAG: select i1 + // CHECK-DAG: or i1 // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } @@ -35,11 +39,12 @@ pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { } // CHECK-LABEL: @option_or_u8 +// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1) #[no_mangle] pub fn option_or_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-NEXT: select i1 - // CHECK-NEXT: or i1 + // CHECK-DAG: select i1 + // CHECK-DAG: or i1 // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } @@ -47,17 +52,20 @@ pub fn option_or_u8(opta: Option, optb: Option) -> Option { } // CHECK-LABEL: @if_some_u8 +// CHECK-SAME: (i1{{.+}}%opta.0, i8 %opta.1, i1{{.+}}%optb.0, i8 %optb.1) #[no_mangle] pub fn if_some_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-NEXT: select i1 - // CHECK-NEXT: or i1 + // CHECK-DAG: select i1 + // CHECK-DAG: or i1 // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } if opta.is_some() { opta } else { optb } } +// Tests a case where an input is a type that is represented as `BackendRepr::Memory` + // CHECK-LABEL: @or_match_slice_u8 // CHECK-SAME: (i16 %0, i16 %1) #[no_mangle] @@ -73,6 +81,7 @@ pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option } // CHECK-LABEL: @or_match_slice_alt_u8 +// CHECK-SAME: (i16 %0, i16 %1) #[no_mangle] pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: @@ -86,6 +95,7 @@ pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Op } // CHECK-LABEL: @option_or_slice_u8 +// CHECK-SAME: (i16 %0, i16 %1) #[no_mangle] pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: @@ -96,6 +106,7 @@ pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Optio } // CHECK-LABEL: @if_some_slice_u8 +// CHECK-SAME: (i16 %0, i16 %1) #[no_mangle] pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: @@ -105,53 +116,60 @@ pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option< if opta.is_some() { opta } else { optb } } -pub struct Test { - _a: u8, - _b: u8, -} +// Test a niche optimization case of `NonZero` -// CHECK-LABEL: @or_match_type +// CHECK-LABEL: @or_match_nz_u8 +// CHECK-SAME: (i8{{.+}}%0, i8{{.+}}%optb) #[no_mangle] -pub fn or_match_type(opta: Option, optb: Option) -> Option { +pub fn or_match_nz_u8(opta: Option>, optb: Option>) -> Option> { // CHECK: start: - // CHECK-NEXT: trunc i24 %0 to i1 - // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 - // ret i24 + // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %0, 0 + // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %0 + // ret i8 match opta { Some(x) => Some(x), None => optb, } } -// CHECK-LABEL: @or_match_alt_type +// CHECK-LABEL: @or_match_alt_nz_u8 +// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb) #[no_mangle] -pub fn or_match_alt_type(opta: Option, optb: Option) -> Option { +pub fn or_match_alt_nz_u8( + opta: Option>, + optb: Option>, +) -> Option> { // CHECK: start: - // CHECK-NEXT: trunc i24 %0 to i1 - // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 - // ret i24 + // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta + // ret i8 match opta { Some(_) => opta, None => optb, } } -// CHECK-LABEL: @option_or_type +// CHECK-LABEL: @option_or_nz_u8 +// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb) #[no_mangle] -pub fn option_or_type(opta: Option, optb: Option) -> Option { +pub fn option_or_nz_u8( + opta: Option>, + optb: Option>, +) -> Option> { // CHECK: start: - // CHECK-NEXT: trunc i24 %0 to i1 - // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 - // ret i24 + // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta + // ret i8 opta.or(optb) } -// CHECK-LABEL: @if_some_type +// CHECK-LABEL: @if_some_nz_u8 +// CHECK-SAME: (i8{{.+}}%opta, i8{{.+}}%optb) #[no_mangle] -pub fn if_some_type(opta: Option, optb: Option) -> Option { +pub fn if_some_nz_u8(opta: Option>, optb: Option>) -> Option> { // CHECK: start: - // CHECK-NEXT: trunc i24 %0 to i1 - // CHECK-NEXT: select i1 %2, i24 %0, i24 %1 - // ret i24 + // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta + // ret i8 if opta.is_some() { opta } else { optb } } From 3df06f5083ef6c44e7f49f6520d62adc1f05aa58 Mon Sep 17 00:00:00 2001 From: Ryan <63398895+rwardd@users.noreply.github.com> Date: Sat, 3 Jan 2026 10:53:54 +1030 Subject: [PATCH 4/5] fix: use `std::num::NonZero` instead of `extern crate` and extend information in `CHECK-` directives Co-authored-by: scottmcm --- .../issues/multiple-option-or-permutations.rs | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs index b45402f28a3a..0ea7ef9a0f7e 100644 --- a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs +++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs @@ -3,16 +3,15 @@ #![crate_type = "lib"] -extern crate core; -use core::num::NonZero; +use std::num::NonZero; // CHECK-LABEL: @or_match_u8 // CHECK-SAME: (i1{{.+}}%0, i8 %1, i1{{.+}}%optb.0, i8 %optb.1) #[no_mangle] pub fn or_match_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: or i1 %0 // CHECK-DAG: select i1 %0 + // CHECK-DAG: or i1 %0 // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } @@ -27,8 +26,8 @@ pub fn or_match_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: select i1 - // CHECK-DAG: or i1 + // CHECK-DAG: select i1 %opta.0, i8 %opta.1, i8 %optb.1 + // CHECK-DAG: or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}} // CHECK-NEXT: insertvalue { i1, i8 } // CHECK-NEXT: insertvalue { i1, i8 } // ret { i1, i8 } From a2fcb0de187664d27aa6c312585bcf64ff1c909a Mon Sep 17 00:00:00 2001 From: Ryan Ward Date: Sat, 3 Jan 2026 12:50:38 +1030 Subject: [PATCH 5/5] fix: add `CHECK` directives to `ret` comments and be more pervasive with directive contents --- .../issues/multiple-option-or-permutations.rs | 88 +++++++++---------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs index 0ea7ef9a0f7e..9ec4ec8eeb15 100644 --- a/tests/codegen-llvm/issues/multiple-option-or-permutations.rs +++ b/tests/codegen-llvm/issues/multiple-option-or-permutations.rs @@ -10,11 +10,11 @@ use std::num::NonZero; #[no_mangle] pub fn or_match_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: select i1 %0 - // CHECK-DAG: or i1 %0 - // CHECK-NEXT: insertvalue { i1, i8 } - // CHECK-NEXT: insertvalue { i1, i8 } - // ret { i1, i8 } + // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %0, i8 %1, i8 %optb.1 + // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%0, %optb.0|%optb.0, %0}} + // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0 + // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1 + // CHECK: ret { i1, i8 } [[R]] match opta { Some(x) => Some(x), None => optb, @@ -26,11 +26,11 @@ pub fn or_match_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: select i1 %opta.0, i8 %opta.1, i8 %optb.1 - // CHECK-DAG: or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}} - // CHECK-NEXT: insertvalue { i1, i8 } - // CHECK-NEXT: insertvalue { i1, i8 } - // ret { i1, i8 } + // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1 + // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}} + // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0 + // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1 + // CHECK: ret { i1, i8 } [[R]] match opta { Some(_) => opta, None => optb, @@ -42,11 +42,11 @@ pub fn or_match_alt_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn option_or_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: select i1 - // CHECK-DAG: or i1 - // CHECK-NEXT: insertvalue { i1, i8 } - // CHECK-NEXT: insertvalue { i1, i8 } - // ret { i1, i8 } + // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1 + // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}} + // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0 + // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1 + // CHECK: ret { i1, i8 } [[R]] opta.or(optb) } @@ -55,11 +55,11 @@ pub fn option_or_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn if_some_u8(opta: Option, optb: Option) -> Option { // CHECK: start: - // CHECK-DAG: select i1 - // CHECK-DAG: or i1 - // CHECK-NEXT: insertvalue { i1, i8 } - // CHECK-NEXT: insertvalue { i1, i8 } - // ret { i1, i8 } + // CHECK-DAG: [[A_OR_B:%.+]] = select i1 %opta.0, i8 %opta.1, i8 %optb.1 + // CHECK-DAG: [[IS_SOME:%.+]] = or i1 {{%opta.0, %optb.0|%optb.0, %opta.0}} + // CHECK-NEXT: [[FLAG:%.+]] = insertvalue { i1, i8 } poison, i1 [[IS_SOME]], 0 + // CHECK-NEXT: [[R:%.+]] = insertvalue { i1, i8 } [[FLAG]], i8 [[A_OR_B]], 1 + // CHECK: ret { i1, i8 } [[R]] if opta.is_some() { opta } else { optb } } @@ -70,9 +70,9 @@ pub fn if_some_u8(opta: Option, optb: Option) -> Option { #[no_mangle] pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: - // CHECK-NEXT: trunc i16 %0 to i1 - // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 - // ret i16 + // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1 + // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1 + // CHECK: ret i16 [[R]] match opta { Some(x) => Some(x), None => optb, @@ -84,9 +84,9 @@ pub fn or_match_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option #[no_mangle] pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: - // CHECK-NEXT: trunc i16 %0 to i1 - // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 - // ret i16 + // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1 + // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1 + // CHECK: ret i16 [[R]] match opta { Some(_) => opta, None => optb, @@ -98,9 +98,9 @@ pub fn or_match_slice_alt_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Op #[no_mangle] pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: - // CHECK-NEXT: trunc i16 %0 to i1 - // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 - // ret i16 + // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1 + // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1 + // CHECK: ret i16 [[R]] opta.or(optb) } @@ -109,9 +109,9 @@ pub fn option_or_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Optio #[no_mangle] pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option<[u8; 1]> { // CHECK: start: - // CHECK-NEXT: trunc i16 %0 to i1 - // CHECK-NEXT: select i1 %2, i16 %0, i16 %1 - // ret i16 + // CHECK-NEXT: [[SOME_A:%.+]] = trunc i16 %0 to i1 + // CHECK-NEXT: [[R:%.+]] = select i1 [[SOME_A]], i16 %0, i16 %1 + // CHECK: ret i16 [[R]] if opta.is_some() { opta } else { optb } } @@ -122,9 +122,9 @@ pub fn if_some_slice_u8(opta: Option<[u8; 1]>, optb: Option<[u8; 1]>) -> Option< #[no_mangle] pub fn or_match_nz_u8(opta: Option>, optb: Option>) -> Option> { // CHECK: start: - // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %0, 0 - // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %0 - // ret i8 + // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %0, 0 + // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %0 + // CHECK: ret i8 [[R]] match opta { Some(x) => Some(x), None => optb, @@ -139,9 +139,9 @@ pub fn or_match_alt_nz_u8( optb: Option>, ) -> Option> { // CHECK: start: - // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 - // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta - // ret i8 + // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta + // CHECK: ret i8 [[R]] match opta { Some(_) => opta, None => optb, @@ -156,9 +156,9 @@ pub fn option_or_nz_u8( optb: Option>, ) -> Option> { // CHECK: start: - // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 - // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta - // ret i8 + // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta + // CHECK: ret i8 [[R]] opta.or(optb) } @@ -167,8 +167,8 @@ pub fn option_or_nz_u8( #[no_mangle] pub fn if_some_nz_u8(opta: Option>, optb: Option>) -> Option> { // CHECK: start: - // CHECK-NEXT: [[NOT_A:%.*]] = icmp eq i8 %opta, 0 - // CHECK-NEXT: select i1 [[NOT_A]], i8 %optb, i8 %opta - // ret i8 + // CHECK-NEXT: [[NOT_A:%.+]] = icmp eq i8 %opta, 0 + // CHECK-NEXT: [[R:%.+]] = select i1 [[NOT_A]], i8 %optb, i8 %opta + // CHECK: ret i8 [[R]] if opta.is_some() { opta } else { optb } }