test/Transforms/InstCombine/unpack-fca.ll

   1 ; RUN: opt -instcombine -S < %s | FileCheck %s
   2
   3 target datalayout = "e-i64:64-f80:128-n8:16:32:64"
   4 target triple = "x86_64-unknown-linux-gnu"
   5
   6 %A__vtbl = type { i8*, i32 (%A*)* }
   7 %A = type { %A__vtbl* }
   8 %B = type { i8*, i64 }
   9
  10 @A__vtblZ = constant %A__vtbl { i8* null, i32 (%A*)* @A.foo }
  11
  12 declare i32 @A.foo(%A* nocapture %this)
  13
  14 define void @storeA(%A* %a.ptr) {
  15 ; CHECK-LABEL: storeA
  16 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds %A, %A* %a.ptr, i64 0, i32 0
  17 ; CHECK-NEXT: store %A__vtbl* @A__vtblZ, %A__vtbl** [[GEP]], align 8
  18 ; CHECK-NEXT: ret void
  19   store %A { %A__vtbl* @A__vtblZ }, %A* %a.ptr, align 8
  20   ret void
  21 }
  22
  23 define void @storeB(%B* %b.ptr) {
  24 ; CHECK-LABEL: storeB
  25 ; CHECK-NEXT: [[GEP1:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 0
  26 ; CHECK-NEXT: store i8* null, i8** [[GEP1]], align 8
  27 ; CHECK-NEXT: [[GEP2:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 1
  28 ; CHECK-NEXT: store i64 42, i64* [[GEP2]], align 8
  29 ; CHECK-NEXT: ret void
  30   store %B { i8* null, i64 42 }, %B* %b.ptr, align 8
  31   ret void
  32 }
  33
  34 define void @storeStructOfA({ %A }* %sa.ptr) {
  35 ; CHECK-LABEL: storeStructOfA
  36 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds { %A }, { %A }* %sa.ptr, i64 0, i32 0, i32 0
  37 ; CHECK-NEXT: store %A__vtbl* @A__vtblZ, %A__vtbl** [[GEP]], align 8
  38 ; CHECK-NEXT: ret void
  39   store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %sa.ptr, align 8
  40   ret void
  41 }
  42
  43 define void @storeArrayOfA([1 x %A]* %aa.ptr) {
  44 ; CHECK-LABEL: storeArrayOfA
  45 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds [1 x %A], [1 x %A]* %aa.ptr, i64 0, i64 0, i32 0
  46 ; CHECK-NEXT: store %A__vtbl* @A__vtblZ, %A__vtbl** [[GEP]], align 8
  47 ; CHECK-NEXT: ret void
  48   store [1 x %A] [%A { %A__vtbl* @A__vtblZ }], [1 x %A]* %aa.ptr, align 8
  49   ret void
  50 }
  51
  52 define void @storeStructOfArrayOfA({ [1 x %A] }* %saa.ptr) {
  53 ; CHECK-LABEL: storeStructOfArrayOfA
  54 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds { [1 x %A] }, { [1 x %A] }* %saa.ptr, i64 0, i32 0, i64 0, i32 0
  55 ; CHECK-NEXT: store %A__vtbl* @A__vtblZ, %A__vtbl** [[GEP]], align 8
  56 ; CHECK-NEXT: ret void
  57   store { [1 x %A] } { [1 x %A] [%A { %A__vtbl* @A__vtblZ }] }, { [1 x %A] }* %saa.ptr, align 8
  58   ret void
  59 }
  60
  61 define %A @loadA(%A* %a.ptr) {
  62 ; CHECK-LABEL: loadA
  63 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds %A, %A* %a.ptr, i64 0, i32 0
  64 ; CHECK-NEXT: [[LOAD:%[a-z0-9\.]+]] = load %A__vtbl*, %A__vtbl** [[GEP]], align 8
  65 ; CHECK-NEXT: [[IV:%[a-z0-9\.]+]] = insertvalue %A undef, %A__vtbl* [[LOAD]], 0
  66 ; CHECK-NEXT: ret %A [[IV]]
  67   %1 = load %A, %A* %a.ptr, align 8
  68   ret %A %1
  69 }
  70
  71 define %B @loadB(%B* %b.ptr) {
  72 ; CHECK-LABEL: loadB
  73 ; CHECK-NEXT: [[GEP1:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 0
  74 ; CHECK-NEXT: [[LOAD1:%[a-z0-9\.]+]] = load i8*, i8** [[GEP1]], align 8
  75 ; CHECK-NEXT: [[IV1:%[a-z0-9\.]+]] = insertvalue %B undef, i8* [[LOAD1]], 0
  76 ; CHECK-NEXT: [[GEP2:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 1
  77 ; CHECK-NEXT: [[LOAD2:%[a-z0-9\.]+]] = load i64, i64* [[GEP2]], align 8
  78 ; CHECK-NEXT: [[IV2:%[a-z0-9\.]+]] = insertvalue %B [[IV1]], i64 [[LOAD2]], 1
  79 ; CHECK-NEXT: ret %B [[IV2]]
  80   %1 = load %B, %B* %b.ptr, align 8
  81   ret %B %1
  82 }
  83
  84 define { %A } @loadStructOfA({ %A }* %sa.ptr) {
  85 ; CHECK-LABEL: loadStructOfA
  86 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds { %A }, { %A }* %sa.ptr, i64 0, i32 0, i32 0
  87 ; CHECK-NEXT: [[LOAD:%[a-z0-9\.]+]] = load %A__vtbl*, %A__vtbl** [[GEP]], align 8
  88 ; CHECK-NEXT: [[IV1:%[a-z0-9\.]+]] = insertvalue %A undef, %A__vtbl* [[LOAD]], 0
  89 ; CHECK-NEXT: [[IV2:%[a-z0-9\.]+]] = insertvalue { %A } undef, %A [[IV1]], 0
  90 ; CHECK-NEXT: ret { %A } [[IV2]]
  91   %1 = load { %A }, { %A }* %sa.ptr, align 8
  92   ret { %A } %1
  93 }
  94
  95 define [1 x %A] @loadArrayOfA([1 x %A]* %aa.ptr) {
  96 ; CHECK-LABEL: loadArrayOfA
  97 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds [1 x %A], [1 x %A]* %aa.ptr, i64 0, i64 0, i32 0
  98 ; CHECK-NEXT: [[LOAD:%[a-z0-9\.]+]] = load %A__vtbl*, %A__vtbl** [[GEP]], align 8
  99 ; CHECK-NEXT: [[IV1:%[a-z0-9\.]+]] = insertvalue %A undef, %A__vtbl* [[LOAD]], 0
 100 ; CHECK-NEXT: [[IV2:%[a-z0-9\.]+]] = insertvalue [1 x %A] undef, %A [[IV1]], 0
 101 ; CHECK-NEXT: ret [1 x %A] [[IV2]]
 102   %1 = load [1 x %A], [1 x %A]* %aa.ptr, align 8
 103   ret [1 x %A] %1
 104 }
 105
 106 define { [1 x %A] } @loadStructOfArrayOfA({ [1 x %A] }* %saa.ptr) {
 107 ; CHECK-LABEL: loadStructOfArrayOfA
 108 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds { [1 x %A] }, { [1 x %A] }* %saa.ptr, i64 0, i32 0, i64 0, i32 0
 109 ; CHECK-NEXT: [[LOAD:%[a-z0-9\.]+]] = load %A__vtbl*, %A__vtbl** [[GEP]], align 8
 110 ; CHECK-NEXT: [[IV1:%[a-z0-9\.]+]] = insertvalue %A undef, %A__vtbl* [[LOAD]], 0
 111 ; CHECK-NEXT: [[IV2:%[a-z0-9\.]+]] = insertvalue [1 x %A] undef, %A [[IV1]], 0
 112 ; CHECK-NEXT: [[IV3:%[a-z0-9\.]+]] = insertvalue { [1 x %A] } undef, [1 x %A] [[IV2]], 0
 113 ; CHECK-NEXT: ret { [1 x %A] } [[IV3]]
 114   %1 = load { [1 x %A] }, { [1 x %A] }* %saa.ptr, align 8
 115   ret { [1 x %A] } %1
 116 }
 117
 118 define { %A } @structOfA({ %A }* %sa.ptr) {
 119 ; CHECK-LABEL: structOfA
 120 ; CHECK-NEXT: [[GEP:%[a-z0-9\.]+]] = getelementptr inbounds { %A }, { %A }* %sa.ptr, i64 0, i32 0, i32 0
 121 ; CHECK-NEXT: store %A__vtbl* @A__vtblZ, %A__vtbl** [[GEP]], align 8
 122 ; CHECK-NEXT: ret { %A } { %A { %A__vtbl* @A__vtblZ } }
 123   store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %sa.ptr, align 8
 124   %1 = load { %A }, { %A }* %sa.ptr, align 8
 125   ret { %A } %1
 126 }
 127
 128 define %B @structB(%B* %b.ptr) {
 129 ; CHECK-LABEL: structB
 130 ; CHECK-NEXT: [[GEP1:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 0
 131 ; CHECK-NEXT: store i8* null, i8** [[GEP1]], align 8
 132 ; CHECK-NEXT: [[GEP2:%[a-z0-9\.]+]] = getelementptr inbounds %B, %B* %b.ptr, i64 0, i32 1
 133 ; CHECK-NEXT: store i64 42, i64* [[GEP2]], align 8
 134 ; CHECK-NEXT: ret %B { i8* null, i64 42 }
 135   store %B { i8* null, i64 42 }, %B* %b.ptr, align 8
 136   %1 = load %B, %B* %b.ptr, align 8
 137   ret %B %1
 138 }