| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6 | |
| ; RUN: opt < %s -passes=instsimplify -S | FileCheck %s | |
| ; RUN: opt < %s -passes=instsimplify -use-constant-int-for-fixed-length-splat -use-constant-int-for-scalable-splat -S | FileCheck %s | |
| @g = global i32 0 | |
| define i8 @bitextract_i8_offset_0() { | |
| ; CHECK-LABEL: define i8 @bitextract_i8_offset_0() { | |
| ; CHECK-NEXT: ret i8 120 | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 0 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_i8_offset_8() { | |
| ; CHECK-LABEL: define i8 @bitextract_i8_offset_8() { | |
| ; CHECK-NEXT: ret i8 86 | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 8 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_i8_top_bits() { | |
| ; CHECK-LABEL: define i8 @bitextract_i8_top_bits() { | |
| ; CHECK-NEXT: ret i8 18 | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 24 | |
| ret i8 %r | |
| } | |
| define i1 @bitextract_i1() { | |
| ; CHECK-LABEL: define i1 @bitextract_i1() { | |
| ; CHECK-NEXT: ret i1 true | |
| ; | |
| %r = bitextract i1, b32 32, i32 5 | |
| ret i1 %r | |
| } | |
| define b16 @bitextract_b16() { | |
| ; CHECK-LABEL: define b16 @bitextract_b16() { | |
| ; CHECK-NEXT: ret b16 4660 | |
| ; | |
| %r = bitextract b16, b32 305419896, i32 16 | |
| ret b16 %r | |
| } | |
| define float @bitextract_float() { | |
| ; CHECK-LABEL: define float @bitextract_float() { | |
| ; CHECK-NEXT: ret float 1.000000e+00 | |
| ; | |
| %r = bitextract float, b64 4575657221408423936, i32 32 | |
| ret float %r | |
| } | |
| define i8 @bitextract_out_of_range() { | |
| ; CHECK-LABEL: define i8 @bitextract_out_of_range() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 25 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_offset_width() { | |
| ; CHECK-LABEL: define i8 @bitextract_offset_width() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 32 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_large_offset() { | |
| ; CHECK-LABEL: define i8 @bitextract_large_offset() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 -1 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_poison_src() { | |
| ; CHECK-LABEL: define i8 @bitextract_poison_src() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 poison, i32 8 | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_poison_offset() { | |
| ; CHECK-LABEL: define i8 @bitextract_poison_offset() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 poison | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_undef_offset() { | |
| ; CHECK-LABEL: define i8 @bitextract_undef_offset() { | |
| ; CHECK-NEXT: ret i8 poison | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 undef | |
| ret i8 %r | |
| } | |
| define i8 @bitextract_undef_src() { | |
| ; CHECK-LABEL: define i8 @bitextract_undef_src() { | |
| ; CHECK-NEXT: ret i8 undef | |
| ; | |
| %r = bitextract i8, b32 undef, i32 8 | |
| ret i8 %r | |
| } | |
| define ptr @bitextract_poison_src_ptr() { | |
| ; CHECK-LABEL: define ptr @bitextract_poison_src_ptr() { | |
| ; CHECK-NEXT: ret ptr poison | |
| ; | |
| %r = bitextract ptr, b64 poison, i32 0 | |
| ret ptr %r | |
| } | |
| ; An integer can't be bitcast to a pointer. | |
| define ptr @neg_bitextract_ptr() { | |
| ; CHECK-LABEL: define ptr @neg_bitextract_ptr() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitextract ptr, b64 1234605616436508552, i32 0 | |
| ; CHECK-NEXT: ret ptr [[R]] | |
| ; | |
| %r = bitextract ptr, b64 1234605616436508552, i32 0 | |
| ret ptr %r | |
| } | |
| ; The source bits are unknown. | |
| define i32 @neg_bitextract_constexpr_src() { | |
| ; CHECK-LABEL: define i32 @neg_bitextract_constexpr_src() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitextract i32, b64 bitcast (ptr @g to b64), i32 0 | |
| ; CHECK-NEXT: ret i32 [[R]] | |
| ; | |
| %r = bitextract i32, b64 bitcast (ptr @g to b64), i32 0 | |
| ret i32 %r | |
| } | |
| define ppc_fp128 @bitextract_ppc_fp128() { | |
| ; CHECK-LABEL: define ppc_fp128 @bitextract_ppc_fp128() { | |
| ; CHECK-NEXT: ret ppc_fp128 bitcast (i128 84987514980498058623787163916674531328 to ppc_fp128) | |
| ; | |
| %r = bitextract ppc_fp128, b128 84987514980498058623787163916674531328, i32 0 | |
| ret ppc_fp128 %r | |
| } | |
| ; The offset is unknown. | |
| define i8 @neg_bitextract_constexpr_offset() { | |
| ; CHECK-LABEL: define i8 @neg_bitextract_constexpr_offset() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitextract i8, b32 305419896, i32 ptrtoint (ptr @g to i32) | |
| ; CHECK-NEXT: ret i8 [[R]] | |
| ; | |
| %r = bitextract i8, b32 305419896, i32 ptrtoint (ptr @g to i32) | |
| ret i8 %r | |
| } | |
| define b32 @bitinsert_i8() { | |
| ; CHECK-LABEL: define b32 @bitinsert_i8() { | |
| ; CHECK-NEXT: ret b32 305441656 | |
| ; | |
| %r = bitinsert b32 305419896, i8 -85, i32 8 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_i1() { | |
| ; CHECK-LABEL: define b32 @bitinsert_i1() { | |
| ; CHECK-NEXT: ret b32 305420024 | |
| ; | |
| %r = bitinsert b32 305419896, i1 true, i32 7 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_b8_top_bits() { | |
| ; CHECK-LABEL: define b32 @bitinsert_b8_top_bits() { | |
| ; CHECK-NEXT: ret b32 -1422633352 | |
| ; | |
| %r = bitinsert b32 305419896, b8 -85, i32 24 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_half() { | |
| ; CHECK-LABEL: define b32 @bitinsert_half() { | |
| ; CHECK-NEXT: ret b32 1006655096 | |
| ; | |
| %r = bitinsert b32 305419896, half 1.0, i32 16 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_out_of_range() { | |
| ; CHECK-LABEL: define b32 @bitinsert_out_of_range() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 305419896, i8 -85, i32 25 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_large_offset() { | |
| ; CHECK-LABEL: define b32 @bitinsert_large_offset() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 305419896, i8 -85, i32 -1 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_poison_offset() { | |
| ; CHECK-LABEL: define b32 @bitinsert_poison_offset() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 305419896, i8 -85, i32 poison | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_undef_offset() { | |
| ; CHECK-LABEL: define b32 @bitinsert_undef_offset() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 305419896, i8 -85, i32 undef | |
| ret b32 %r | |
| } | |
| define b64 @bitinsert_full_width_i64() { | |
| ; CHECK-LABEL: define b64 @bitinsert_full_width_i64() { | |
| ; CHECK-NEXT: ret b64 1234605616436508552 | |
| ; | |
| %r = bitinsert b64 bitcast (ptr @g to b64), i64 1234605616436508552, i32 0 | |
| ret b64 %r | |
| } | |
| define b64 @bitinsert_full_width_ptr() { | |
| ; CHECK-LABEL: define b64 @bitinsert_full_width_ptr() { | |
| ; CHECK-NEXT: ret b64 bitcast (ptr @g to b64) | |
| ; | |
| %r = bitinsert b64 0, ptr @g, i32 0 | |
| ret b64 %r | |
| } | |
| define b32 @bitinsert_full_width_float() { | |
| ; CHECK-LABEL: define b32 @bitinsert_full_width_float() { | |
| ; CHECK-NEXT: ret b32 1065353216 | |
| ; | |
| %r = bitinsert b32 305419896, float 1.0, i32 0 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_full_width_poison() { | |
| ; CHECK-LABEL: define b32 @bitinsert_full_width_poison() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 305419896, i32 poison, i32 0 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_full_width_undef() { | |
| ; CHECK-LABEL: define b32 @bitinsert_full_width_undef() { | |
| ; CHECK-NEXT: ret b32 undef | |
| ; | |
| %r = bitinsert b32 305419896, i32 undef, i32 0 | |
| ret b32 %r | |
| } | |
| define b128 @bitinsert_full_width_ppc_fp128() { | |
| ; CHECK-LABEL: define b128 @bitinsert_full_width_ppc_fp128() { | |
| ; CHECK-NEXT: ret b128 bitcast (ppc_fp128 1.000000e+00 to b128) | |
| ; | |
| %r = bitinsert b128 0, ppc_fp128 0xM3FF00000000000000000000000000000, i32 0 | |
| ret b128 %r | |
| } | |
| define b32 @bitinsert_full_width_constexpr_val() { | |
| ; CHECK-LABEL: define b32 @bitinsert_full_width_constexpr_val() { | |
| ; CHECK-NEXT: ret b32 bitcast (i32 ptrtoint (ptr @g to i32) to b32) | |
| ; | |
| %r = bitinsert b32 305419896, i32 ptrtoint (ptr @g to i32), i32 0 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_poison_poison() { | |
| ; CHECK-LABEL: define b32 @bitinsert_poison_poison() { | |
| ; CHECK-NEXT: ret b32 poison | |
| ; | |
| %r = bitinsert b32 poison, i8 poison, i32 8 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_undef_undef() { | |
| ; CHECK-LABEL: define b32 @bitinsert_undef_undef() { | |
| ; CHECK-NEXT: ret b32 undef | |
| ; | |
| %r = bitinsert b32 undef, i8 undef, i32 8 | |
| ret b32 %r | |
| } | |
| ; The result would have both poison and non-poison bits. | |
| define b32 @neg_bitinsert_poison_val() { | |
| ; CHECK-LABEL: define b32 @neg_bitinsert_poison_val() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b32 305419896, i8 poison, i32 8 | |
| ; CHECK-NEXT: ret b32 [[R]] | |
| ; | |
| %r = bitinsert b32 305419896, i8 poison, i32 8 | |
| ret b32 %r | |
| } | |
| ; The result would have both undef and defined bits. | |
| define b32 @neg_bitinsert_undef_val() { | |
| ; CHECK-LABEL: define b32 @neg_bitinsert_undef_val() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b32 305419896, i8 undef, i32 8 | |
| ; CHECK-NEXT: ret b32 [[R]] | |
| ; | |
| %r = bitinsert b32 305419896, i8 undef, i32 8 | |
| ret b32 %r | |
| } | |
| ; The result would have both poison and non-poison bits. | |
| define b32 @neg_bitinsert_poison_base() { | |
| ; CHECK-LABEL: define b32 @neg_bitinsert_poison_base() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b32 poison, b8 -85, i32 8 | |
| ; CHECK-NEXT: ret b32 [[R]] | |
| ; | |
| %r = bitinsert b32 poison, b8 -85, i32 8 | |
| ret b32 %r | |
| } | |
| define b32 @bitinsert_undef_base_poison_val() { | |
| ; CHECK-LABEL: define b32 @bitinsert_undef_base_poison_val() { | |
| ; CHECK-NEXT: ret b32 undef | |
| ; | |
| %r = bitinsert b32 undef, i8 poison, i32 8 | |
| ret b32 %r | |
| } | |
| ; The value bits are unknown. | |
| define b128 @neg_bitinsert_ptr() { | |
| ; CHECK-LABEL: define b128 @neg_bitinsert_ptr() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b128 0, ptr null, i32 0 | |
| ; CHECK-NEXT: ret b128 [[R]] | |
| ; | |
| %r = bitinsert b128 0, ptr null, i32 0 | |
| ret b128 %r | |
| } | |
| ; The base bits are unknown. | |
| define b64 @neg_bitinsert_constexpr_base() { | |
| ; CHECK-LABEL: define b64 @neg_bitinsert_constexpr_base() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b64 bitcast (ptr @g to b64), i8 -85, i32 8 | |
| ; CHECK-NEXT: ret b64 [[R]] | |
| ; | |
| %r = bitinsert b64 bitcast (ptr @g to b64), i8 -85, i32 8 | |
| ret b64 %r | |
| } | |
| ; The value bits are unknown. | |
| define b64 @neg_bitinsert_constexpr_val() { | |
| ; CHECK-LABEL: define b64 @neg_bitinsert_constexpr_val() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b64 0, i32 ptrtoint (ptr @g to i32), i32 8 | |
| ; CHECK-NEXT: ret b64 [[R]] | |
| ; | |
| %r = bitinsert b64 0, i32 ptrtoint (ptr @g to i32), i32 8 | |
| ret b64 %r | |
| } | |
| ; The value bits are unknown. | |
| define b128 @neg_bitinsert_constexpr_byte_val() { | |
| ; CHECK-LABEL: define b128 @neg_bitinsert_constexpr_byte_val() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b128 0, b64 bitcast (ptr @g to b64), i32 0 | |
| ; CHECK-NEXT: ret b128 [[R]] | |
| ; | |
| %r = bitinsert b128 0, b64 bitcast (ptr @g to b64), i32 0 | |
| ret b128 %r | |
| } | |
| ; The bits of a ppc_fp128 depend on endianness. | |
| define b256 @neg_bitinsert_ppc_fp128() { | |
| ; CHECK-LABEL: define b256 @neg_bitinsert_ppc_fp128() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert b256 0, ppc_fp128 1.000000e+00, i32 0 | |
| ; CHECK-NEXT: ret b256 [[R]] | |
| ; | |
| %r = bitinsert b256 0, ppc_fp128 0xM3FF00000000000000000000000000000, i32 0 | |
| 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 | |
| } | |
| define <vscale x 4 x i8> @bitextract_scalable_vec_splat() { | |
| ; CHECK-LABEL: define <vscale x 4 x i8> @bitextract_scalable_vec_splat() { | |
| ; CHECK-NEXT: ret <vscale x 4 x i8> splat (i8 52) | |
| ; | |
| %r = bitextract <vscale x 4 x i8>, <vscale x 4 x b32> splat (b32 305419896), <vscale x 4 x i32> splat (i32 16) | |
| ret <vscale x 4 x i8> %r | |
| } | |
| define <2 x i8> @bitextract_vec() { | |
| ; CHECK-LABEL: define <2 x i8> @bitextract_vec() { | |
| ; CHECK-NEXT: ret <2 x i8> <i8 120, i8 86> | |
| ; | |
| %r = bitextract <2 x i8>, <2 x b32> <b32 305419896, b32 305419896>, <2 x i32> <i32 0, i32 8> | |
| ret <2 x i8> %r | |
| } | |
| define <2 x b32> @bitinsert_vec() { | |
| ; CHECK-LABEL: define <2 x b32> @bitinsert_vec() { | |
| ; CHECK-NEXT: ret <2 x b32> <b32 1, b32 512> | |
| ; | |
| %r = bitinsert <2 x b32> <b32 0, b32 0>, <2 x i8> <i8 1, i8 2>, <2 x i32> <i32 0, i32 8> | |
| ret <2 x b32> %r | |
| } | |
| define <2 x i8> @bitextract_vec_splat() { | |
| ; CHECK-LABEL: define <2 x i8> @bitextract_vec_splat() { | |
| ; CHECK-NEXT: ret <2 x i8> splat (i8 86) | |
| ; | |
| %r = bitextract <2 x i8>, <2 x b32> splat (b32 305419896), <2 x i32> splat (i32 8) | |
| ret <2 x i8> %r | |
| } | |
| define <2 x b32> @bitinsert_vec_splat() { | |
| ; CHECK-LABEL: define <2 x b32> @bitinsert_vec_splat() { | |
| ; CHECK-NEXT: ret <2 x b32> splat (b32 305398136) | |
| ; | |
| %r = bitinsert <2 x b32> splat (b32 305419896), <2 x i8> splat (i8 1), <2 x i32> splat (i32 8) | |
| ret <2 x b32> %r | |
| } | |
| define <vscale x 4 x b32> @bitinsert_scalable_vec_splat() { | |
| ; CHECK-LABEL: define <vscale x 4 x b32> @bitinsert_scalable_vec_splat() { | |
| ; CHECK-NEXT: ret <vscale x 4 x b32> splat (b32 256) | |
| ; | |
| %r = bitinsert <vscale x 4 x b32> splat (b32 0), <vscale x 4 x i8> splat (i8 1), <vscale x 4 x i32> splat (i32 8) | |
| ret <vscale x 4 x b32> %r | |
| } | |
| ; Only the lanes with an out-of-range or poison offset are poison. | |
| define <3 x i8> @bitextract_vec_poison_lanes() { | |
| ; CHECK-LABEL: define <3 x i8> @bitextract_vec_poison_lanes() { | |
| ; CHECK-NEXT: ret <3 x i8> <i8 86, i8 poison, i8 poison> | |
| ; | |
| %r = bitextract <3 x i8>, <3 x b32> splat (b32 305419896), <3 x i32> <i32 8, i32 32, i32 poison> | |
| ret <3 x i8> %r | |
| } | |
| define <3 x b32> @bitinsert_vec_poison_lanes() { | |
| ; CHECK-LABEL: define <3 x b32> @bitinsert_vec_poison_lanes() { | |
| ; CHECK-NEXT: ret <3 x b32> <b32 305397880, b32 poison, b32 poison> | |
| ; | |
| %r = bitinsert <3 x b32> splat (b32 305419896), <3 x i8> zeroinitializer, <3 x i32> <i32 8, i32 32, i32 poison> | |
| ret <3 x b32> %r | |
| } | |
| define <2 x i8> @bitextract_vec_poison_src_lane() { | |
| ; CHECK-LABEL: define <2 x i8> @bitextract_vec_poison_src_lane() { | |
| ; CHECK-NEXT: ret <2 x i8> <i8 86, i8 poison> | |
| ; | |
| %r = bitextract <2 x i8>, <2 x b32> <b32 305419896, b32 poison>, <2 x i32> splat (i32 8) | |
| ret <2 x i8> %r | |
| } | |
| define <2 x b32> @bitinsert_vec_poison_poison_lane() { | |
| ; CHECK-LABEL: define <2 x b32> @bitinsert_vec_poison_poison_lane() { | |
| ; CHECK-NEXT: ret <2 x b32> <b32 256, b32 poison> | |
| ; | |
| %r = bitinsert <2 x b32> <b32 0, b32 poison>, <2 x i8> <i8 1, i8 poison>, <2 x i32> splat (i32 8) | |
| ret <2 x b32> %r | |
| } | |
| define <2 x float> @bitextract_vec_fp() { | |
| ; CHECK-LABEL: define <2 x float> @bitextract_vec_fp() { | |
| ; CHECK-NEXT: ret <2 x float> splat (float 1.000000e+00) | |
| ; | |
| %r = bitextract <2 x float>, <2 x b64> <b64 4575657221408423936, b64 1065353216>, <2 x i32> <i32 32, i32 0> | |
| ret <2 x float> %r | |
| } | |
| define <2 x b64> @bitinsert_vec_full_width() { | |
| ; CHECK-LABEL: define <2 x b64> @bitinsert_vec_full_width() { | |
| ; CHECK-NEXT: ret <2 x b64> <b64 4607182418800017408, b64 4611686018427387904> | |
| ; | |
| %r = bitinsert <2 x b64> zeroinitializer, <2 x double> <double 1.0, double 2.0>, <2 x i32> zeroinitializer | |
| ret <2 x b64> %r | |
| } | |
| ; A lane that cannot be folded prevents folding the vector. | |
| define <2 x i8> @neg_bitextract_vec_constexpr_lane() { | |
| ; CHECK-LABEL: define <2 x i8> @neg_bitextract_vec_constexpr_lane() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitextract <2 x i8>, <2 x b32> splat (b32 305419896), <2 x i32> <i32 8, i32 ptrtoint (ptr @g to i32)> | |
| ; CHECK-NEXT: ret <2 x i8> [[R]] | |
| ; | |
| %r = bitextract <2 x i8>, <2 x b32> splat (b32 305419896), <2 x i32> <i32 8, i32 ptrtoint (ptr @g to i32)> | |
| ret <2 x i8> %r | |
| } | |
| ; A lane that cannot be folded prevents folding the vector. | |
| define <2 x b64> @neg_bitinsert_vec_constexpr_lane() { | |
| ; CHECK-LABEL: define <2 x b64> @neg_bitinsert_vec_constexpr_lane() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitinsert <2 x b64> zeroinitializer, <2 x i32> <i32 1, i32 ptrtoint (ptr @g to i32)>, <2 x i32> zeroinitializer | |
| ; CHECK-NEXT: ret <2 x b64> [[R]] | |
| ; | |
| %r = bitinsert <2 x b64> zeroinitializer, <2 x i32> <i32 1, i32 ptrtoint (ptr @g to i32)>, <2 x i32> zeroinitializer | |
| ret <2 x b64> %r | |
| } | |
| ; A splat that cannot be folded prevents folding the scalable vector. | |
| define <vscale x 2 x ptr> @neg_bitextract_scalable_vec_ptr() { | |
| ; CHECK-LABEL: define <vscale x 2 x ptr> @neg_bitextract_scalable_vec_ptr() { | |
| ; CHECK-NEXT: [[R:%.*]] = bitextract <vscale x 2 x ptr>, <vscale x 2 x b64> splat (b64 1), <vscale x 2 x i32> zeroinitializer | |
| ; CHECK-NEXT: ret <vscale x 2 x ptr> [[R]] | |
| ; | |
| %r = bitextract <vscale x 2 x ptr>, <vscale x 2 x b64> splat (b64 1), <vscale x 2 x i32> zeroinitializer | |
| ret <vscale x 2 x ptr> %r | |
| } | |
| define i8 @bitextract_vec_bitcast_src() { | |
| ; CHECK-LABEL: define i8 @bitextract_vec_bitcast_src() { | |
| ; CHECK-NEXT: ret i8 2 | |
| ; | |
| %b = bitcast <2 x i32> <i32 1, i32 2> to b64 | |
| %r = bitextract i8, b64 %b, i32 32 | |
| ret i8 %r | |
| } | |
| define b64 @bitinsert_vec_bitcast_base() { | |
| ; CHECK-LABEL: define b64 @bitinsert_vec_bitcast_base() { | |
| ; CHECK-NEXT: ret b64 8589934599 | |
| ; | |
| %b = bitcast <2 x i32> <i32 1, i32 2> to b64 | |
| %r = bitinsert b64 %b, i8 7, i32 0 | |
| ret b64 %r | |
| } |