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
   9 @A__vtblZ = constant %A__vtbl { i8* null, i32 (%A*)* @A.foo }
  10
  11 declare i32 @A.foo(%A* nocapture %this)
  12
  13 declare i8* @allocmemory(i64)
  14
  15 define void @storeA() {
  16 body:
  17   %0 = tail call i8* @allocmemory(i64 32)
  18   %1 = bitcast i8* %0 to %A*
  19 ; CHECK-LABEL: storeA
  20 ; CHECK: store %A__vtbl* @A__vtblZ
  21   store %A { %A__vtbl* @A__vtblZ }, %A* %1, align 8
  22   ret void
  23 }
  24
  25 define void @storeStructOfA() {
  26 body:
  27   %0 = tail call i8* @allocmemory(i64 32)
  28   %1 = bitcast i8* %0 to { %A }*
  29 ; CHECK-LABEL: storeStructOfA
  30 ; CHECK: store %A__vtbl* @A__vtblZ
  31   store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %1, align 8
  32   ret void
  33 }
  34
  35 define void @storeArrayOfA() {
  36 body:
  37   %0 = tail call i8* @allocmemory(i64 32)
  38   %1 = bitcast i8* %0 to [1 x %A]*
  39 ; CHECK-LABEL: storeArrayOfA
  40 ; CHECK: store %A__vtbl* @A__vtblZ
  41   store [1 x %A] [%A { %A__vtbl* @A__vtblZ }], [1 x %A]* %1, align 8
  42   ret void
  43 }
  44
  45 define void @storeStructOfArrayOfA() {
  46 body:
  47   %0 = tail call i8* @allocmemory(i64 32)
  48   %1 = bitcast i8* %0 to { [1 x %A] }*
  49 ; CHECK-LABEL: storeStructOfArrayOfA
  50 ; CHECK: store %A__vtbl* @A__vtblZ
  51   store { [1 x %A] } { [1 x %A] [%A { %A__vtbl* @A__vtblZ }] }, { [1 x %A] }* %1, align 8
  52   ret void
  53 }
  54
  55 define %A @loadA() {
  56 body:
  57   %0 = tail call i8* @allocmemory(i64 32)
  58   %1 = bitcast i8* %0 to %A*
  59 ; CHECK-LABEL: loadA
  60 ; CHECK: load %A__vtbl*,
  61 ; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
  62   %2 = load %A, %A* %1, align 8
  63   ret %A %2
  64 }
  65
  66 define { %A } @loadStructOfA() {
  67 body:
  68   %0 = tail call i8* @allocmemory(i64 32)
  69   %1 = bitcast i8* %0 to { %A }*
  70 ; CHECK-LABEL: loadStructOfA
  71 ; CHECK: load %A__vtbl*,
  72 ; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
  73 ; CHECK: insertvalue { %A } undef, %A {{.*}}, 0
  74   %2 = load { %A }, { %A }* %1, align 8
  75   ret { %A } %2
  76 }
  77
  78 define [1 x %A] @loadArrayOfA() {
  79 body:
  80   %0 = tail call i8* @allocmemory(i64 32)
  81   %1 = bitcast i8* %0 to [1 x %A]*
  82 ; CHECK-LABEL: loadArrayOfA
  83 ; CHECK: load %A__vtbl*,
  84 ; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
  85 ; CHECK: insertvalue [1 x %A] undef, %A {{.*}}, 0
  86   %2 = load [1 x %A], [1 x %A]* %1, align 8
  87   ret [1 x %A] %2
  88 }
  89
  90 define { [1 x %A] } @loadStructOfArrayOfA() {
  91 body:
  92   %0 = tail call i8* @allocmemory(i64 32)
  93   %1 = bitcast i8* %0 to { [1 x %A] }*
  94 ; CHECK-LABEL: loadStructOfArrayOfA
  95 ; CHECK: load %A__vtbl*,
  96 ; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
  97 ; CHECK: insertvalue [1 x %A] undef, %A {{.*}}, 0
  98 ; CHECK: insertvalue { [1 x %A] } undef, [1 x %A] {{.*}}, 0
  99   %2 = load { [1 x %A] }, { [1 x %A] }* %1, align 8
 100   ret { [1 x %A] } %2
 101 }
 102
 103 define { %A } @structOfA() {
 104 body:
 105   %0 = tail call i8* @allocmemory(i64 32)
 106   %1 = bitcast i8* %0 to { %A }*
 107 ; CHECK-LABEL: structOfA
 108 ; CHECK: store %A__vtbl* @A__vtblZ
 109   store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %1, align 8
 110   %2 = load { %A }, { %A }* %1, align 8
 111 ; CHECK-NOT: load
 112 ; CHECK: ret { %A } { %A { %A__vtbl* @A__vtblZ } }
 113   ret { %A } %2
 114 }