1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -instcombine -S | FileCheck %s 3target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 4 5define i32 @test2(float %f) { 6; CHECK-LABEL: @test2( 7; CHECK-NEXT: [[T5:%.*]] = fmul float [[F:%.*]], [[F]] 8; CHECK-NEXT: [[T21:%.*]] = bitcast float [[T5]] to i32 9; CHECK-NEXT: ret i32 [[T21]] 10; 11 %t5 = fmul float %f, %f 12 %t9 = insertelement <4 x float> undef, float %t5, i32 0 13 %t10 = insertelement <4 x float> %t9, float 0.000000e+00, i32 1 14 %t11 = insertelement <4 x float> %t10, float 0.000000e+00, i32 2 15 %t12 = insertelement <4 x float> %t11, float 0.000000e+00, i32 3 16 %t19 = bitcast <4 x float> %t12 to <4 x i32> 17 %t21 = extractelement <4 x i32> %t19, i32 0 18 ret i32 %t21 19} 20 21define void @get_image() nounwind { 22; CHECK-LABEL: @get_image( 23; CHECK-NEXT: entry: 24; CHECK-NEXT: [[TMP0:%.*]] = call i32 @fgetc(i8* null) [[ATTR0:#.*]] 25; CHECK-NEXT: br i1 false, label [[BB2:%.*]], label [[BB3:%.*]] 26; CHECK: bb2: 27; CHECK-NEXT: br label [[BB3]] 28; CHECK: bb3: 29; CHECK-NEXT: unreachable 30; 31entry: 32 %0 = call i32 @fgetc(i8* null) nounwind 33 %1 = trunc i32 %0 to i8 34 %t2 = insertelement <100 x i8> zeroinitializer, i8 %1, i32 1 35 %t1 = extractelement <100 x i8> %t2, i32 0 36 %2 = icmp eq i8 %t1, 80 37 br i1 %2, label %bb2, label %bb3 38 39bb2: ; preds = %entry 40 br label %bb3 41 42bb3: ; preds = %bb2, %entry 43 unreachable 44} 45 46; PR4340 47define void @vac(<4 x float>* nocapture %a) nounwind { 48; CHECK-LABEL: @vac( 49; CHECK-NEXT: entry: 50; CHECK-NEXT: store <4 x float> zeroinitializer, <4 x float>* [[A:%.*]], align 16 51; CHECK-NEXT: ret void 52; 53entry: 54 %t1 = load <4 x float>, <4 x float>* %a ; <<4 x float>> [#uses=1] 55 %vecins = insertelement <4 x float> %t1, float 0.000000e+00, i32 0 ; <<4 x float>> [#uses=1] 56 %vecins4 = insertelement <4 x float> %vecins, float 0.000000e+00, i32 1; <<4 x float>> [#uses=1] 57 %vecins6 = insertelement <4 x float> %vecins4, float 0.000000e+00, i32 2; <<4 x float>> [#uses=1] 58 %vecins8 = insertelement <4 x float> %vecins6, float 0.000000e+00, i32 3; <<4 x float>> [#uses=1] 59 store <4 x float> %vecins8, <4 x float>* %a 60 ret void 61} 62 63declare i32 @fgetc(i8*) 64 65define <4 x float> @dead_shuffle_elt(<4 x float> %x, <2 x float> %y) nounwind { 66; CHECK-LABEL: @dead_shuffle_elt( 67; CHECK-NEXT: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> [[Y:%.*]], <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 68; CHECK-NEXT: [[SHUFFLE9_I:%.*]] = shufflevector <4 x float> [[SHUFFLE_I]], <4 x float> [[X:%.*]], <4 x i32> <i32 0, i32 1, i32 6, i32 7> 69; CHECK-NEXT: ret <4 x float> [[SHUFFLE9_I]] 70; 71 %shuffle.i = shufflevector <2 x float> %y, <2 x float> %y, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 72 %shuffle9.i = shufflevector <4 x float> %x, <4 x float> %shuffle.i, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 73 ret <4 x float> %shuffle9.i 74} 75 76define <2 x float> @test_fptrunc(double %f) { 77; CHECK-LABEL: @test_fptrunc( 78; CHECK-NEXT: [[TMP1:%.*]] = insertelement <2 x double> <double undef, double 0.000000e+00>, double [[F:%.*]], i32 0 79; CHECK-NEXT: [[TMP2:%.*]] = fptrunc <2 x double> [[TMP1]] to <2 x float> 80; CHECK-NEXT: ret <2 x float> [[TMP2]] 81; 82 %t9 = insertelement <4 x double> undef, double %f, i32 0 83 %t10 = insertelement <4 x double> %t9, double 0.000000e+00, i32 1 84 %t11 = insertelement <4 x double> %t10, double 0.000000e+00, i32 2 85 %t12 = insertelement <4 x double> %t11, double 0.000000e+00, i32 3 86 %t5 = fptrunc <4 x double> %t12 to <4 x float> 87 %ret = shufflevector <4 x float> %t5, <4 x float> undef, <2 x i32> <i32 0, i32 1> 88 ret <2 x float> %ret 89} 90 91define <2 x double> @test_fpext(float %f) { 92; CHECK-LABEL: @test_fpext( 93; CHECK-NEXT: [[TMP1:%.*]] = insertelement <2 x float> <float undef, float 0.000000e+00>, float [[F:%.*]], i32 0 94; CHECK-NEXT: [[TMP2:%.*]] = fpext <2 x float> [[TMP1]] to <2 x double> 95; CHECK-NEXT: ret <2 x double> [[TMP2]] 96; 97 %t9 = insertelement <4 x float> undef, float %f, i32 0 98 %t10 = insertelement <4 x float> %t9, float 0.000000e+00, i32 1 99 %t11 = insertelement <4 x float> %t10, float 0.000000e+00, i32 2 100 %t12 = insertelement <4 x float> %t11, float 0.000000e+00, i32 3 101 %t5 = fpext <4 x float> %t12 to <4 x double> 102 %ret = shufflevector <4 x double> %t5, <4 x double> undef, <2 x i32> <i32 0, i32 1> 103 ret <2 x double> %ret 104} 105 106define <4 x double> @test_shuffle(<4 x double> %f) { 107; CHECK-LABEL: @test_shuffle( 108; CHECK-NEXT: [[RET1:%.*]] = insertelement <4 x double> [[F:%.*]], double 1.000000e+00, i32 3 109; CHECK-NEXT: ret <4 x double> [[RET1]] 110; 111 %ret = shufflevector <4 x double> %f, <4 x double> <double undef, double 1.0, double undef, double undef>, <4 x i32> <i32 0, i32 1, i32 2, i32 5> 112 ret <4 x double> %ret 113} 114 115define <4 x float> @test_select(float %f, float %g) { 116; CHECK-LABEL: @test_select( 117; CHECK-NEXT: [[A3:%.*]] = insertelement <4 x float> <float undef, float undef, float undef, float 3.000000e+00>, float [[F:%.*]], i32 0 118; CHECK-NEXT: [[RET:%.*]] = shufflevector <4 x float> [[A3]], <4 x float> <float undef, float 4.000000e+00, float 5.000000e+00, float undef>, <4 x i32> <i32 0, i32 5, i32 6, i32 3> 119; CHECK-NEXT: ret <4 x float> [[RET]] 120; 121 %a0 = insertelement <4 x float> undef, float %f, i32 0 122 %a1 = insertelement <4 x float> %a0, float 1.000000e+00, i32 1 123 %a2 = insertelement <4 x float> %a1, float 2.000000e+00, i32 2 124 %a3 = insertelement <4 x float> %a2, float 3.000000e+00, i32 3 125 %b0 = insertelement <4 x float> undef, float %g, i32 0 126 %b1 = insertelement <4 x float> %b0, float 4.000000e+00, i32 1 127 %b2 = insertelement <4 x float> %b1, float 5.000000e+00, i32 2 128 %b3 = insertelement <4 x float> %b2, float 6.000000e+00, i32 3 129 %ret = select <4 x i1> <i1 true, i1 false, i1 false, i1 true>, <4 x float> %a3, <4 x float> %b3 130 ret <4 x float> %ret 131} 132 133; Check that instcombine doesn't wrongly fold away the select completely. 134 135define <2 x i64> @PR24922(<2 x i64> %v) { 136; CHECK-LABEL: @PR24922( 137; CHECK-NEXT: [[RESULT1:%.*]] = insertelement <2 x i64> [[V:%.*]], i64 0, i32 0 138; CHECK-NEXT: ret <2 x i64> [[RESULT1]] 139; 140 %result = select <2 x i1> <i1 icmp eq (i64 extractelement (<2 x i64> bitcast (<4 x i32> <i32 15, i32 15, i32 15, i32 15> to <2 x i64>), i64 0), i64 0), i1 true>, <2 x i64> %v, <2 x i64> zeroinitializer 141 ret <2 x i64> %result 142} 143 144; The shuffle only demands the 0th (undef) element of 'out123', so everything should fold away. 145 146define <4 x float> @inselt_shuf_no_demand(float %a1, float %a2, float %a3) { 147; CHECK-LABEL: @inselt_shuf_no_demand( 148; CHECK-NEXT: ret <4 x float> undef 149; 150 %out1 = insertelement <4 x float> undef, float %a1, i32 1 151 %out12 = insertelement <4 x float> %out1, float %a2, i32 2 152 %out123 = insertelement <4 x float> %out12, float %a3, i32 3 153 %shuffle = shufflevector <4 x float> %out123, <4 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef> 154 ret <4 x float> %shuffle 155} 156 157; The shuffle only demands the 0th (undef) element of 'out123', so everything should fold away. 158 159define <4 x float> @inselt_shuf_no_demand_commute(float %a1, float %a2, float %a3) { 160; CHECK-LABEL: @inselt_shuf_no_demand_commute( 161; CHECK-NEXT: ret <4 x float> undef 162; 163 %out1 = insertelement <4 x float> undef, float %a1, i32 1 164 %out12 = insertelement <4 x float> %out1, float %a2, i32 2 165 %out123 = insertelement <4 x float> %out12, float %a3, i32 3 166 %shuffle = shufflevector <4 x float> undef, <4 x float> %out123, <4 x i32> <i32 4, i32 undef, i32 undef, i32 undef> 167 ret <4 x float> %shuffle 168} 169 170; The add uses 'out012' giving it multiple uses after the shuffle is transformed to also 171; use 'out012'. The analysis should be able to see past that. 172 173define <4 x i32> @inselt_shuf_no_demand_multiuse(i32 %a0, i32 %a1, <4 x i32> %b) { 174; CHECK-LABEL: @inselt_shuf_no_demand_multiuse( 175; CHECK-NEXT: [[OUT0:%.*]] = insertelement <4 x i32> undef, i32 [[A0:%.*]], i32 0 176; CHECK-NEXT: [[OUT01:%.*]] = insertelement <4 x i32> [[OUT0]], i32 [[A1:%.*]], i32 1 177; CHECK-NEXT: [[FOO:%.*]] = add <4 x i32> [[OUT01]], [[B:%.*]] 178; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <4 x i32> [[FOO]], <4 x i32> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 179; CHECK-NEXT: ret <4 x i32> [[SHUFFLE]] 180; 181 %out0 = insertelement <4 x i32> undef, i32 %a0, i32 0 182 %out01 = insertelement <4 x i32> %out0, i32 %a1, i32 1 183 %out012 = insertelement <4 x i32> %out01, i32 %a0, i32 2 184 %foo = add <4 x i32> %out012, %b 185 %out0123 = insertelement <4 x i32> %foo, i32 %a1, i32 3 186 %shuffle = shufflevector <4 x i32> %out0123, <4 x i32> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 187 ret <4 x i32> %shuffle 188} 189 190define <4 x float> @inselt_shuf_no_demand_bogus_insert_index_in_chain(float %a1, float %a2, float %a3, i32 %variable_index) { 191; CHECK-LABEL: @inselt_shuf_no_demand_bogus_insert_index_in_chain( 192; CHECK-NEXT: [[OUT12:%.*]] = insertelement <4 x float> undef, float [[A2:%.*]], i32 [[VARIABLE_INDEX:%.*]] 193; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <4 x float> [[OUT12]], <4 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef> 194; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] 195; 196 %out1 = insertelement <4 x float> undef, float %a1, i32 1 197 %out12 = insertelement <4 x float> %out1, float %a2, i32 %variable_index ; something unexpected 198 %out123 = insertelement <4 x float> %out12, float %a3, i32 3 199 %shuffle = shufflevector <4 x float> %out123, <4 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef> 200 ret <4 x float> %shuffle 201} 202 203; Test undef replacement in constant vector elements with binops. 204 205define <3 x i8> @shuf_add(<3 x i8> %x) { 206; CHECK-LABEL: @shuf_add( 207; CHECK-NEXT: [[BO:%.*]] = add <3 x i8> [[X:%.*]], <i8 undef, i8 2, i8 3> 208; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 2> 209; CHECK-NEXT: ret <3 x i8> [[R]] 210; 211 %bo = add nsw <3 x i8> %x, <i8 1, i8 2, i8 3> 212 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 2> 213 ret <3 x i8> %r 214} 215 216define <3 x i8> @shuf_sub(<3 x i8> %x) { 217; CHECK-LABEL: @shuf_sub( 218; CHECK-NEXT: [[BO:%.*]] = sub <3 x i8> <i8 1, i8 undef, i8 3>, [[X:%.*]] 219; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 2> 220; CHECK-NEXT: ret <3 x i8> [[R]] 221; 222 %bo = sub nuw <3 x i8> <i8 1, i8 2, i8 3>, %x 223 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 2> 224 ret <3 x i8> %r 225} 226 227define <3 x i8> @shuf_mul(<3 x i8> %x) { 228; CHECK-LABEL: @shuf_mul( 229; CHECK-NEXT: [[BO:%.*]] = mul <3 x i8> [[X:%.*]], <i8 1, i8 undef, i8 3> 230; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 0, i32 2, i32 0> 231; CHECK-NEXT: ret <3 x i8> [[R]] 232; 233 %bo = mul nsw <3 x i8> %x, <i8 1, i8 2, i8 3> 234 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 0, i32 2, i32 0> 235 ret <3 x i8> %r 236} 237 238define <3 x i8> @shuf_and(<3 x i8> %x) { 239; CHECK-LABEL: @shuf_and( 240; CHECK-NEXT: [[BO:%.*]] = and <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 undef> 241; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 1, i32 1, i32 0> 242; CHECK-NEXT: ret <3 x i8> [[R]] 243; 244 %bo = and <3 x i8> %x, <i8 1, i8 2, i8 3> 245 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 1, i32 1, i32 0> 246 ret <3 x i8> %r 247} 248 249define <3 x i8> @shuf_or(<3 x i8> %x) { 250; CHECK-LABEL: @shuf_or( 251; CHECK-NEXT: [[BO:%.*]] = or <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 undef> 252; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 0> 253; CHECK-NEXT: ret <3 x i8> [[R]] 254; 255 %bo = or <3 x i8> %x, <i8 1, i8 2, i8 3> 256 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 0> 257 ret <3 x i8> %r 258} 259 260define <3 x i8> @shuf_xor(<3 x i8> %x) { 261; CHECK-LABEL: @shuf_xor( 262; CHECK-NEXT: [[BO:%.*]] = xor <3 x i8> [[X:%.*]], <i8 1, i8 undef, i8 3> 263; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 264; CHECK-NEXT: ret <3 x i8> [[R]] 265; 266 %bo = xor <3 x i8> %x, <i8 1, i8 2, i8 3> 267 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 268 ret <3 x i8> %r 269} 270 271define <3 x i8> @shuf_lshr_const_op0(<3 x i8> %x) { 272; CHECK-LABEL: @shuf_lshr_const_op0( 273; CHECK-NEXT: [[BO:%.*]] = lshr <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 274; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 275; CHECK-NEXT: ret <3 x i8> [[R]] 276; 277 %bo = lshr <3 x i8> <i8 1, i8 2, i8 3>, %x 278 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 279 ret <3 x i8> %r 280} 281 282define <3 x i8> @shuf_lshr_const_op1(<3 x i8> %x) { 283; CHECK-LABEL: @shuf_lshr_const_op1( 284; CHECK-NEXT: [[BO:%.*]] = lshr exact <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 285; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 286; CHECK-NEXT: ret <3 x i8> [[R]] 287; 288 %bo = lshr exact <3 x i8> %x, <i8 1, i8 2, i8 3> 289 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 290 ret <3 x i8> %r 291} 292 293define <3 x i8> @shuf_ashr_const_op0(<3 x i8> %x) { 294; CHECK-LABEL: @shuf_ashr_const_op0( 295; CHECK-NEXT: [[BO:%.*]] = lshr <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 296; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 297; CHECK-NEXT: ret <3 x i8> [[R]] 298; 299 %bo = ashr <3 x i8> <i8 1, i8 2, i8 3>, %x 300 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 301 ret <3 x i8> %r 302} 303 304define <3 x i8> @shuf_ashr_const_op1(<3 x i8> %x) { 305; CHECK-LABEL: @shuf_ashr_const_op1( 306; CHECK-NEXT: [[BO:%.*]] = ashr exact <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 307; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 308; CHECK-NEXT: ret <3 x i8> [[R]] 309; 310 %bo = ashr exact <3 x i8> %x, <i8 1, i8 2, i8 3> 311 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 312 ret <3 x i8> %r 313} 314 315define <3 x i8> @shuf_shl_const_op0(<3 x i8> %x) { 316; CHECK-LABEL: @shuf_shl_const_op0( 317; CHECK-NEXT: [[BO:%.*]] = shl nsw <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 318; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 319; CHECK-NEXT: ret <3 x i8> [[R]] 320; 321 %bo = shl nsw <3 x i8> <i8 1, i8 2, i8 3>, %x 322 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 323 ret <3 x i8> %r 324} 325 326define <3 x i8> @shuf_shl_const_op1(<3 x i8> %x) { 327; CHECK-LABEL: @shuf_shl_const_op1( 328; CHECK-NEXT: [[BO:%.*]] = shl nuw <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 329; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 330; CHECK-NEXT: ret <3 x i8> [[R]] 331; 332 %bo = shl nuw <3 x i8> %x, <i8 1, i8 2, i8 3> 333 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 334 ret <3 x i8> %r 335} 336 337define <3 x i8> @shuf_sdiv_const_op0(<3 x i8> %x) { 338; CHECK-LABEL: @shuf_sdiv_const_op0( 339; CHECK-NEXT: [[BO:%.*]] = sdiv exact <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 340; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 341; CHECK-NEXT: ret <3 x i8> [[R]] 342; 343 %bo = sdiv exact <3 x i8> <i8 1, i8 2, i8 3>, %x 344 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 1> 345 ret <3 x i8> %r 346} 347 348define <3 x i8> @shuf_sdiv_const_op1(<3 x i8> %x) { 349; CHECK-LABEL: @shuf_sdiv_const_op1( 350; CHECK-NEXT: [[BO:%.*]] = sdiv <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 351; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 0> 352; CHECK-NEXT: ret <3 x i8> [[R]] 353; 354 %bo = sdiv <3 x i8> %x, <i8 1, i8 2, i8 3> 355 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 0> 356 ret <3 x i8> %r 357} 358 359define <3 x i8> @shuf_srem_const_op0(<3 x i8> %x) { 360; CHECK-LABEL: @shuf_srem_const_op0( 361; CHECK-NEXT: [[BO:%.*]] = srem <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 362; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 2> 363; CHECK-NEXT: ret <3 x i8> [[R]] 364; 365 %bo = srem <3 x i8> <i8 1, i8 2, i8 3>, %x 366 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 1, i32 undef, i32 2> 367 ret <3 x i8> %r 368} 369 370define <3 x i8> @shuf_srem_const_op1(<3 x i8> %x) { 371; CHECK-LABEL: @shuf_srem_const_op1( 372; CHECK-NEXT: [[BO:%.*]] = srem <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 373; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 1> 374; CHECK-NEXT: ret <3 x i8> [[R]] 375; 376 %bo = srem <3 x i8> %x, <i8 1, i8 2, i8 3> 377 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 1> 378 ret <3 x i8> %r 379} 380 381define <3 x i8> @shuf_udiv_const_op0(<3 x i8> %x) { 382; CHECK-LABEL: @shuf_udiv_const_op0( 383; CHECK-NEXT: [[BO:%.*]] = udiv exact <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 384; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 385; CHECK-NEXT: ret <3 x i8> [[R]] 386; 387 %bo = udiv exact <3 x i8> <i8 1, i8 2, i8 3>, %x 388 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 389 ret <3 x i8> %r 390} 391 392define <3 x i8> @shuf_udiv_const_op1(<3 x i8> %x) { 393; CHECK-LABEL: @shuf_udiv_const_op1( 394; CHECK-NEXT: [[BO:%.*]] = udiv <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 395; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 396; CHECK-NEXT: ret <3 x i8> [[R]] 397; 398 %bo = udiv <3 x i8> %x, <i8 1, i8 2, i8 3> 399 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 undef, i32 0> 400 ret <3 x i8> %r 401} 402 403define <3 x i8> @shuf_urem_const_op0(<3 x i8> %x) { 404; CHECK-LABEL: @shuf_urem_const_op0( 405; CHECK-NEXT: [[BO:%.*]] = urem <3 x i8> <i8 1, i8 2, i8 3>, [[X:%.*]] 406; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 407; CHECK-NEXT: ret <3 x i8> [[R]] 408; 409 %bo = urem <3 x i8> <i8 1, i8 2, i8 3>, %x 410 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 2, i32 1, i32 undef> 411 ret <3 x i8> %r 412} 413 414define <3 x i8> @shuf_urem_const_op1(<3 x i8> %x) { 415; CHECK-LABEL: @shuf_urem_const_op1( 416; CHECK-NEXT: [[BO:%.*]] = urem <3 x i8> [[X:%.*]], <i8 1, i8 2, i8 3> 417; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x i8> [[BO]], <3 x i8> undef, <3 x i32> <i32 undef, i32 1, i32 0> 418; CHECK-NEXT: ret <3 x i8> [[R]] 419; 420 %bo = urem <3 x i8> %x, <i8 1, i8 2, i8 3> 421 %r = shufflevector <3 x i8> %bo, <3 x i8> undef, <3 x i32> <i32 undef, i32 1, i32 0> 422 ret <3 x i8> %r 423} 424 425define <3 x float> @shuf_fadd(<3 x float> %x) { 426; CHECK-LABEL: @shuf_fadd( 427; CHECK-NEXT: [[BO:%.*]] = fadd <3 x float> [[X:%.*]], <float 1.000000e+00, float 2.000000e+00, float undef> 428; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 429; CHECK-NEXT: ret <3 x float> [[R]] 430; 431 %bo = fadd <3 x float> %x, <float 1.0, float 2.0, float 3.0> 432 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 433 ret <3 x float> %r 434} 435 436define <3 x float> @shuf_fsub(<3 x float> %x) { 437; CHECK-LABEL: @shuf_fsub( 438; CHECK-NEXT: [[BO:%.*]] = fsub fast <3 x float> <float 1.000000e+00, float undef, float 3.000000e+00>, [[X:%.*]] 439; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 0, i32 2> 440; CHECK-NEXT: ret <3 x float> [[R]] 441; 442 %bo = fsub fast <3 x float> <float 1.0, float 2.0, float 3.0>, %x 443 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 0, i32 2> 444 ret <3 x float> %r 445} 446 447define <3 x float> @shuf_fmul(<3 x float> %x) { 448; CHECK-LABEL: @shuf_fmul( 449; CHECK-NEXT: [[BO:%.*]] = fmul reassoc <3 x float> [[X:%.*]], <float 1.000000e+00, float 2.000000e+00, float undef> 450; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 451; CHECK-NEXT: ret <3 x float> [[R]] 452; 453 %bo = fmul reassoc <3 x float> %x, <float 1.0, float 2.0, float 3.0> 454 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 455 ret <3 x float> %r 456} 457 458define <3 x float> @shuf_fdiv_const_op0(<3 x float> %x) { 459; CHECK-LABEL: @shuf_fdiv_const_op0( 460; CHECK-NEXT: [[BO:%.*]] = fdiv reassoc ninf <3 x float> <float 1.000000e+00, float undef, float 3.000000e+00>, [[X:%.*]] 461; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 0, i32 2> 462; CHECK-NEXT: ret <3 x float> [[R]] 463; 464 %bo = fdiv ninf reassoc <3 x float> <float 1.0, float 2.0, float 3.0>, %x 465 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 0, i32 2> 466 ret <3 x float> %r 467} 468 469define <3 x float> @shuf_fdiv_const_op1(<3 x float> %x) { 470; CHECK-LABEL: @shuf_fdiv_const_op1( 471; CHECK-NEXT: [[BO:%.*]] = fdiv nnan ninf <3 x float> [[X:%.*]], <float 1.000000e+00, float 2.000000e+00, float undef> 472; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 473; CHECK-NEXT: ret <3 x float> [[R]] 474; 475 %bo = fdiv ninf nnan <3 x float> %x, <float 1.0, float 2.0, float 3.0> 476 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 1, i32 0> 477 ret <3 x float> %r 478} 479 480define <3 x float> @shuf_frem_const_op0(<3 x float> %x) { 481; CHECK-LABEL: @shuf_frem_const_op0( 482; CHECK-NEXT: [[BO:%.*]] = frem nnan <3 x float> <float 1.000000e+00, float undef, float 3.000000e+00>, [[X:%.*]] 483; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 undef, i32 2, i32 0> 484; CHECK-NEXT: ret <3 x float> [[R]] 485; 486 %bo = frem nnan <3 x float> <float 1.0, float 2.0, float 3.0>, %x 487 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 undef, i32 2, i32 0> 488 ret <3 x float> %r 489} 490 491define <3 x float> @shuf_frem_const_op1(<3 x float> %x) { 492; CHECK-LABEL: @shuf_frem_const_op1( 493; CHECK-NEXT: [[BO:%.*]] = frem reassoc ninf <3 x float> [[X:%.*]], <float undef, float 2.000000e+00, float 3.000000e+00> 494; CHECK-NEXT: [[R:%.*]] = shufflevector <3 x float> [[BO]], <3 x float> undef, <3 x i32> <i32 1, i32 undef, i32 2> 495; CHECK-NEXT: ret <3 x float> [[R]] 496; 497 %bo = frem ninf reassoc <3 x float> %x, <float 1.0, float 2.0, float 3.0> 498 %r = shufflevector <3 x float> %bo, <3 x float> undef, <3 x i32> <i32 1, i32 undef, i32 2> 499 ret <3 x float> %r 500} 501 502;; TODO: getelementptr tests below show missing simplifications for 503;; vector demanded elements on vector geps. 504 505define i32* @gep_vbase_w_s_idx(<2 x i32*> %base) { 506; CHECK-LABEL: @gep_vbase_w_s_idx( 507; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> [[BASE:%.*]], i64 1 508; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 509; CHECK-NEXT: ret i32* [[EE]] 510; 511 %gep = getelementptr i32, <2 x i32*> %base, i64 1 512 %ee = extractelement <2 x i32*> %gep, i32 1 513 ret i32* %ee 514} 515 516define i32* @gep_splat_base_w_s_idx(i32* %base) { 517; CHECK-LABEL: @gep_splat_base_w_s_idx( 518; CHECK-NEXT: [[BASEVEC2:%.*]] = insertelement <2 x i32*> undef, i32* [[BASE:%.*]], i32 1 519; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> [[BASEVEC2]], i64 1 520; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 521; CHECK-NEXT: ret i32* [[EE]] 522; 523 %basevec1 = insertelement <2 x i32*> undef, i32* %base, i32 0 524 %basevec2 = shufflevector <2 x i32*> %basevec1, <2 x i32*> undef, <2 x i32> zeroinitializer 525 %gep = getelementptr i32, <2 x i32*> %basevec2, i64 1 526 %ee = extractelement <2 x i32*> %gep, i32 1 527 ret i32* %ee 528} 529 530 531define i32* @gep_splat_base_w_cv_idx(i32* %base) { 532; CHECK-LABEL: @gep_splat_base_w_cv_idx( 533; CHECK-NEXT: [[BASEVEC2:%.*]] = insertelement <2 x i32*> undef, i32* [[BASE:%.*]], i32 1 534; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> [[BASEVEC2]], <2 x i64> <i64 undef, i64 1> 535; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 536; CHECK-NEXT: ret i32* [[EE]] 537; 538 %basevec1 = insertelement <2 x i32*> undef, i32* %base, i32 0 539 %basevec2 = shufflevector <2 x i32*> %basevec1, <2 x i32*> undef, <2 x i32> zeroinitializer 540 %gep = getelementptr i32, <2 x i32*> %basevec2, <2 x i64> <i64 0, i64 1> 541 %ee = extractelement <2 x i32*> %gep, i32 1 542 ret i32* %ee 543} 544 545define i32* @gep_splat_base_w_vidx(i32* %base, <2 x i64> %idxvec) { 546; CHECK-LABEL: @gep_splat_base_w_vidx( 547; CHECK-NEXT: [[BASEVEC2:%.*]] = insertelement <2 x i32*> undef, i32* [[BASE:%.*]], i32 1 548; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> [[BASEVEC2]], <2 x i64> [[IDXVEC:%.*]] 549; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 550; CHECK-NEXT: ret i32* [[EE]] 551; 552 %basevec1 = insertelement <2 x i32*> undef, i32* %base, i32 0 553 %basevec2 = shufflevector <2 x i32*> %basevec1, <2 x i32*> undef, <2 x i32> zeroinitializer 554 %gep = getelementptr i32, <2 x i32*> %basevec2, <2 x i64> %idxvec 555 %ee = extractelement <2 x i32*> %gep, i32 1 556 ret i32* %ee 557} 558 559 560@GLOBAL = internal global i32 zeroinitializer 561 562define i32* @gep_cvbase_w_s_idx(<2 x i32*> %base, i64 %raw_addr) { 563; CHECK-LABEL: @gep_cvbase_w_s_idx( 564; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> <i32* undef, i32* @GLOBAL>, i64 [[RAW_ADDR:%.*]] 565; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 566; CHECK-NEXT: ret i32* [[EE]] 567; 568 %gep = getelementptr i32, <2 x i32*> <i32* @GLOBAL, i32* @GLOBAL>, i64 %raw_addr 569 %ee = extractelement <2 x i32*> %gep, i32 1 570 ret i32* %ee 571} 572 573define i32* @gep_cvbase_w_cv_idx(<2 x i32*> %base, i64 %raw_addr) { 574; CHECK-LABEL: @gep_cvbase_w_cv_idx( 575; CHECK-NEXT: ret i32* getelementptr inbounds (i32, i32* @GLOBAL, i64 1) 576; 577 %gep = getelementptr i32, <2 x i32*> <i32* @GLOBAL, i32* @GLOBAL>, <2 x i64> <i64 0, i64 1> 578 %ee = extractelement <2 x i32*> %gep, i32 1 579 ret i32* %ee 580} 581 582 583define i32* @gep_sbase_w_cv_idx(i32* %base) { 584; CHECK-LABEL: @gep_sbase_w_cv_idx( 585; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, i32* [[BASE:%.*]], <2 x i64> <i64 undef, i64 1> 586; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 587; CHECK-NEXT: ret i32* [[EE]] 588; 589 %gep = getelementptr i32, i32* %base, <2 x i64> <i64 0, i64 1> 590 %ee = extractelement <2 x i32*> %gep, i32 1 591 ret i32* %ee 592} 593 594define i32* @gep_sbase_w_splat_idx(i32* %base, i64 %idx) { 595; CHECK-LABEL: @gep_sbase_w_splat_idx( 596; CHECK-NEXT: [[IDXVEC2:%.*]] = insertelement <2 x i64> undef, i64 [[IDX:%.*]], i32 1 597; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, i32* [[BASE:%.*]], <2 x i64> [[IDXVEC2]] 598; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 599; CHECK-NEXT: ret i32* [[EE]] 600; 601 %idxvec1 = insertelement <2 x i64> undef, i64 %idx, i32 0 602 %idxvec2 = shufflevector <2 x i64> %idxvec1, <2 x i64> undef, <2 x i32> zeroinitializer 603 %gep = getelementptr i32, i32* %base, <2 x i64> %idxvec2 604 %ee = extractelement <2 x i32*> %gep, i32 1 605 ret i32* %ee 606} 607define i32* @gep_splat_both(i32* %base, i64 %idx) { 608; CHECK-LABEL: @gep_splat_both( 609; CHECK-NEXT: [[BASEVEC2:%.*]] = insertelement <2 x i32*> undef, i32* [[BASE:%.*]], i32 1 610; CHECK-NEXT: [[IDXVEC2:%.*]] = insertelement <2 x i64> undef, i64 [[IDX:%.*]], i32 1 611; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, <2 x i32*> [[BASEVEC2]], <2 x i64> [[IDXVEC2]] 612; CHECK-NEXT: [[EE:%.*]] = extractelement <2 x i32*> [[GEP]], i32 1 613; CHECK-NEXT: ret i32* [[EE]] 614; 615 %basevec1 = insertelement <2 x i32*> undef, i32* %base, i32 0 616 %basevec2 = shufflevector <2 x i32*> %basevec1, <2 x i32*> undef, <2 x i32> zeroinitializer 617 %idxvec1 = insertelement <2 x i64> undef, i64 %idx, i32 0 618 %idxvec2 = shufflevector <2 x i64> %idxvec1, <2 x i64> undef, <2 x i32> zeroinitializer 619 %gep = getelementptr i32, <2 x i32*> %basevec2, <2 x i64> %idxvec2 620 %ee = extractelement <2 x i32*> %gep, i32 1 621 ret i32* %ee 622} 623 624define <2 x i32*> @gep_all_lanes_undef(i32* %base, i64 %idx) {; 625; CHECK-LABEL: @gep_all_lanes_undef( 626; CHECK-NEXT: ret <2 x i32*> undef 627; 628 %basevec = insertelement <2 x i32*> undef, i32* %base, i32 0 629 %idxvec = insertelement <2 x i64> undef, i64 %idx, i32 1 630 %gep = getelementptr i32, <2 x i32*> %basevec, <2 x i64> %idxvec 631 ret <2 x i32*> %gep 632} 633 634define i32* @gep_demanded_lane_undef(i32* %base, i64 %idx) { 635; CHECK-LABEL: @gep_demanded_lane_undef( 636; CHECK-NEXT: ret i32* undef 637; 638 %basevec = insertelement <2 x i32*> undef, i32* %base, i32 0 639 %idxvec = insertelement <2 x i64> undef, i64 %idx, i32 1 640 %gep = getelementptr i32, <2 x i32*> %basevec, <2 x i64> %idxvec 641 %ee = extractelement <2 x i32*> %gep, i32 1 642 ret i32* %ee 643} 644 645 646;; LangRef has an odd quirk around FCAs which make it illegal to use undef 647;; indices. 648define i32* @PR41624(<2 x { i32, i32 }*> %a) { 649; CHECK-LABEL: @PR41624( 650; CHECK-NEXT: [[W:%.*]] = getelementptr { i32, i32 }, <2 x { i32, i32 }*> [[A:%.*]], <2 x i64> <i64 5, i64 5>, <2 x i32> zeroinitializer 651; CHECK-NEXT: [[R:%.*]] = extractelement <2 x i32*> [[W]], i32 0 652; CHECK-NEXT: ret i32* [[R]] 653; 654 %w = getelementptr { i32, i32 }, <2 x { i32, i32 }*> %a, <2 x i64> <i64 5, i64 5>, <2 x i32> zeroinitializer 655 %r = extractelement <2 x i32*> %w, i32 0 656 ret i32* %r 657} 658 659@global = external global [0 x i32], align 4 660 661; Make sure we don't get stuck in a loop turning the zeroinitializer into 662; <0, undef, undef, undef> and then changing it back. 663define i32* @zero_sized_type_extract(<4 x i64> %arg, i64 %arg1) { 664; CHECK-LABEL: @zero_sized_type_extract( 665; CHECK-NEXT: bb: 666; CHECK-NEXT: [[T:%.*]] = getelementptr inbounds [0 x i32], <4 x [0 x i32]*> <[0 x i32]* @global, [0 x i32]* undef, [0 x i32]* undef, [0 x i32]* undef>, <4 x i64> <i64 0, i64 undef, i64 undef, i64 undef>, <4 x i64> [[ARG:%.*]] 667; CHECK-NEXT: [[T2:%.*]] = extractelement <4 x i32*> [[T]], i64 0 668; CHECK-NEXT: ret i32* [[T2]] 669; 670bb: 671 %t = getelementptr inbounds [0 x i32], <4 x [0 x i32]*> <[0 x i32]* @global, [0 x i32]* @global, [0 x i32]* @global, [0 x i32]* @global>, <4 x i64> zeroinitializer, <4 x i64> %arg 672 %t2 = extractelement <4 x i32*> %t, i64 0 673 ret i32* %t2 674} 675 676; The non-zero elements of the result are always 'y', so the splat is unnecessary. 677 678define <4 x i8> @select_cond_with_eq_true_false_elts(<4 x i8> %x, <4 x i8> %y, <4 x i1> %cmp) { 679; CHECK-LABEL: @select_cond_with_eq_true_false_elts( 680; CHECK-NEXT: [[SEL:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x i8> [[X:%.*]], <4 x i8> [[Y:%.*]] 681; CHECK-NEXT: [[R:%.*]] = shufflevector <4 x i8> [[SEL]], <4 x i8> [[Y]], <4 x i32> <i32 0, i32 5, i32 6, i32 7> 682; CHECK-NEXT: ret <4 x i8> [[R]] 683; 684 %tval = shufflevector <4 x i8> %x, <4 x i8> %y, <4 x i32> <i32 0, i32 5, i32 6, i32 7> 685 %splat = shufflevector <4 x i1> %cmp, <4 x i1> undef, <4 x i32> zeroinitializer 686 %r = select <4 x i1> %splat, <4 x i8> %tval, <4 x i8> %y 687 ret <4 x i8> %r 688} 689 690; First element of the result is always x[0], so first element of select condition is unnecessary. 691 692define <4 x i8> @select_cond_with_eq_true_false_elts2(<4 x i8> %x, <4 x i8> %y, <4 x i1> %cmp) { 693; CHECK-LABEL: @select_cond_with_eq_true_false_elts2( 694; CHECK-NEXT: [[COND:%.*]] = shufflevector <4 x i1> [[CMP:%.*]], <4 x i1> undef, <4 x i32> <i32 undef, i32 1, i32 0, i32 1> 695; CHECK-NEXT: [[SEL:%.*]] = select <4 x i1> [[COND]], <4 x i8> [[Y:%.*]], <4 x i8> [[X:%.*]] 696; CHECK-NEXT: [[R:%.*]] = shufflevector <4 x i8> [[X]], <4 x i8> [[SEL]], <4 x i32> <i32 0, i32 5, i32 6, i32 7> 697; CHECK-NEXT: ret <4 x i8> [[R]] 698; 699 %tval = shufflevector <4 x i8> %x, <4 x i8> %y, <4 x i32> <i32 0, i32 5, i32 6, i32 7> 700 %cond = shufflevector <4 x i1> %cmp, <4 x i1> undef, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 701 %r = select <4 x i1> %cond, <4 x i8> %tval, <4 x i8> %x 702 ret <4 x i8> %r 703} 704 705; Second element of the result is always x[3], so second element of select condition is unnecessary. 706; Fourth element of the result is always undef, so fourth element of select condition is unnecessary. 707 708define <4 x float> @select_cond_with_eq_true_false_elts3(<4 x float> %x, <4 x float> %y, <4 x i1> %cmp) { 709; CHECK-LABEL: @select_cond_with_eq_true_false_elts3( 710; CHECK-NEXT: [[TVAL:%.*]] = shufflevector <4 x float> [[X:%.*]], <4 x float> [[Y:%.*]], <4 x i32> <i32 1, i32 3, i32 5, i32 undef> 711; CHECK-NEXT: [[FVAL:%.*]] = shufflevector <4 x float> [[Y]], <4 x float> [[X]], <4 x i32> <i32 0, i32 7, i32 6, i32 undef> 712; CHECK-NEXT: [[COND:%.*]] = shufflevector <4 x i1> [[CMP:%.*]], <4 x i1> undef, <4 x i32> <i32 undef, i32 1, i32 2, i32 3> 713; CHECK-NEXT: [[R:%.*]] = select <4 x i1> [[COND]], <4 x float> [[TVAL]], <4 x float> [[FVAL]] 714; CHECK-NEXT: ret <4 x float> [[R]] 715; 716 %tval = shufflevector <4 x float> %x, <4 x float> %y, <4 x i32> <i32 1, i32 3, i32 5, i32 undef> 717 %fval = shufflevector <4 x float> %y, <4 x float> %x, <4 x i32> <i32 0, i32 7, i32 6, i32 undef> 718 %cond = shufflevector <4 x i1> %cmp, <4 x i1> undef, <4 x i32> <i32 undef, i32 1, i32 2, i32 3> 719 %r = select <4 x i1> %cond, <4 x float> %tval, <4 x float> %fval 720 ret <4 x float> %r 721} 722 723define <4 x i8> @select_cond_with_undef_true_false_elts(<4 x i8> %x, <4 x i8> %y, <4 x i1> %cmp) { 724; CHECK-LABEL: @select_cond_with_undef_true_false_elts( 725; CHECK-NEXT: [[TVAL:%.*]] = shufflevector <4 x i8> [[Y:%.*]], <4 x i8> undef, <4 x i32> <i32 undef, i32 1, i32 2, i32 3> 726; CHECK-NEXT: [[COND:%.*]] = shufflevector <4 x i1> [[CMP:%.*]], <4 x i1> undef, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 727; CHECK-NEXT: [[R:%.*]] = select <4 x i1> [[COND]], <4 x i8> [[TVAL]], <4 x i8> [[X:%.*]] 728; CHECK-NEXT: ret <4 x i8> [[R]] 729; 730 %tval = shufflevector <4 x i8> %x, <4 x i8> %y, <4 x i32> <i32 undef, i32 5, i32 6, i32 7> 731 %cond = shufflevector <4 x i1> %cmp, <4 x i1> undef, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 732 %r = select <4 x i1> %cond, <4 x i8> %tval, <4 x i8> %x 733 ret <4 x i8> %r 734} 735 736; The insert can be safely eliminated because the shuffle blocks poison from cmp[0]. 737 738define <4 x i8> @select_cond_(<4 x i8> %x, <4 x i8> %min, <4 x i1> %cmp, i1 %poison_blocker) { 739; CHECK-LABEL: @select_cond_( 740; CHECK-NEXT: [[SEL:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x i8> [[MIN:%.*]], <4 x i8> [[X:%.*]] 741; CHECK-NEXT: [[R:%.*]] = shufflevector <4 x i8> [[X]], <4 x i8> [[SEL]], <4 x i32> <i32 0, i32 5, i32 6, i32 7> 742; CHECK-NEXT: ret <4 x i8> [[R]] 743; 744 %ins = insertelement <4 x i1> %cmp, i1 %poison_blocker, i32 0 745 %vecins = shufflevector <4 x i8> %x, <4 x i8> %min, <4 x i32> <i32 0, i32 5, i32 6, i32 7> 746 %r = select <4 x i1> %ins, <4 x i8> %vecins, <4 x i8> %x 747 ret <4 x i8> %r 748} 749 750define <4 x float> @ins_of_ext(<4 x float> %x, float %y) { 751; CHECK-LABEL: @ins_of_ext( 752; CHECK-NEXT: [[I1:%.*]] = insertelement <4 x float> [[X:%.*]], float [[Y:%.*]], i32 1 753; CHECK-NEXT: [[I2:%.*]] = insertelement <4 x float> [[I1]], float [[Y]], i32 2 754; CHECK-NEXT: [[I3:%.*]] = insertelement <4 x float> [[I2]], float [[Y]], i32 3 755; CHECK-NEXT: ret <4 x float> [[I3]] 756; 757 %e0 = extractelement <4 x float> %x, i32 0 758 %i0 = insertelement <4 x float> undef, float %e0, i32 0 759 %i1 = insertelement <4 x float> %i0, float %y, i32 1 760 %i2 = insertelement <4 x float> %i1, float %y, i32 2 761 %i3 = insertelement <4 x float> %i2, float %y, i32 3 762 ret <4 x float> %i3 763} 764 765define <4 x float> @ins_of_ext_twice(<4 x float> %x, float %y) { 766; CHECK-LABEL: @ins_of_ext_twice( 767; CHECK-NEXT: [[I2:%.*]] = insertelement <4 x float> [[X:%.*]], float [[Y:%.*]], i32 2 768; CHECK-NEXT: [[I3:%.*]] = insertelement <4 x float> [[I2]], float [[Y]], i32 3 769; CHECK-NEXT: ret <4 x float> [[I3]] 770; 771 %e0 = extractelement <4 x float> %x, i32 0 772 %i0 = insertelement <4 x float> undef, float %e0, i32 0 773 %e1 = extractelement <4 x float> %x, i32 1 774 %i1 = insertelement <4 x float> %i0, float %e1, i32 1 775 %i2 = insertelement <4 x float> %i1, float %y, i32 2 776 %i3 = insertelement <4 x float> %i2, float %y, i32 3 777 ret <4 x float> %i3 778} 779 780; Negative test - element 3 of the result must be undef to be poison safe. 781; TODO: Could convert insert/extract to identity shuffle with undef mask elements. 782 783define <4 x float> @ins_of_ext_wrong_demand(<4 x float> %x, float %y) { 784; CHECK-LABEL: @ins_of_ext_wrong_demand( 785; CHECK-NEXT: [[E0:%.*]] = extractelement <4 x float> [[X:%.*]], i32 0 786; CHECK-NEXT: [[I0:%.*]] = insertelement <4 x float> undef, float [[E0]], i32 0 787; CHECK-NEXT: [[I1:%.*]] = insertelement <4 x float> [[I0]], float [[Y:%.*]], i32 1 788; CHECK-NEXT: [[I2:%.*]] = insertelement <4 x float> [[I1]], float [[Y]], i32 2 789; CHECK-NEXT: ret <4 x float> [[I2]] 790; 791 %e0 = extractelement <4 x float> %x, i32 0 792 %i0 = insertelement <4 x float> undef, float %e0, i32 0 793 %i1 = insertelement <4 x float> %i0, float %y, i32 1 794 %i2 = insertelement <4 x float> %i1, float %y, i32 2 795 ret <4 x float> %i2 796} 797 798; Negative test - can't replace i0 with x. 799; TODO: Could convert insert/extract to identity shuffle with undef mask elements. 800 801define <4 x float> @ins_of_ext_wrong_type(<5 x float> %x, float %y) { 802; CHECK-LABEL: @ins_of_ext_wrong_type( 803; CHECK-NEXT: [[E0:%.*]] = extractelement <5 x float> [[X:%.*]], i32 0 804; CHECK-NEXT: [[I0:%.*]] = insertelement <4 x float> undef, float [[E0]], i32 0 805; CHECK-NEXT: [[I1:%.*]] = insertelement <4 x float> [[I0]], float [[Y:%.*]], i32 1 806; CHECK-NEXT: [[I2:%.*]] = insertelement <4 x float> [[I1]], float [[Y]], i32 2 807; CHECK-NEXT: [[I3:%.*]] = insertelement <4 x float> [[I2]], float [[Y]], i32 3 808; CHECK-NEXT: ret <4 x float> [[I3]] 809; 810 %e0 = extractelement <5 x float> %x, i32 0 811 %i0 = insertelement <4 x float> undef, float %e0, i32 0 812 %i1 = insertelement <4 x float> %i0, float %y, i32 1 813 %i2 = insertelement <4 x float> %i1, float %y, i32 2 814 %i3 = insertelement <4 x float> %i2, float %y, i32 3 815 ret <4 x float> %i3 816} 817 818; This should reduce, but the shuffle mask must remain as-is (no extra undef). 819 820define <4 x i4> @ins_of_ext_undef_elts_propagation(<4 x i4> %v, <4 x i4> %v2, i4 %x) { 821; CHECK-LABEL: @ins_of_ext_undef_elts_propagation( 822; CHECK-NEXT: [[T2:%.*]] = insertelement <4 x i4> [[V:%.*]], i4 [[X:%.*]], i32 2 823; CHECK-NEXT: [[R:%.*]] = shufflevector <4 x i4> [[T2]], <4 x i4> [[V2:%.*]], <4 x i32> <i32 0, i32 6, i32 2, i32 7> 824; CHECK-NEXT: ret <4 x i4> [[R]] 825; 826 %v0 = extractelement <4 x i4> %v, i32 0 827 %t0 = insertelement <4 x i4> undef, i4 %v0, i32 0 828 %t2 = insertelement <4 x i4> %t0, i4 %x, i32 2 829 %r = shufflevector <4 x i4> %t2, <4 x i4> %v2, <4 x i32> <i32 0, i32 6, i32 2, i32 7> 830 ret <4 x i4> %r 831} 832 833; Similar to above, but more ops/uses to verify things work in more complicated cases. 834 835define <8 x i4> @ins_of_ext_undef_elts_propagation2(<8 x i4> %v, <8 x i4> %v2, i4 %x) { 836; CHECK-LABEL: @ins_of_ext_undef_elts_propagation2( 837; CHECK-NEXT: [[I19:%.*]] = insertelement <8 x i4> [[V:%.*]], i4 [[X:%.*]], i32 2 838; CHECK-NEXT: [[I20:%.*]] = shufflevector <8 x i4> [[I19]], <8 x i4> [[V2:%.*]], <8 x i32> <i32 0, i32 1, i32 2, i32 11, i32 10, i32 9, i32 8, i32 undef> 839; CHECK-NEXT: [[I21:%.*]] = shufflevector <8 x i4> [[I20]], <8 x i4> [[V]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 15> 840; CHECK-NEXT: ret <8 x i4> [[I21]] 841; 842 %i15 = extractelement <8 x i4> %v, i32 0 843 %i16 = insertelement <8 x i4> undef, i4 %i15, i32 0 844 %i17 = extractelement <8 x i4> %v, i32 1 845 %i18 = insertelement <8 x i4> %i16, i4 %i17, i32 1 846 %i19 = insertelement <8 x i4> %i18, i4 %x, i32 2 847 %i20 = shufflevector <8 x i4> %i19, <8 x i4> %v2, <8 x i32> <i32 0, i32 1, i32 2, i32 11, i32 10, i32 9, i32 8, i32 undef> 848 %i21 = shufflevector <8 x i4> %i20, <8 x i4> %v, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 15> 849 ret <8 x i4> %i21 850} 851