[llvm-branch-commits] [llvm] [InstSimplify][InstCombine] Add vector tests for `bitinsert` and `bitextract` (PR #240197)
Pedro Lobo via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sun Nov 8 13:05:42 PST 2026
https://github.com/pedroclobo created https://github.com/llvm/llvm-project/pull/240197
Add vector tests for the `bitinsert` and `bitextract` folds that already work on scalar types.
Vectors were not implemented when the following landed, so none of them had vector tests:
- ConstantFolding's `poison` early exits (#229115).
- InstSimplify's out-of-range splat offsets, full-width forms, and `bitextract`/`bitinsert` round trips (#229125).
- InstCombine's full-width `bitcast` folds (#229147).
It also adds negative tests where only some elements of the offset are out of range or `poison`. Those elements become `poison`.
>From eb04b18c1b601ab220d8d6dcfc1745fc746a925a Mon Sep 17 00:00:00 2001
From: Pedro Lobo <pedro.lobo at tecnico.ulisboa.pt>
Date: Fri, 6 Nov 2026 17:03:55 +0000
Subject: [PATCH] [InstSimplify][InstCombine] Add vector tests for `bitinsert`
and `bitextract`
---
.../InstCombine/bitinsert-bitextract.ll | 93 ++++++++++++
.../ConstProp/bitinsert-bitextract.ll | 16 ++
.../InstSimplify/bitinsert-bitextract.ll | 140 ++++++++++++++++++
3 files changed, 249 insertions(+)
diff --git a/llvm/test/Transforms/InstCombine/bitinsert-bitextract.ll b/llvm/test/Transforms/InstCombine/bitinsert-bitextract.ll
index 59aef89ea5d99f..5ed8b3f7f2a9ef 100644
--- a/llvm/test/Transforms/InstCombine/bitinsert-bitextract.ll
+++ b/llvm/test/Transforms/InstCombine/bitinsert-bitextract.ll
@@ -148,3 +148,96 @@ define b64 @neg_bitinsert_variable_offset(b64 %x, i64 %y, i32 %n) {
%r = bitinsert b64 %x, i64 %y, i32 %n
ret b64 %r
}
+
+define <2 x i64> @bitextract_vec_full_width(<2 x b64> %x) {
+; CHECK-LABEL: define <2 x i64> @bitextract_vec_full_width(
+; CHECK-SAME: <2 x b64> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <2 x b64> [[X]] to <2 x i64>
+; CHECK-NEXT: ret <2 x i64> [[R]]
+;
+ %r = bitextract <2 x i64>, <2 x b64> %x, <2 x i32> zeroinitializer
+ ret <2 x i64> %r
+}
+
+define <2 x ptr> @bitextract_vec_full_width_ptr(<2 x b64> %x) {
+; CHECK-LABEL: define <2 x ptr> @bitextract_vec_full_width_ptr(
+; CHECK-SAME: <2 x b64> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <2 x b64> [[X]] to <2 x ptr>
+; CHECK-NEXT: ret <2 x ptr> [[R]]
+;
+ %r = bitextract <2 x ptr>, <2 x b64> %x, <2 x i32> zeroinitializer
+ ret <2 x ptr> %r
+}
+
+define <vscale x 2 x double> @bitextract_scalable_vec_full_width(<vscale x 2 x b64> %x) {
+; CHECK-LABEL: define <vscale x 2 x double> @bitextract_scalable_vec_full_width(
+; CHECK-SAME: <vscale x 2 x b64> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <vscale x 2 x b64> [[X]] to <vscale x 2 x double>
+; CHECK-NEXT: ret <vscale x 2 x double> [[R]]
+;
+ %r = bitextract <vscale x 2 x double>, <vscale x 2 x b64> %x, <vscale x 2 x i32> zeroinitializer
+ ret <vscale x 2 x double> %r
+}
+
+define <2 x b64> @bitinsert_vec_full_width(<2 x b64> %x, <2 x i64> %y) {
+; CHECK-LABEL: define <2 x b64> @bitinsert_vec_full_width(
+; CHECK-SAME: <2 x b64> [[X:%.*]], <2 x i64> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <2 x i64> [[Y]] to <2 x b64>
+; CHECK-NEXT: ret <2 x b64> [[R]]
+;
+ %r = bitinsert <2 x b64> %x, <2 x i64> %y, <2 x i32> zeroinitializer
+ ret <2 x b64> %r
+}
+
+define <2 x b64> @bitinsert_vec_full_width_ptr(<2 x b64> %x, <2 x ptr> %y) {
+; CHECK-LABEL: define <2 x b64> @bitinsert_vec_full_width_ptr(
+; CHECK-SAME: <2 x b64> [[X:%.*]], <2 x ptr> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <2 x ptr> [[Y]] to <2 x b64>
+; CHECK-NEXT: ret <2 x b64> [[R]]
+;
+ %r = bitinsert <2 x b64> %x, <2 x ptr> %y, <2 x i32> zeroinitializer
+ ret <2 x b64> %r
+}
+
+define <vscale x 2 x b64> @bitinsert_scalable_vec_full_width(<vscale x 2 x b64> %x, <vscale x 2 x double> %y) {
+; CHECK-LABEL: define <vscale x 2 x b64> @bitinsert_scalable_vec_full_width(
+; CHECK-SAME: <vscale x 2 x b64> [[X:%.*]], <vscale x 2 x double> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitcast <vscale x 2 x double> [[Y]] to <vscale x 2 x b64>
+; CHECK-NEXT: ret <vscale x 2 x b64> [[R]]
+;
+ %r = bitinsert <vscale x 2 x b64> %x, <vscale x 2 x double> %y, <vscale x 2 x i32> zeroinitializer
+ ret <vscale x 2 x b64> %r
+}
+
+; The elements are narrower than the source elements.
+define <2 x i32> @neg_bitextract_vec_partial(<2 x b64> %x) {
+; CHECK-LABEL: define <2 x i32> @neg_bitextract_vec_partial(
+; CHECK-SAME: <2 x b64> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitextract <2 x i32>, <2 x b64> [[X]], <2 x i32> zeroinitializer
+; CHECK-NEXT: ret <2 x i32> [[R]]
+;
+ %r = bitextract <2 x i32>, <2 x b64> %x, <2 x i32> zeroinitializer
+ ret <2 x i32> %r
+}
+
+; The offset may not be zero.
+define <2 x i64> @neg_bitextract_vec_variable_offset(<2 x b64> %x, <2 x i32> %n) {
+; CHECK-LABEL: define <2 x i64> @neg_bitextract_vec_variable_offset(
+; CHECK-SAME: <2 x b64> [[X:%.*]], <2 x i32> [[N:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitextract <2 x i64>, <2 x b64> [[X]], <2 x i32> [[N]]
+; CHECK-NEXT: ret <2 x i64> [[R]]
+;
+ %r = bitextract <2 x i64>, <2 x b64> %x, <2 x i32> %n
+ ret <2 x i64> %r
+}
+
+; The elements are narrower than the base elements.
+define <2 x b64> @neg_bitinsert_vec_partial(<2 x b64> %x, <2 x i32> %y) {
+; CHECK-LABEL: define <2 x b64> @neg_bitinsert_vec_partial(
+; CHECK-SAME: <2 x b64> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitinsert <2 x b64> [[X]], <2 x i32> [[Y]], <2 x i32> zeroinitializer
+; CHECK-NEXT: ret <2 x b64> [[R]]
+;
+ %r = bitinsert <2 x b64> %x, <2 x i32> %y, <2 x i32> zeroinitializer
+ ret <2 x b64> %r
+}
diff --git a/llvm/test/Transforms/InstSimplify/ConstProp/bitinsert-bitextract.ll b/llvm/test/Transforms/InstSimplify/ConstProp/bitinsert-bitextract.ll
index 5ea3d4b7b5bec2..cd858b461a1c0a 100644
--- a/llvm/test/Transforms/InstSimplify/ConstProp/bitinsert-bitextract.ll
+++ b/llvm/test/Transforms/InstSimplify/ConstProp/bitinsert-bitextract.ll
@@ -378,6 +378,22 @@ define b256 @neg_bitinsert_ppc_fp128() {
ret b256 %r
}
+define <2 x i8> @bitextract_vec_poison_src() {
+; CHECK-LABEL: define <2 x i8> @bitextract_vec_poison_src() {
+; CHECK-NEXT: ret <2 x i8> poison
+;
+ %r = bitextract <2 x i8>, <2 x b32> poison, <2 x i32> splat (i32 8)
+ ret <2 x i8> %r
+}
+
+define <2 x b32> @bitinsert_vec_poison_poison() {
+; CHECK-LABEL: define <2 x b32> @bitinsert_vec_poison_poison() {
+; CHECK-NEXT: ret <2 x b32> poison
+;
+ %r = bitinsert <2 x b32> poison, <2 x i8> poison, <2 x i32> splat (i32 8)
+ ret <2 x b32> %r
+}
+
; TODO: Fold vectors element by element.
define <vscale x 4 x i8> @bitextract_scalable_vec_splat() {
; CHECK-LABEL: define <vscale x 4 x i8> @bitextract_scalable_vec_splat() {
diff --git a/llvm/test/Transforms/InstSimplify/bitinsert-bitextract.ll b/llvm/test/Transforms/InstSimplify/bitinsert-bitextract.ll
index 448f1f197e8518..7c8252e9f63fc9 100644
--- a/llvm/test/Transforms/InstSimplify/bitinsert-bitextract.ll
+++ b/llvm/test/Transforms/InstSimplify/bitinsert-bitextract.ll
@@ -295,6 +295,37 @@ define b32 @neg_bitinsert_bitextract_other_offset(b32 %x) {
ret b32 %r
}
+define <4 x i8> @bitextract_vec_out_of_range(<4 x b32> %x) {
+; CHECK-LABEL: define <4 x i8> @bitextract_vec_out_of_range(
+; CHECK-SAME: <4 x b32> [[X:%.*]]) {
+; CHECK-NEXT: ret <4 x i8> poison
+;
+ %r = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> splat (i32 25)
+ ret <4 x i8> %r
+}
+
+; The last bits of each element are in range.
+define <4 x i8> @neg_bitextract_vec_in_range(<4 x b32> %x) {
+; CHECK-LABEL: define <4 x i8> @neg_bitextract_vec_in_range(
+; CHECK-SAME: <4 x b32> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitextract <4 x i8>, <4 x b32> [[X]], <4 x i32> splat (i32 24)
+; CHECK-NEXT: ret <4 x i8> [[R]]
+;
+ %r = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> splat (i32 24)
+ ret <4 x i8> %r
+}
+
+; Only the last lane is out of range.
+define <4 x i8> @neg_bitextract_vec_non_splat_offset(<4 x b32> %x) {
+; CHECK-LABEL: define <4 x i8> @neg_bitextract_vec_non_splat_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitextract <4 x i8>, <4 x b32> [[X]], <4 x i32> <i32 0, i32 8, i32 16, i32 25>
+; CHECK-NEXT: ret <4 x i8> [[R]]
+;
+ %r = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> <i32 0, i32 8, i32 16, i32 25>
+ ret <4 x i8> %r
+}
+
define <vscale x 4 x i8> @bitextract_scalable_vec_out_of_range(<vscale x 4 x b32> %x) {
; CHECK-LABEL: define <vscale x 4 x i8> @bitextract_scalable_vec_out_of_range(
; CHECK-SAME: <vscale x 4 x b32> [[X:%.*]]) {
@@ -303,3 +334,112 @@ define <vscale x 4 x i8> @bitextract_scalable_vec_out_of_range(<vscale x 4 x b32
%r = bitextract <vscale x 4 x i8>, <vscale x 4 x b32> %x, <vscale x 4 x i32> splat (i32 25)
ret <vscale x 4 x i8> %r
}
+
+define <4 x b32> @bitinsert_vec_out_of_range(<4 x b32> %x, <4 x i8> %y) {
+; CHECK-LABEL: define <4 x b32> @bitinsert_vec_out_of_range(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]]) {
+; CHECK-NEXT: ret <4 x b32> poison
+;
+ %r = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> splat (i32 25)
+ ret <4 x b32> %r
+}
+
+; The last bits of each element are in range.
+define <4 x b32> @neg_bitinsert_vec_in_range(<4 x b32> %x, <4 x i8> %y) {
+; CHECK-LABEL: define <4 x b32> @neg_bitinsert_vec_in_range(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitinsert <4 x b32> [[X]], <4 x i8> [[Y]], <4 x i32> splat (i32 24)
+; CHECK-NEXT: ret <4 x b32> [[R]]
+;
+ %r = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> splat (i32 24)
+ ret <4 x b32> %r
+}
+
+; Only the last lane is out of range.
+define <4 x b32> @neg_bitinsert_vec_non_splat_offset(<4 x b32> %x, <4 x i8> %y) {
+; CHECK-LABEL: define <4 x b32> @neg_bitinsert_vec_non_splat_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitinsert <4 x b32> [[X]], <4 x i8> [[Y]], <4 x i32> <i32 0, i32 8, i32 16, i32 25>
+; CHECK-NEXT: ret <4 x b32> [[R]]
+;
+ %r = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> <i32 0, i32 8, i32 16, i32 25>
+ ret <4 x b32> %r
+}
+
+define <4 x i8> @bitextract_vec_poison_offset(<4 x b32> %x) {
+; CHECK-LABEL: define <4 x i8> @bitextract_vec_poison_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]]) {
+; CHECK-NEXT: ret <4 x i8> poison
+;
+ %r = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> poison
+ ret <4 x i8> %r
+}
+
+define <4 x b32> @bitinsert_vec_poison_offset(<4 x b32> %x, <4 x i8> %y) {
+; CHECK-LABEL: define <4 x b32> @bitinsert_vec_poison_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]]) {
+; CHECK-NEXT: ret <4 x b32> poison
+;
+ %r = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> poison
+ ret <4 x b32> %r
+}
+
+; Only the last lane is poison.
+define <4 x i8> @neg_bitextract_vec_partial_poison_offset(<4 x b32> %x) {
+; CHECK-LABEL: define <4 x i8> @neg_bitextract_vec_partial_poison_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitextract <4 x i8>, <4 x b32> [[X]], <4 x i32> <i32 0, i32 8, i32 16, i32 poison>
+; CHECK-NEXT: ret <4 x i8> [[R]]
+;
+ %r = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> <i32 0, i32 8, i32 16, i32 poison>
+ ret <4 x i8> %r
+}
+
+; Only the last lane is poison.
+define <4 x b32> @neg_bitinsert_vec_partial_poison_offset(<4 x b32> %x, <4 x i8> %y) {
+; CHECK-LABEL: define <4 x b32> @neg_bitinsert_vec_partial_poison_offset(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]]) {
+; CHECK-NEXT: [[R:%.*]] = bitinsert <4 x b32> [[X]], <4 x i8> [[Y]], <4 x i32> <i32 0, i32 8, i32 16, i32 poison>
+; CHECK-NEXT: ret <4 x b32> [[R]]
+;
+ %r = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> <i32 0, i32 8, i32 16, i32 poison>
+ ret <4 x b32> %r
+}
+
+define <4 x b32> @bitextract_vec_full_width(<4 x b32> %x, <4 x i32> %n) {
+; CHECK-LABEL: define <4 x b32> @bitextract_vec_full_width(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i32> [[N:%.*]]) {
+; CHECK-NEXT: ret <4 x b32> [[X]]
+;
+ %r = bitextract <4 x b32>, <4 x b32> %x, <4 x i32> %n
+ ret <4 x b32> %r
+}
+
+define <4 x b32> @bitinsert_vec_full_width(<4 x b32> %x, <4 x b32> %y, <4 x i32> %n) {
+; CHECK-LABEL: define <4 x b32> @bitinsert_vec_full_width(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x b32> [[Y:%.*]], <4 x i32> [[N:%.*]]) {
+; CHECK-NEXT: ret <4 x b32> [[Y]]
+;
+ %r = bitinsert <4 x b32> %x, <4 x b32> %y, <4 x i32> %n
+ ret <4 x b32> %r
+}
+
+define <4 x i8> @bitextract_bitinsert_vec(<4 x b32> %x, <4 x i8> %y, <4 x i32> %n) {
+; CHECK-LABEL: define <4 x i8> @bitextract_bitinsert_vec(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i8> [[Y:%.*]], <4 x i32> [[N:%.*]]) {
+; CHECK-NEXT: ret <4 x i8> [[Y]]
+;
+ %i = bitinsert <4 x b32> %x, <4 x i8> %y, <4 x i32> %n
+ %r = bitextract <4 x i8>, <4 x b32> %i, <4 x i32> %n
+ ret <4 x i8> %r
+}
+
+define <4 x b32> @bitinsert_bitextract_vec(<4 x b32> %x, <4 x i32> %n) {
+; CHECK-LABEL: define <4 x b32> @bitinsert_bitextract_vec(
+; CHECK-SAME: <4 x b32> [[X:%.*]], <4 x i32> [[N:%.*]]) {
+; CHECK-NEXT: ret <4 x b32> [[X]]
+;
+ %e = bitextract <4 x i8>, <4 x b32> %x, <4 x i32> %n
+ %r = bitinsert <4 x b32> %x, <4 x i8> %e, <4 x i32> %n
+ ret <4 x b32> %r
+}
More information about the llvm-branch-commits
mailing list