llvm/test/Transforms/InstCombine/bitcast.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -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:    [[LOBIT:%.*]] = ashr <4 x i32> [[X:%.*]], <i32 31, i32 31, i32 31, i32 31>
  79 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <4 x i32> [[LOBIT]] to <2 x i64>
  80 ; CHECK-NEXT:    ret <2 x i64> [[TMP1]]
  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:    [[LOBIT:%.*]] = ashr <4 x i32> [[X:%.*]], <i32 31, i32 31, i32 31, i32 31>
  95 ; CHECK-NEXT:    ret <4 x i32> [[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]], <i8 -128, 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> [[TMP1]], [[A:%.*]]
 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 ; The destination must have an integer element type.
 134 ; FIXME: We can still eliminate one bitcast in this test by doing the logic op
 135 ; in the type of the input that has an integer element type.
 136
 137 define <4 x float> @bitcasts_and_bitcast_to_fp(<4 x float> %a, <8 x i16> %b) {
 138 ; CHECK-LABEL: @bitcasts_and_bitcast_to_fp(
 139 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
 140 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast <8 x i16> [[B:%.*]] to <2 x i64>
 141 ; CHECK-NEXT:    [[AND:%.*]] = and <2 x i64> [[BC2]], [[BC1]]
 142 ; CHECK-NEXT:    [[BC3:%.*]] = bitcast <2 x i64> [[AND]] to <4 x float>
 143 ; CHECK-NEXT:    ret <4 x float> [[BC3]]
 144 ;
 145   %bc1 = bitcast <4 x float> %a to <2 x i64>
 146   %bc2 = bitcast <8 x i16> %b to <2 x i64>
 147   %and = and <2 x i64> %bc2, %bc1
 148   %bc3 = bitcast <2 x i64> %and to <4 x float>
 149   ret <4 x float> %bc3
 150 }
 151
 152 ; FIXME: Transform limited from changing vector op to integer op to avoid codegen problems.
 153
 154 define i128 @bitcast_or_bitcast(i128 %a, <2 x i64> %b) {
 155 ; CHECK-LABEL: @bitcast_or_bitcast(
 156 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast i128 [[A:%.*]] to <2 x i64>
 157 ; CHECK-NEXT:    [[OR:%.*]] = or <2 x i64> [[BC1]], [[B:%.*]]
 158 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast <2 x i64> [[OR]] to i128
 159 ; CHECK-NEXT:    ret i128 [[BC2]]
 160 ;
 161   %bc1 = bitcast i128 %a to <2 x i64>
 162   %or = or <2 x i64> %b, %bc1
 163   %bc2 = bitcast <2 x i64> %or to i128
 164   ret i128 %bc2
 165 }
 166
 167 ; FIXME: Transform limited from changing integer op to vector op to avoid codegen problems.
 168
 169 define <4 x i32> @bitcast_xor_bitcast(<4 x i32> %a, i128 %b) {
 170 ; CHECK-LABEL: @bitcast_xor_bitcast(
 171 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast <4 x i32> [[A:%.*]] to i128
 172 ; CHECK-NEXT:    [[XOR:%.*]] = xor i128 [[BC1]], [[B:%.*]]
 173 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast i128 [[XOR]] to <4 x i32>
 174 ; CHECK-NEXT:    ret <4 x i32> [[BC2]]
 175 ;
 176   %bc1 = bitcast <4 x i32> %a to i128
 177   %xor = xor i128 %bc1, %b
 178   %bc2 = bitcast i128 %xor to <4 x i32>
 179   ret <4 x i32> %bc2
 180 }
 181
 182 ; https://llvm.org/bugs/show_bug.cgi?id=6137#c6
 183
 184 define <4 x float> @bitcast_vector_select(<4 x float> %x, <2 x i64> %y, <4 x i1> %cmp) {
 185 ; CHECK-LABEL: @bitcast_vector_select(
 186 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[Y:%.*]] to <4 x float>
 187 ; CHECK-NEXT:    [[T7:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x float> [[X:%.*]], <4 x float> [[TMP1]]
 188 ; CHECK-NEXT:    ret <4 x float> [[T7]]
 189 ;
 190   %t4 = bitcast <4 x float> %x to <4 x i32>
 191   %t5 = bitcast <2 x i64> %y to <4 x i32>
 192   %t6 = select <4 x i1> %cmp, <4 x i32> %t4, <4 x i32> %t5
 193   %t7 = bitcast <4 x i32> %t6 to <4 x float>
 194   ret <4 x float> %t7
 195 }
 196
 197 define float @bitcast_scalar_select_of_scalars(float %x, i32 %y, i1 %cmp) {
 198 ; CHECK-LABEL: @bitcast_scalar_select_of_scalars(
 199 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[Y:%.*]] to float
 200 ; CHECK-NEXT:    [[T7:%.*]] = select i1 [[CMP:%.*]], float [[X:%.*]], float [[TMP1]]
 201 ; CHECK-NEXT:    ret float [[T7]]
 202 ;
 203   %t4 = bitcast float %x to i32
 204   %t6 = select i1 %cmp, i32 %t4, i32 %y
 205   %t7 = bitcast i32 %t6 to float
 206   ret float %t7
 207 }
 208
 209 ; FIXME: We should change the select operand types to scalars, but we need to make
 210 ; sure the backend can reverse that transform if needed.
 211
 212 define float @bitcast_scalar_select_type_mismatch1(float %x, <4 x i8> %y, i1 %cmp) {
 213 ; CHECK-LABEL: @bitcast_scalar_select_type_mismatch1(
 214 ; CHECK-NEXT:    [[T4:%.*]] = bitcast float [[X:%.*]] to <4 x i8>
 215 ; CHECK-NEXT:    [[T6:%.*]] = select i1 [[CMP:%.*]], <4 x i8> [[T4]], <4 x i8> [[Y:%.*]]
 216 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <4 x i8> [[T6]] to float
 217 ; CHECK-NEXT:    ret float [[T7]]
 218 ;
 219   %t4 = bitcast float %x to <4 x i8>
 220   %t6 = select i1 %cmp, <4 x i8> %t4, <4 x i8> %y
 221   %t7 = bitcast <4 x i8> %t6 to float
 222   ret float %t7
 223 }
 224
 225 ; FIXME: We should change the select operand types to vectors, but we need to make
 226 ; sure the backend can reverse that transform if needed.
 227
 228 define <4 x i8> @bitcast_scalar_select_type_mismatch2(<4 x i8> %x, float %y, i1 %cmp) {
 229 ; CHECK-LABEL: @bitcast_scalar_select_type_mismatch2(
 230 ; CHECK-NEXT:    [[T4:%.*]] = bitcast <4 x i8> [[X:%.*]] to float
 231 ; CHECK-NEXT:    [[T6:%.*]] = select i1 [[CMP:%.*]], float [[T4]], float [[Y:%.*]]
 232 ; CHECK-NEXT:    [[T7:%.*]] = bitcast float [[T6]] to <4 x i8>
 233 ; CHECK-NEXT:    ret <4 x i8> [[T7]]
 234 ;
 235   %t4 = bitcast <4 x i8> %x to float
 236   %t6 = select i1 %cmp, float %t4, float %y
 237   %t7 = bitcast float %t6 to <4 x i8>
 238   ret <4 x i8> %t7
 239 }
 240
 241 define <4 x float> @bitcast_scalar_select_of_vectors(<4 x float> %x, <2 x i64> %y, i1 %cmp) {
 242 ; CHECK-LABEL: @bitcast_scalar_select_of_vectors(
 243 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i64> [[Y:%.*]] to <4 x float>
 244 ; CHECK-NEXT:    [[T7:%.*]] = select i1 [[CMP:%.*]], <4 x float> [[X:%.*]], <4 x float> [[TMP1]]
 245 ; CHECK-NEXT:    ret <4 x float> [[T7]]
 246 ;
 247   %t4 = bitcast <4 x float> %x to <4 x i32>
 248   %t5 = bitcast <2 x i64> %y to <4 x i32>
 249   %t6 = select i1 %cmp, <4 x i32> %t4, <4 x i32> %t5
 250   %t7 = bitcast <4 x i32> %t6 to <4 x float>
 251   ret <4 x float> %t7
 252 }
 253
 254 ; Can't change the type of the vector select if the dest type is scalar.
 255
 256 define float @bitcast_vector_select_no_fold1(float %x, <2 x i16> %y, <4 x i1> %cmp) {
 257 ; CHECK-LABEL: @bitcast_vector_select_no_fold1(
 258 ; CHECK-NEXT:    [[T4:%.*]] = bitcast float [[X:%.*]] to <4 x i8>
 259 ; CHECK-NEXT:    [[T5:%.*]] = bitcast <2 x i16> [[Y:%.*]] to <4 x i8>
 260 ; CHECK-NEXT:    [[T6:%.*]] = select <4 x i1> [[CMP:%.*]], <4 x i8> [[T4]], <4 x i8> [[T5]]
 261 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <4 x i8> [[T6]] to float
 262 ; CHECK-NEXT:    ret float [[T7]]
 263 ;
 264   %t4 = bitcast float %x to <4 x i8>
 265   %t5 = bitcast <2 x i16> %y to <4 x i8>
 266   %t6 = select <4 x i1> %cmp, <4 x i8> %t4, <4 x i8> %t5
 267   %t7 = bitcast <4 x i8> %t6 to float
 268   ret float %t7
 269 }
 270
 271 ; Can't change the type of the vector select if the number of elements in the dest type is not the same.
 272
 273 define <2 x float> @bitcast_vector_select_no_fold2(<2 x float> %x, <4 x i16> %y, <8 x i1> %cmp) {
 274 ; CHECK-LABEL: @bitcast_vector_select_no_fold2(
 275 ; CHECK-NEXT:    [[T4:%.*]] = bitcast <2 x float> [[X:%.*]] to <8 x i8>
 276 ; CHECK-NEXT:    [[T5:%.*]] = bitcast <4 x i16> [[Y:%.*]] to <8 x i8>
 277 ; CHECK-NEXT:    [[T6:%.*]] = select <8 x i1> [[CMP:%.*]], <8 x i8> [[T4]], <8 x i8> [[T5]]
 278 ; CHECK-NEXT:    [[T7:%.*]] = bitcast <8 x i8> [[T6]] to <2 x float>
 279 ; CHECK-NEXT:    ret <2 x float> [[T7]]
 280 ;
 281   %t4 = bitcast <2 x float> %x to <8 x i8>
 282   %t5 = bitcast <4 x i16> %y to <8 x i8>
 283   %t6 = select <8 x i1> %cmp, <8 x i8> %t4, <8 x i8> %t5
 284   %t7 = bitcast <8 x i8> %t6 to <2 x float>
 285   ret <2 x float> %t7
 286 }
 287
 288 ; Optimize bitcasts that are extracting low element of vector.  This happens because of SRoA.
 289 ; rdar://7892780
 290 define float @test2(<2 x float> %A, <2 x i32> %B) {
 291 ; CHECK-LABEL: @test2(
 292 ; CHECK-NEXT:    [[TMP24:%.*]] = extractelement <2 x float> [[A:%.*]], i32 0
 293 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x i32> [[B:%.*]] to <2 x float>
 294 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <2 x float> [[BC]], i32 0
 295 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[TMP24]], [[TMP4]]
 296 ; CHECK-NEXT:    ret float [[ADD]]
 297 ;
 298   %tmp28 = bitcast <2 x float> %A to i64  ; <i64> [#uses=2]
 299   %tmp23 = trunc i64 %tmp28 to i32                ; <i32> [#uses=1]
 300   %tmp24 = bitcast i32 %tmp23 to float            ; <float> [#uses=1]
 301
 302   %tmp = bitcast <2 x i32> %B to i64
 303   %tmp2 = trunc i64 %tmp to i32                ; <i32> [#uses=1]
 304   %tmp4 = bitcast i32 %tmp2 to float            ; <float> [#uses=1]
 305
 306   %add = fadd float %tmp24, %tmp4
 307   ret float %add
 308 }
 309
 310 ; Optimize bitcasts that are extracting other elements of a vector.  This happens because of SRoA.
 311 ; rdar://7892780
 312 define float @test3(<2 x float> %A, <2 x i64> %B) {
 313 ; CHECK-LABEL: @test3(
 314 ; CHECK-NEXT:    [[TMP24:%.*]] = extractelement <2 x float> [[A:%.*]], i32 1
 315 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast <2 x i64> [[B:%.*]] to <4 x float>
 316 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <4 x float> [[BC2]], i32 2
 317 ; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[TMP24]], [[TMP4]]
 318 ; CHECK-NEXT:    ret float [[ADD]]
 319 ;
 320   %tmp28 = bitcast <2 x float> %A to i64
 321   %tmp29 = lshr i64 %tmp28, 32
 322   %tmp23 = trunc i64 %tmp29 to i32
 323   %tmp24 = bitcast i32 %tmp23 to float
 324
 325   %tmp = bitcast <2 x i64> %B to i128
 326   %tmp1 = lshr i128 %tmp, 64
 327   %tmp2 = trunc i128 %tmp1 to i32
 328   %tmp4 = bitcast i32 %tmp2 to float
 329
 330   %add = fadd float %tmp24, %tmp4
 331   ret float %add
 332 }
 333
 334 ; Both bitcasts are unnecessary; change the extractelement.
 335
 336 define float @bitcast_extelt1(<2 x float> %A) {
 337 ; CHECK-LABEL: @bitcast_extelt1(
 338 ; CHECK-NEXT:    [[BC2:%.*]] = extractelement <2 x float> [[A:%.*]], i32 0
 339 ; CHECK-NEXT:    ret float [[BC2]]
 340 ;
 341   %bc1 = bitcast <2 x float> %A to <2 x i32>
 342   %ext = extractelement <2 x i32> %bc1, i32 0
 343   %bc2 = bitcast i32 %ext to float
 344   ret float %bc2
 345 }
 346
 347 ; Second bitcast can be folded into the first.
 348
 349 define i64 @bitcast_extelt2(<4 x float> %A) {
 350 ; CHECK-LABEL: @bitcast_extelt2(
 351 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <4 x float> [[A:%.*]] to <2 x i64>
 352 ; CHECK-NEXT:    [[BC2:%.*]] = extractelement <2 x i64> [[BC]], i32 1
 353 ; CHECK-NEXT:    ret i64 [[BC2]]
 354 ;
 355   %bc1 = bitcast <4 x float> %A to <2 x double>
 356   %ext = extractelement <2 x double> %bc1, i32 1
 357   %bc2 = bitcast double %ext to i64
 358   ret i64 %bc2
 359 }
 360
 361 ; TODO: This should return %A.
 362
 363 define <2 x i32> @bitcast_extelt3(<2 x i32> %A) {
 364 ; CHECK-LABEL: @bitcast_extelt3(
 365 ; CHECK-NEXT:    [[BC1:%.*]] = bitcast <2 x i32> [[A:%.*]] to <1 x i64>
 366 ; CHECK-NEXT:    [[EXT:%.*]] = extractelement <1 x i64> [[BC1]], i32 0
 367 ; CHECK-NEXT:    [[BC2:%.*]] = bitcast i64 [[EXT]] to <2 x i32>
 368 ; CHECK-NEXT:    ret <2 x i32> [[BC2]]
 369 ;
 370   %bc1 = bitcast <2 x i32> %A to <1 x i64>
 371   %ext = extractelement <1 x i64> %bc1, i32 0
 372   %bc2 = bitcast i64 %ext to <2 x i32>
 373   ret <2 x i32> %bc2
 374 }
 375
 376 ; Handle the case where the input is not a vector.
 377
 378 define double @bitcast_extelt4(i128 %A) {
 379 ; CHECK-LABEL: @bitcast_extelt4(
 380 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i128 [[A:%.*]] to <2 x double>
 381 ; CHECK-NEXT:    [[BC2:%.*]] = extractelement <2 x double> [[BC]], i32 0
 382 ; CHECK-NEXT:    ret double [[BC2]]
 383 ;
 384   %bc1 = bitcast i128 %A to <2 x i64>
 385   %ext = extractelement <2 x i64> %bc1, i32 0
 386   %bc2 = bitcast i64 %ext to double
 387   ret double %bc2
 388 }
 389
 390 define <2 x i32> @test4(i32 %A, i32 %B){
 391 ; CHECK-LABEL: @test4(
 392 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x i32> poison, i32 [[A:%.*]], i32 0
 393 ; CHECK-NEXT:    [[TMP2:%.*]] = insertelement <2 x i32> [[TMP1]], i32 [[B:%.*]], i32 1
 394 ; CHECK-NEXT:    ret <2 x i32> [[TMP2]]
 395 ;
 396   %tmp38 = zext i32 %A to i64
 397   %tmp32 = zext i32 %B to i64
 398   %tmp33 = shl i64 %tmp32, 32
 399   %ins35 = or i64 %tmp33, %tmp38
 400   %tmp43 = bitcast i64 %ins35 to <2 x i32>
 401   ret <2 x i32> %tmp43
 402 }
 403
 404 ; rdar://8360454
 405 define <2 x float> @test5(float %A, float %B) {
 406 ; CHECK-LABEL: @test5(
 407 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x float> poison, float [[A:%.*]], i32 0
 408 ; CHECK-NEXT:    [[TMP2:%.*]] = insertelement <2 x float> [[TMP1]], float [[B:%.*]], i32 1
 409 ; CHECK-NEXT:    ret <2 x float> [[TMP2]]
 410 ;
 411   %tmp37 = bitcast float %A to i32
 412   %tmp38 = zext i32 %tmp37 to i64
 413   %tmp31 = bitcast float %B to i32
 414   %tmp32 = zext i32 %tmp31 to i64
 415   %tmp33 = shl i64 %tmp32, 32
 416   %ins35 = or i64 %tmp33, %tmp38
 417   %tmp43 = bitcast i64 %ins35 to <2 x float>
 418   ret <2 x float> %tmp43
 419 }
 420
 421 define <2 x float> @test6(float %A){
 422 ; CHECK-LABEL: @test6(
 423 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <2 x float> <float 4.200000e+01, float poison>, float [[A:%.*]], i32 1
 424 ; CHECK-NEXT:    ret <2 x float> [[TMP1]]
 425 ;
 426   %tmp23 = bitcast float %A to i32
 427   %tmp24 = zext i32 %tmp23 to i64
 428   %tmp25 = shl i64 %tmp24, 32
 429   %mask20 = or i64 %tmp25, 1109917696
 430   %tmp35 = bitcast i64 %mask20 to <2 x float>
 431   ret <2 x float> %tmp35
 432 }
 433
 434 define i64 @ISPC0(i64 %in) {
 435 ; CHECK-LABEL: @ISPC0(
 436 ; CHECK-NEXT:    ret i64 0
 437 ;
 438   %out = and i64 %in, xor (i64 bitcast (<4 x i16> <i16 -1, i16 -1, i16 -1, i16 -1> to i64), i64 -1)
 439   ret i64 %out
 440 }
 441
 442
 443 define i64 @Vec2(i64 %in) {
 444 ; CHECK-LABEL: @Vec2(
 445 ; CHECK-NEXT:    ret i64 0
 446 ;
 447   %out = and i64 %in, xor (i64 bitcast (<4 x i16> <i16 0, i16 0, i16 0, i16 0> to i64), i64 0)
 448   ret i64 %out
 449 }
 450
 451 define i64 @All11(i64 %in) {
 452 ; CHECK-LABEL: @All11(
 453 ; CHECK-NEXT:    ret i64 0
 454 ;
 455   %out = and i64 %in, xor (i64 bitcast (<2 x float> bitcast (i64 -1 to <2 x float>) to i64), i64 -1)
 456   ret i64 %out
 457 }
 458
 459
 460 define i32 @All111(i32 %in) {
 461 ; CHECK-LABEL: @All111(
 462 ; CHECK-NEXT:    ret i32 0
 463 ;
 464   %out = and i32 %in, xor (i32 bitcast (<1 x float> bitcast (i32 -1 to <1 x float>) to i32), i32 -1)
 465   ret i32 %out
 466 }
 467
 468 define <vscale x 1 x i32> @ScalableAll111(<vscale x 1 x i32> %in) {
 469 ; CHECK-LABEL: @ScalableAll111(
 470 ; CHECK-NEXT:    ret <vscale x 1 x i32> [[IN:%.*]]
 471 ;
 472   %out = and <vscale x 1 x i32> %in, bitcast (<vscale x 2 x i16> shufflevector (<vscale x 2 x i16> insertelement (<vscale x 2 x i16> undef, i16 -1, i32 0), <vscale x 2 x i16> undef, <vscale x 2 x i32> zeroinitializer) to <vscale x 1 x i32>)
 473   ret <vscale x 1 x i32> %out
 474 }
 475
 476 define <2 x i16> @BitcastInsert(i32 %a) {
 477 ; CHECK-LABEL: @BitcastInsert(
 478 ; CHECK-NEXT:    [[R:%.*]] = bitcast i32 [[A:%.*]] to <2 x i16>
 479 ; CHECK-NEXT:    ret <2 x i16> [[R]]
 480 ;
 481   %v = insertelement <1 x i32> undef, i32 %a, i32 0
 482   %r = bitcast <1 x i32> %v to <2 x i16>
 483   ret <2 x i16> %r
 484 }
 485
 486 ; PR17293
 487 define <2 x i64> @test7(<2 x i8*>* %arg) nounwind {
 488 ; CHECK-LABEL: @test7(
 489 ; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i8*>* [[ARG:%.*]] to <2 x i64>*
 490 ; CHECK-NEXT:    [[LOAD:%.*]] = load <2 x i64>, <2 x i64>* [[CAST]], align 16
 491 ; CHECK-NEXT:    ret <2 x i64> [[LOAD]]
 492 ;
 493   %cast = bitcast <2 x i8*>* %arg to <2 x i64>*
 494   %load = load <2 x i64>, <2 x i64>* %cast, align 16
 495   ret <2 x i64> %load
 496 }
 497
 498 define i8 @test8() {
 499 ; CHECK-LABEL: @test8(
 500 ; CHECK-NEXT:    ret i8 -85
 501 ;
 502   %res = bitcast <8 x i1> <i1 true, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true> to i8
 503   ret i8 %res
 504 }
 505
 506 @g = internal unnamed_addr global i32 undef
 507
 508 define void @constant_fold_vector_to_double() {
 509 ; CHECK-LABEL: @constant_fold_vector_to_double(
 510 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* undef, align 8
 511 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* undef, align 8
 512 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* undef, align 8
 513 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* undef, align 8
 514 ; CHECK-NEXT:    store volatile double 0xFFFFFFFFFFFFFFFF, double* undef, align 8
 515 ; CHECK-NEXT:    store volatile double 0x162E000004D2, double* undef, align 8
 516 ; CHECK-NEXT:    store volatile double bitcast (<2 x i32> <i32 1234, i32 ptrtoint (i32* @g to i32)> to double), double* undef, align 8
 517 ; CHECK-NEXT:    store volatile double 0x400000003F800000, double* undef, align 8
 518 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 519 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 520 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 521 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 522 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 523 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* undef, align 8
 524 ; CHECK-NEXT:    ret void
 525 ;
 526   store volatile double bitcast (<1 x i64> <i64 4607182418800017408> to double), double* undef
 527   store volatile double bitcast (<2 x i32> <i32 0, i32 1072693248> to double), double* undef
 528   store volatile double bitcast (<4 x i16> <i16 0, i16 0, i16 0, i16 16368> to double), double* undef
 529   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), double* undef
 530
 531   store volatile double bitcast (<2 x i32> <i32 -1, i32 -1> to double), double* undef
 532   store volatile double bitcast (<2 x i32> <i32 1234, i32 5678> to double), double* undef
 533
 534   store volatile double bitcast (<2 x i32> <i32 1234, i32 ptrtoint (i32* @g to i32)> to double), double* undef
 535   store volatile double bitcast (<2 x float> <float 1.0, float 2.0> to double), double* undef
 536
 537   store volatile double bitcast (<2 x i32> zeroinitializer to double), double* undef
 538   store volatile double bitcast (<4 x i16> zeroinitializer to double), double* undef
 539   store volatile double bitcast (<8 x i8> zeroinitializer to double), double* undef
 540   store volatile double bitcast (<16 x i4> zeroinitializer to double), double* undef
 541   store volatile double bitcast (<32 x i2> zeroinitializer to double), double* undef
 542   store volatile double bitcast (<64 x i1> zeroinitializer to double), double* undef
 543   ret void
 544 }
 545
 546 define void @constant_fold_vector_to_float() {
 547 ; CHECK-LABEL: @constant_fold_vector_to_float(
 548 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* undef, align 4
 549 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* undef, align 4
 550 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* undef, align 4
 551 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* undef, align 4
 552 ; CHECK-NEXT:    ret void
 553 ;
 554   store volatile float bitcast (<1 x i32> <i32 1065353216> to float), float* undef
 555   store volatile float bitcast (<2 x i16> <i16 0, i16 16256> to float), float* undef
 556   store volatile float bitcast (<4 x i8> <i8 0, i8 0, i8 128, i8 63> to float), float* undef
 557   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), float* undef
 558
 559   ret void
 560 }
 561
 562 define void @constant_fold_vector_to_half() {
 563 ; CHECK-LABEL: @constant_fold_vector_to_half(
 564 ; CHECK-NEXT:    store volatile half 0xH4000, half* undef, align 2
 565 ; CHECK-NEXT:    store volatile half 0xH4000, half* undef, align 2
 566 ; CHECK-NEXT:    ret void
 567 ;
 568   store volatile half bitcast (<2 x i8> <i8 0, i8 64> to half), half* undef
 569   store volatile half bitcast (<4 x i4> <i4 0, i4 0, i4 0, i4 4> to half), half* undef
 570   ret void
 571 }
 572
 573 ; Ensure that we do not crash when looking at such a weird bitcast.
 574 define i8* @bitcast_from_single_element_pointer_vector_to_pointer(<1 x i8*> %ptrvec) {
 575 ; CHECK-LABEL: @bitcast_from_single_element_pointer_vector_to_pointer(
 576 ; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <1 x i8*> [[PTRVEC:%.*]], i32 0
 577 ; CHECK-NEXT:    ret i8* [[TMP1]]
 578 ;
 579   %ptr = bitcast <1 x i8*> %ptrvec to i8*
 580   ret i8* %ptr
 581 }
 582
 583 declare void @f1()
 584 declare void @f2()
 585 define i8* @select_bitcast_unsized_pointer(i1 %c) {
 586 ; CHECK-LABEL: @select_bitcast_unsized_pointer(
 587 ; CHECK-NEXT:    [[B:%.*]] = select i1 [[C:%.*]], i8* bitcast (void ()* @f1 to i8*), i8* bitcast (void ()* @f2 to i8*)
 588 ; CHECK-NEXT:    ret i8* [[B]]
 589 ;
 590   %s = select i1 %c, void ()* @f1, void ()* @f2
 591   %b = bitcast void ()* %s to i8*
 592   ret i8* %b
 593 }