Home | History | Annotate | Download | only in InstCombine
      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 }
    139