llvm/test/Transforms/InstCombine/bitcast-inseltpoison.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3
   4 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
   5 target triple = "x86_64-apple-darwin10.0.0"
   6
   7 ; Bitcasts between vectors and scalars are valid.
   8 ; PR4487
   9 define i32 @test1(i64 %a) {
  10 ; CHECK-LABEL: @test1(
  11 ; CHECK-NEXT:    ret i32 0
  12 ;
  13   %t1 = bitcast i64 %a to <2 x i32>
  14   %t2 = bitcast i64 %a to <2 x i32>
  15   %t3 = xor <2 x i32> %t1, %t2
  16   %t4 = extractelement <2 x i32> %t3, i32 0
  17   ret i32 %t4
  18 }
  19
  20 ; Perform the bitwise logic in the source type of the operands to eliminate bitcasts.
  21
  22 define <2 x i32> @xor_two_vector_bitcasts(<1 x i64> %a, <1 x i64> %b) {
  23 ; CHECK-LABEL: @xor_two_vector_bitcasts(
  24 ; CHECK-NEXT:    [[T31:%.*]] = xor <1 x i64> [[A:%.*]], [[B:%.*]]
  25 ; CHECK-NEXT:    [[T3:%.*]] = bitcast <1 x i64> [[T31]] to <2 x i32>
  26 ; CHECK-NEXT:    ret <2 x i32> [[T3]]
  27 ;
  28   %t1 = bitcast <1 x i64> %a to <2 x i32>
  29   %t2 = bitcast <1 x i64> %b to <2 x i32>
  30   %t3 = xor <2 x i32> %t1, %t2
  31   ret <2 x i32> %t3
  32 }
  33
  34 ; No change. Bitcasts are canonicalized above bitwise logic.
  35
  36 define <2 x i32> @xor_bitcast_vec_to_vec(<1 x i64> %a) {
  37 ; CHECK-LABEL: @xor_bitcast_vec_to_vec(
  38 ; CHECK-NEXT:    [[T1:%.*]] = bitcast <1 x i64> [[A:%.*]] to <2 x i32>
  39 ; CHECK-NEXT:    [[T2:%.*]] = xor <2 x i32> [[T1]], <i32 1, i32 2>
  40 ; CHECK-NEXT:    ret <2 x i32> [[T2]]
  41 ;
  42   %t1 = bitcast <1 x i64> %a to <2 x i32>
  43   %t2 = xor <2 x i32> <i32 1, i32 2>, %t1
  44   ret <2 x i32> %t2
  45 }
  46
  47 ; No change. Bitcasts are canonicalized above bitwise logic.
  48
  49 define i64 @and_bitcast_vec_to_int(<2 x i32> %a) {
  50 ; CHECK-LABEL: @and_bitcast_vec_to_int(
  51 ; CHECK-NEXT:    [[T1:%.*]] = bitcast <2 x i32> [[A:%.*]] to i64
  52 ; CHECK-NEXT:    [[T2:%.*]] = and i64 [[T1]], 3
  53 ; CHECK-NEXT:    ret i64 [[T2]]
  54 ;
  55   %t1 = bitcast <2 x i32> %a to i64
  56   %t2 = and i64 %t1, 3
  57   ret i64 %t2
  58 }
  59
  60 ; No change. Bitcasts are canonicalized above bitwise logic.
  61
  62 define <2 x i32> @or_bitcast_int_to_vec(i64 %a) {
  63 ; CHECK-LABEL: @or_bitcast_int_to_vec(
  64 ; CHECK-NEXT:    [[T1:%.*]] = bitcast i64 [[A:%.*]] to <2 x i32>
  65 ; CHECK-NEXT:    [[T2:%.*]] = or <2 x i32> [[T1]], <i32 1, i32 2>
  66 ; CHECK-NEXT:    ret <2 x i32> [[T2]]
  67 ;
  68   %t1 = bitcast i64 %a to <2 x i32>
  69   %t2 = or <2 x i32> %t1, <i32 1, i32 2>
  70   ret <2 x i32> %t2
  71 }
  72
  73 ; PR26702 - https://bugs.llvm.org//show_bug.cgi?id=26702
  74 ; Bitcast is canonicalized above logic, so we can see the not-not pattern.
  75
  76 define <2 x i64> @is_negative(<4 x i32> %x) {
  77 ; CHECK-LABEL: @is_negative(
  78 ; CHECK-NEXT:    [[X_LOBIT:%.*]] = ashr <4 x i32> [[X:%.*]], splat (i32 31)
  79 ; CHECK-NEXT:    [[NOTNOT:%.*]] = bitcast <4 x i32> [[X_LOBIT]] to <2 x i64>
  80 ; CHECK-NEXT:    ret <2 x i64> [[NOTNOT]]
  81 ;
  82   %lobit = ashr <4 x i32> %x, <i32 31, i32 31, i32 31, i32 31>
  83   %not = xor <4 x i32> %lobit, <i32 -1, i32 -1, i32 -1, i32 -1>
  84   %bc = bitcast <4 x i32> %not to <2 x i64>
  85   %notnot = xor <2 x i64> %bc, <i64 -1, i64 -1>
  86   ret <2 x i64> %notnot
  87 }
  88
  89 ; This variation has an extra bitcast at the end. This means that the 2nd xor
  90 ; can be done in <4 x i32> to eliminate a bitcast regardless of canonicalizaion.
  91
  92 define <4 x i32> @is_negative_bonus_bitcast(<4 x i32> %x) {
  93 ; CHECK-LABEL: @is_negative_bonus_bitcast(
  94 ; CHECK-NEXT:    [[X_LOBIT:%.*]] = ashr <4 x i32> [[X:%.*]], splat (i32 31)
  95 ; CHECK-NEXT:    ret <4 x i32> [[X_LOBIT]]
  96 ;
  97   %lobit = ashr <4 x i32> %x, <i32 31, i32 31, i32 31, i32 31>
  98   %not = xor <4 x i32> %lobit, <i32 -1, i32 -1, i32 -1, i32 -1>
  99   %bc = bitcast <4 x i32> %not to <2 x i64>
 100   %notnot = xor <2 x i64> %bc, <i64 -1, i64 -1>
 101   %bc2 = bitcast <2 x i64> %notnot to <4 x i32>
 102   ret <4 x i32> %bc2
 103 }
 104
 105 ; Bitcasts are canonicalized above bitwise logic.
 106
 107 define <2 x i8> @canonicalize_bitcast_logic_with_constant(<4 x i4> %x) {
 108 ; CHECK-LABEL: @canonicalize_bitcast_logic_with_constant(
 109 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i4> [[X:%.*]] to <2 x i8>
 110 ; CHECK-NEXT:    [[B:%.*]] = and <2 x i8> [[TMP1]], splat (i8 -128)
 111 ; CHECK-NEXT:    ret <2 x i8> [[B]]
 112 ;
 113   %a = and <4 x i4> %x, <i4 0, i4 8, i4 0, i4 8>
 114   %b = bitcast <4 x i4> %a to <2 x i8>
 115   ret <2 x i8> %b
 116 }
 117
 118 ; PR27925 - https://llvm.org/bugs/show_bug.cgi?id=27925
 119
 120 define <4 x i32> @bitcasts_and_bitcast(<4 x i32> %a, <8 x i16> %b) {
 121 ; CHECK-LABEL: @bitcasts_and_bitcast(
 122 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <8 x i16> [[B:%.*]] to <4 x i32>
 123 ; CHECK-NEXT:    [[BC3:%.*]] = and <4 x i32> [[A:%.*]], [[TMP1]]
 124 ; CHECK-NEXT:    ret <4 x i32> [[BC3]]
 125 ;
 126   %bc1 = bitcast <4 x i32> %a to <2 x i64>
 127   %bc2 = bitcast <8 x i16> %b to <2 x i64>
 128   %and = and <2 x i64> %bc2, %bc1
 129   %bc3 = bitcast <2 x i64> %and to <4 x i32>
 130   ret <4 x i32> %bc3
 131 }
 132
 133 define <4 x float> @bitcasts_and_bitcast_to_fp(<4 x float> %a, <8 x i16> %b) {
 134 ; CHECK-LABEL: @bitcasts_and_bitcast_to_fp(
 135 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x float> [[A:%.*]] to <8 x i16>
 136 ; CHECK-NEXT:    [[TMP2:%.*]] = and <8 x i16> [[B:%.*]], [[TMP1]]
 137 ; CHECK-NEXT:    [[BC3:%.*]] = bitcast <8 x i16> [[TMP2]] to <4 x float>
 138 ; CHECK-NEXT:    ret <4 x float> [[BC3]]
 139 ;
 140   %bc1 = bitcast <4 x float> %a to <2 x i64>
 141   %bc2 = bitcast <8 x i16> %b to <2 x i64>
 142   %and = and <2 x i64> %bc2, %bc1
 143   %bc3 = bitcast <2 x i64> %and to <4 x float>
 144   ret <4 x float> %bc3
 145 }
 146
 147 ; FIXME: Transform limited from changing vector op to integer op to avoid codegen problems.
 148
 149 define i128 @bitcast_or_bitcast(i128 %a, <2 x i64> %b) {
 150 ; CHECK-LABEL: @bitcast_or_bitcast(
 151 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast i128 [[A:%.*]] to <2 x i64>
 152 ; CHECK-NEXT:    [[OR:%.*]] = or <2 x i64> [[B:%.*]], [[BC1]]
 153 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast <2 x i64> [[OR]] to i128
 154 ; CHECK-NEXT:    ret i128 [[BC2]]
 155 ;
 156   %bc1 = bitcast i128 %a to <2 x i64>
 157   %or = or <2 x i64> %b, %bc1
 158   %bc2 = bitcast <2 x i64> %or to i128
 159   ret i128 %bc2
 160 }
 161
 162 ; FIXME: Transform limited from changing integer op to vector op to avoid codegen problems.
 163
 164 define <4 x i32> @bitcast_xor_bitcast(<4 x i32> %a, i128 %b) {
 165 ; CHECK-LABEL: @bitcast_xor_bitcast(
 166 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast <4 x i32> [[A:%.*]] to i128
 167 ; CHECK-NEXT:    [[XOR:%.*]] = xor i128 [[B:%.*]], [[BC1]]
 168 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast i128 [[XOR]] to <4 x i32>
 169 ; CHECK-NEXT:    ret <4 x i32> [[BC2]]
 170 ;
 171   %bc1 = bitcast <4 x i32> %a to i128
 172   %xor = xor i128 %bc1, %b
 173   %bc2 = bitcast i128 %xor to <4 x i32>
 174   ret <4 x i32> %bc2
 175 }
 176
 177 ; https://llvm.org/bugs/show_bug.cgi?id=6137#c6
 178
 179 define <4 x float> @bitcast_vector_select(<4 x float> %x, <2 x i64> %y, <4 x i1> %cmp) {
 180 ; CHECK-LABEL: @bitcast_vector_select(
 181 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[Y:%.*]] to <4 x float>
 182 ; CHECK-NEXT:    [[T7:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x float> [[X:%.*]], <4 x float> [[TMP1]]
 183 ; CHECK-NEXT:    ret <4 x float> [[T7]]
 184 ;
 185   %t4 = bitcast <4 x float> %x to <4 x i32>
 186   %t5 = bitcast <2 x i64> %y to <4 x i32>
 187   %t6 = select <4 x i1> %cmp, <4 x i32> %t4, <4 x i32> %t5
 188   %t7 = bitcast <4 x i32> %t6 to <4 x float>
 189   ret <4 x float> %t7
 190 }
 191
 192 define float @bitcast_scalar_select_of_scalars(float %x, i32 %y, i1 %cmp) {
 193 ; CHECK-LABEL: @bitcast_scalar_select_of_scalars(
 194 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[Y:%.*]] to float
 195 ; CHECK-NEXT:    [[T7:%.*]] = select i1 [[CMP:%.*]], float [[X:%.*]], float [[TMP1]]
 196 ; CHECK-NEXT:    ret float [[T7]]
 197 ;
 198   %t4 = bitcast float %x to i32
 199   %t6 = select i1 %cmp, i32 %t4, i32 %y
 200   %t7 = bitcast i32 %t6 to float
 201   ret float %t7
 202 }
 203
 204 ; FIXME: We should change the select operand types to scalars, but we need to make
 205 ; sure the backend can reverse that transform if needed.
 206
 207 define float @bitcast_scalar_select_type_mismatch1(float %x, <4 x i8> %y, i1 %cmp) {
 208 ; CHECK-LABEL: @bitcast_scalar_select_type_mismatch1(
 209 ; CHECK-NEXT:    [[T4:%.*]] = bitcast float [[X:%.*]] to <4 x i8>
 210 ; CHECK-NEXT:    [[T6:%.*]] = select i1 [[CMP:%.*]], <4 x i8> [[T4]], <4 x i8> [[Y:%.*]]
 211 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <4 x i8> [[T6]] to float
 212 ; CHECK-NEXT:    ret float [[T7]]
 213 ;
 214   %t4 = bitcast float %x to <4 x i8>
 215   %t6 = select i1 %cmp, <4 x i8> %t4, <4 x i8> %y
 216   %t7 = bitcast <4 x i8> %t6 to float
 217   ret float %t7
 218 }
 219
 220 ; FIXME: We should change the select operand types to vectors, but we need to make
 221 ; sure the backend can reverse that transform if needed.
 222
 223 define <4 x i8> @bitcast_scalar_select_type_mismatch2(<4 x i8> %x, float %y, i1 %cmp) {
 224 ; CHECK-LABEL: @bitcast_scalar_select_type_mismatch2(
 225 ; CHECK-NEXT:    [[T4:%.*]] = bitcast <4 x i8> [[X:%.*]] to float
 226 ; CHECK-NEXT:    [[T6:%.*]] = select i1 [[CMP:%.*]], float [[T4]], float [[Y:%.*]]
 227 ; CHECK-NEXT:    [[T7:%.*]] = bitcast float [[T6]] to <4 x i8>
 228 ; CHECK-NEXT:    ret <4 x i8> [[T7]]
 229 ;
 230   %t4 = bitcast <4 x i8> %x to float
 231   %t6 = select i1 %cmp, float %t4, float %y
 232   %t7 = bitcast float %t6 to <4 x i8>
 233   ret <4 x i8> %t7
 234 }
 235
 236 define <4 x float> @bitcast_scalar_select_of_vectors(<4 x float> %x, <2 x i64> %y, i1 %cmp) {
 237 ; CHECK-LABEL: @bitcast_scalar_select_of_vectors(
 238 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[Y:%.*]] to <4 x float>
 239 ; CHECK-NEXT:    [[T7:%.*]] = select i1 [[CMP:%.*]], <4 x float> [[X:%.*]], <4 x float> [[TMP1]]
 240 ; CHECK-NEXT:    ret <4 x float> [[T7]]
 241 ;
 242   %t4 = bitcast <4 x float> %x to <4 x i32>
 243   %t5 = bitcast <2 x i64> %y to <4 x i32>
 244   %t6 = select i1 %cmp, <4 x i32> %t4, <4 x i32> %t5
 245   %t7 = bitcast <4 x i32> %t6 to <4 x float>
 246   ret <4 x float> %t7
 247 }
 248
 249 ; Can't change the type of the vector select if the dest type is scalar.
 250
 251 define float @bitcast_vector_select_no_fold1(float %x, <2 x i16> %y, <4 x i1> %cmp) {
 252 ; CHECK-LABEL: @bitcast_vector_select_no_fold1(
 253 ; CHECK-NEXT:    [[T4:%.*]] = bitcast float [[X:%.*]] to <4 x i8>
 254 ; CHECK-NEXT:    [[T5:%.*]] = bitcast <2 x i16> [[Y:%.*]] to <4 x i8>
 255 ; CHECK-NEXT:    [[T6:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x i8> [[T4]], <4 x i8> [[T5]]
 256 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <4 x i8> [[T6]] to float
 257 ; CHECK-NEXT:    ret float [[T7]]
 258 ;
 259   %t4 = bitcast float %x to <4 x i8>
 260   %t5 = bitcast <2 x i16> %y to <4 x i8>
 261   %t6 = select <4 x i1> %cmp, <4 x i8> %t4, <4 x i8> %t5
 262   %t7 = bitcast <4 x i8> %t6 to float
 263   ret float %t7
 264 }
 265
 266 ; Can't change the type of the vector select if the number of elements in the dest type is not the same.
 267
 268 define <2 x float> @bitcast_vector_select_no_fold2(<2 x float> %x, <4 x i16> %y, <8 x i1> %cmp) {
 269 ; CHECK-LABEL: @bitcast_vector_select_no_fold2(
 270 ; CHECK-NEXT:    [[T4:%.*]] = bitcast <2 x float> [[X:%.*]] to <8 x i8>
 271 ; CHECK-NEXT:    [[T5:%.*]] = bitcast <4 x i16> [[Y:%.*]] to <8 x i8>
 272 ; CHECK-NEXT:    [[T6:%.*]] = select <8 x i1> [[CMP:%.*]], <8 x i8> [[T4]], <8 x i8> [[T5]]
 273 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <8 x i8> [[T6]] to <2 x float>
 274 ; CHECK-NEXT:    ret <2 x float> [[T7]]
 275 ;
 276   %t4 = bitcast <2 x float> %x to <8 x i8>
 277   %t5 = bitcast <4 x i16> %y to <8 x i8>
 278   %t6 = select <8 x i1> %cmp, <8 x i8> %t4, <8 x i8> %t5
 279   %t7 = bitcast <8 x i8> %t6 to <2 x float>
 280   ret <2 x float> %t7
 281 }
 282
 283 ; Optimize bitcasts that are extracting low element of vector.  This happens because of SRoA.
 284 ; rdar://7892780
 285 define float @test2(<2 x float> %A, <2 x i32> %B) {
 286 ; CHECK-LABEL: @test2(
 287 ; CHECK-NEXT:    [[T24:%.*]] = extractelement <2 x float> [[A:%.*]], i64 0
 288 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i32> [[B:%.*]] to <2 x float>
 289 ; CHECK-NEXT:    [[T4:%.*]] = extractelement <2 x float> [[BC]], i64 0
 290 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[T24]], [[T4]]
 291 ; CHECK-NEXT:    ret float [[ADD]]
 292 ;
 293   %t28 = bitcast <2 x float> %A to i64  ; <i64> [#uses=2]
 294   %t23 = trunc i64 %t28 to i32                ; <i32> [#uses=1]
 295   %t24 = bitcast i32 %t23 to float            ; <float> [#uses=1]
 296
 297   %t = bitcast <2 x i32> %B to i64
 298   %t2 = trunc i64 %t to i32                ; <i32> [#uses=1]
 299   %t4 = bitcast i32 %t2 to float            ; <float> [#uses=1]
 300
 301   %add = fadd float %t24, %t4
 302   ret float %add
 303 }
 304
 305 ; Optimize bitcasts that are extracting other elements of a vector.  This happens because of SRoA.
 306 ; rdar://7892780
 307 define float @test3(<2 x float> %A, <2 x i64> %B) {
 308 ; CHECK-LABEL: @test3(
 309 ; CHECK-NEXT:    [[T24:%.*]] = extractelement <2 x float> [[A:%.*]], i64 1
 310 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast <2 x i64> [[B:%.*]] to <4 x float>
 311 ; CHECK-NEXT:    [[T4:%.*]] = extractelement <4 x float> [[BC2]], i64 2
 312 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[T24]], [[T4]]
 313 ; CHECK-NEXT:    ret float [[ADD]]
 314 ;
 315   %t28 = bitcast <2 x float> %A to i64
 316   %t29 = lshr i64 %t28, 32
 317   %t23 = trunc i64 %t29 to i32
 318   %t24 = bitcast i32 %t23 to float
 319
 320   %t = bitcast <2 x i64> %B to i128
 321   %t1 = lshr i128 %t, 64
 322   %t2 = trunc i128 %t1 to i32
 323   %t4 = bitcast i32 %t2 to float
 324
 325   %add = fadd float %t24, %t4
 326   ret float %add
 327 }
 328
 329 ; Both bitcasts are unnecessary; change the extractelement.
 330
 331 define float @bitcast_extelt1(<2 x float> %A) {
 332 ; CHECK-LABEL: @bitcast_extelt1(
 333 ; CHECK-NEXT:    [[BC2:%.*]] = extractelement <2 x float> [[A:%.*]], i64 0
 334 ; CHECK-NEXT:    ret float [[BC2]]
 335 ;
 336   %bc1 = bitcast <2 x float> %A to <2 x i32>
 337   %ext = extractelement <2 x i32> %bc1, i32 0
 338   %bc2 = bitcast i32 %ext to float
 339   ret float %bc2
 340 }
 341
 342 ; Second bitcast can be folded into the first.
 343
 344 define i64 @bitcast_extelt2(<4 x float> %A) {
 345 ; CHECK-LABEL: @bitcast_extelt2(
 346 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
 347 ; CHECK-NEXT:    [[BC2:%.*]] = extractelement <2 x i64> [[BC]], i64 1
 348 ; CHECK-NEXT:    ret i64 [[BC2]]
 349 ;
 350   %bc1 = bitcast <4 x float> %A to <2 x double>
 351   %ext = extractelement <2 x double> %bc1, i32 1
 352   %bc2 = bitcast double %ext to i64
 353   ret i64 %bc2
 354 }
 355
 356 define <2 x i32> @bitcast_extelt3(<2 x i32> %A) {
 357 ; CHECK-LABEL: @bitcast_extelt3(
 358 ; CHECK-NEXT:    ret <2 x i32> [[A:%.*]]
 359 ;
 360   %bc1 = bitcast <2 x i32> %A to <1 x i64>
 361   %ext = extractelement <1 x i64> %bc1, i32 0
 362   %bc2 = bitcast i64 %ext to <2 x i32>
 363   ret <2 x i32> %bc2
 364 }
 365
 366 ; Handle the case where the input is not a vector.
 367
 368 define double @bitcast_extelt4(i128 %A) {
 369 ; CHECK-LABEL: @bitcast_extelt4(
 370 ; CHECK-NEXT:    [[EXT:%.*]] = trunc i128 [[A:%.*]] to i64
 371 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast i64 [[EXT]] to double
 372 ; CHECK-NEXT:    ret double [[BC2]]
 373 ;
 374   %bc1 = bitcast i128 %A to <2 x i64>
 375   %ext = extractelement <2 x i64> %bc1, i32 0
 376   %bc2 = bitcast i64 %ext to double
 377   ret double %bc2
 378 }
 379
 380 define <2 x i32> @test4(i32 %A, i32 %B){
 381 ; CHECK-LABEL: @test4(
 382 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x i32> poison, i32 [[A:%.*]], i64 0
 383 ; CHECK-NEXT:    [[T43:%.*]] = insertelement <2 x i32> [[TMP1]], i32 [[B:%.*]], i64 1
 384 ; CHECK-NEXT:    ret <2 x i32> [[T43]]
 385 ;
 386   %t38 = zext i32 %A to i64
 387   %t32 = zext i32 %B to i64
 388   %t33 = shl i64 %t32, 32
 389   %ins35 = or i64 %t33, %t38
 390   %t43 = bitcast i64 %ins35 to <2 x i32>
 391   ret <2 x i32> %t43
 392 }
 393
 394 ; rdar://8360454
 395 define <2 x float> @test5(float %A, float %B) {
 396 ; CHECK-LABEL: @test5(
 397 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x float> poison, float [[A:%.*]], i64 0
 398 ; CHECK-NEXT:    [[T43:%.*]] = insertelement <2 x float> [[TMP1]], float [[B:%.*]], i64 1
 399 ; CHECK-NEXT:    ret <2 x float> [[T43]]
 400 ;
 401   %t37 = bitcast float %A to i32
 402   %t38 = zext i32 %t37 to i64
 403   %t31 = bitcast float %B to i32
 404   %t32 = zext i32 %t31 to i64
 405   %t33 = shl i64 %t32, 32
 406   %ins35 = or i64 %t33, %t38
 407   %t43 = bitcast i64 %ins35 to <2 x float>
 408   ret <2 x float> %t43
 409 }
 410
 411 define <2 x float> @test6(float %A){
 412 ; CHECK-LABEL: @test6(
 413 ; CHECK-NEXT:    [[T35:%.*]] = insertelement <2 x float> <float 4.200000e+01, float poison>, float [[A:%.*]], i64 1
 414 ; CHECK-NEXT:    ret <2 x float> [[T35]]
 415 ;
 416   %t23 = bitcast float %A to i32
 417   %t24 = zext i32 %t23 to i64
 418   %t25 = shl i64 %t24, 32
 419   %mask20 = or i64 %t25, 1109917696
 420   %t35 = bitcast i64 %mask20 to <2 x float>
 421   ret <2 x float> %t35
 422 }
 423
 424 define i64 @ISPC0(i64 %in) {
 425 ; CHECK-LABEL: @ISPC0(
 426 ; CHECK-NEXT:    ret i64 0
 427 ;
 428   %out = and i64 %in, xor (i64 bitcast (<4 x i16> <i16 -1, i16 -1, i16 -1, i16 -1> to i64), i64 -1)
 429   ret i64 %out
 430 }
 431
 432
 433 define i64 @Vec2(i64 %in) {
 434 ; CHECK-LABEL: @Vec2(
 435 ; CHECK-NEXT:    ret i64 0
 436 ;
 437   %out = and i64 %in, xor (i64 bitcast (<4 x i16> <i16 0, i16 0, i16 0, i16 0> to i64), i64 0)
 438   ret i64 %out
 439 }
 440
 441 define i64 @All11(i64 %in) {
 442 ; CHECK-LABEL: @All11(
 443 ; CHECK-NEXT:    ret i64 0
 444 ;
 445   %out = and i64 %in, xor (i64 bitcast (<2 x float> bitcast (i64 -1 to <2 x float>) to i64), i64 -1)
 446   ret i64 %out
 447 }
 448
 449
 450 define i32 @All111(i32 %in) {
 451 ; CHECK-LABEL: @All111(
 452 ; CHECK-NEXT:    ret i32 0
 453 ;
 454   %out = and i32 %in, xor (i32 bitcast (<1 x float> bitcast (i32 -1 to <1 x float>) to i32), i32 -1)
 455   ret i32 %out
 456 }
 457
 458 define <2 x i16> @BitcastInsert(i32 %a) {
 459 ; CHECK-LABEL: @BitcastInsert(
 460 ; CHECK-NEXT:    [[R:%.*]] = bitcast i32 [[A:%.*]] to <2 x i16>
 461 ; CHECK-NEXT:    ret <2 x i16> [[R]]
 462 ;
 463   %v = insertelement <1 x i32> poison, i32 %a, i32 0
 464   %r = bitcast <1 x i32> %v to <2 x i16>
 465   ret <2 x i16> %r
 466 }
 467
 468 ; PR17293
 469 define <2 x i64> @test7(ptr %arg) nounwind {
 470 ; CHECK-LABEL: @test7(
 471 ; CHECK-NEXT:    [[LOAD:%.*]] = load <2 x i64>, ptr [[ARG:%.*]], align 16
 472 ; CHECK-NEXT:    ret <2 x i64> [[LOAD]]
 473 ;
 474   %load = load <2 x i64>, ptr %arg, align 16
 475   ret <2 x i64> %load
 476 }
 477
 478 define i8 @test8() {
 479 ; CHECK-LABEL: @test8(
 480 ; CHECK-NEXT:    ret i8 -85
 481 ;
 482   %res = bitcast <8 x i1> <i1 true, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true> to i8
 483   ret i8 %res
 484 }
 485
 486 @g = internal unnamed_addr global i32 undef
 487
 488 define void @constant_fold_vector_to_double() {
 489 ; CHECK-LABEL: @constant_fold_vector_to_double(
 490 ; CHECK-NEXT:    store volatile double 1.000000e+00, ptr undef, align 8
 491 ; CHECK-NEXT:    store volatile double 1.000000e+00, ptr undef, align 8
 492 ; CHECK-NEXT:    store volatile double 1.000000e+00, ptr undef, align 8
 493 ; CHECK-NEXT:    store volatile double 1.000000e+00, ptr undef, align 8
 494 ; CHECK-NEXT:    store volatile double 0xFFFFFFFFFFFFFFFF, ptr undef, align 8
 495 ; CHECK-NEXT:    store volatile double 0x162E000004D2, ptr undef, align 8
 496 ; CHECK-NEXT:    store volatile double bitcast (<2 x i32> <i32 1234, i32 ptrtoint (ptr @g to i32)> to double), ptr undef, align 8
 497 ; CHECK-NEXT:    store volatile double 0x400000003F800000, ptr undef, align 8
 498 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 499 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 500 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 501 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 502 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 503 ; CHECK-NEXT:    store volatile double 0.000000e+00, ptr undef, align 8
 504 ; CHECK-NEXT:    ret void
 505 ;
 506   store volatile double bitcast (<1 x i64> <i64 4607182418800017408> to double), ptr undef
 507   store volatile double bitcast (<2 x i32> <i32 0, i32 1072693248> to double), ptr undef
 508   store volatile double bitcast (<4 x i16> <i16 0, i16 0, i16 0, i16 16368> to double), ptr undef
 509   store volatile double bitcast (<8 x i8> <i8 0, i8 0, i8 0, i8 0, i8 0, i8 0, i8 240, i8 63> to double), ptr undef
 510
 511   store volatile double bitcast (<2 x i32> <i32 -1, i32 -1> to double), ptr undef
 512   store volatile double bitcast (<2 x i32> <i32 1234, i32 5678> to double), ptr undef
 513
 514   store volatile double bitcast (<2 x i32> <i32 1234, i32 ptrtoint (ptr @g to i32)> to double), ptr undef
 515   store volatile double bitcast (<2 x float> <float 1.0, float 2.0> to double), ptr undef
 516
 517   store volatile double bitcast (<2 x i32> zeroinitializer to double), ptr undef
 518   store volatile double bitcast (<4 x i16> zeroinitializer to double), ptr undef
 519   store volatile double bitcast (<8 x i8> zeroinitializer to double), ptr undef
 520   store volatile double bitcast (<16 x i4> zeroinitializer to double), ptr undef
 521   store volatile double bitcast (<32 x i2> zeroinitializer to double), ptr undef
 522   store volatile double bitcast (<64 x i1> zeroinitializer to double), ptr undef
 523   ret void
 524 }
 525
 526 define void @constant_fold_vector_to_float() {
 527 ; CHECK-LABEL: @constant_fold_vector_to_float(
 528 ; CHECK-NEXT:    store volatile float 1.000000e+00, ptr undef, align 4
 529 ; CHECK-NEXT:    store volatile float 1.000000e+00, ptr undef, align 4
 530 ; CHECK-NEXT:    store volatile float 1.000000e+00, ptr undef, align 4
 531 ; CHECK-NEXT:    store volatile float 1.000000e+00, ptr undef, align 4
 532 ; CHECK-NEXT:    ret void
 533 ;
 534   store volatile float bitcast (<1 x i32> <i32 1065353216> to float), ptr undef
 535   store volatile float bitcast (<2 x i16> <i16 0, i16 16256> to float), ptr undef
 536   store volatile float bitcast (<4 x i8> <i8 0, i8 0, i8 128, i8 63> to float), ptr undef
 537   store volatile float bitcast (<32 x i1> <i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 0, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1, i1 1, i1 0, i1 0> to float), ptr undef
 538
 539   ret void
 540 }
 541
 542 define void @constant_fold_vector_to_half() {
 543 ; CHECK-LABEL: @constant_fold_vector_to_half(
 544 ; CHECK-NEXT:    store volatile half 0xH4000, ptr undef, align 2
 545 ; CHECK-NEXT:    store volatile half 0xH4000, ptr undef, align 2
 546 ; CHECK-NEXT:    ret void
 547 ;
 548   store volatile half bitcast (<2 x i8> <i8 0, i8 64> to half), ptr undef
 549   store volatile half bitcast (<4 x i4> <i4 0, i4 0, i4 0, i4 4> to half), ptr undef
 550   ret void
 551 }
 552
 553 ; Ensure that we do not crash when looking at such a weird bitcast.
 554 define ptr @bitcast_from_single_element_pointer_vector_to_pointer(<1 x ptr> %ptrvec) {
 555 ; CHECK-LABEL: @bitcast_from_single_element_pointer_vector_to_pointer(
 556 ; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <1 x ptr> [[PTRVEC:%.*]], i64 0
 557 ; CHECK-NEXT:    ret ptr [[TMP1]]
 558 ;
 559   %ptr = bitcast <1 x ptr> %ptrvec to ptr
 560   ret ptr %ptr
 561 }