test/Transforms/InstCombine/getelementptr.ll

   1 ; RUN: llvm-as < %s | opt -instcombine | llvm-dis | FileCheck %s
   2
   3 target datalayout = "e-p:64:64"
   4
   5 %pair = type { i32, i32 }
   6 %struct.B = type { double }
   7 %struct.A = type { %struct.B, i32, i32 }
   8
   9
  10 @Global = constant [10 x i8] c"helloworld"
  11
  12 ; Test noop elimination
  13 define i32* @test1(i32* %I) {
  14         %A = getelementptr i32* %I, i64 0
  15         ret i32* %A
  16 ; CHECK: @test1
  17 ; CHECK: ret i32* %I
  18 }
  19
  20 ; Test noop elimination
  21 define i32* @test2(i32* %I) {
  22         %A = getelementptr i32* %I
  23         ret i32* %A
  24 ; CHECK: @test2
  25 ; CHECK: ret i32* %I
  26 }
  27
  28 ; Test that two array indexing geps fold
  29 define i32* @test3(i32* %I) {
  30         %A = getelementptr i32* %I, i64 17
  31         %B = getelementptr i32* %A, i64 4
  32         ret i32* %B
  33 ; CHECK: @test3
  34 ; CHECK: getelementptr i32* %I, i64 21
  35 }
  36
  37 ; Test that two getelementptr insts fold
  38 define i32* @test4({ i32 }* %I) {
  39         %A = getelementptr { i32 }* %I, i64 1
  40         %B = getelementptr { i32 }* %A, i64 0, i32 0
  41         ret i32* %B
  42 ; CHECK: @test4
  43 ; CHECK: getelementptr %0* %I, i64 1, i32 0
  44 }
  45
  46 define void @test5(i8 %B) {
  47         ; This should be turned into a constexpr instead of being an instruction
  48         %A = getelementptr [10 x i8]* @Global, i64 0, i64 4
  49         store i8 %B, i8* %A
  50         ret void
  51 ; CHECK: @test5
  52 ; CHECK: store i8 %B, i8* getelementptr inbounds ([10 x i8]* @Global, i64 0, i64 4)
  53 }
  54
  55 define i32* @test6() {
  56         %M = malloc [4 x i32]
  57         %A = getelementptr [4 x i32]* %M, i64 0, i64 0
  58         %B = getelementptr i32* %A, i64 2
  59         ret i32* %B
  60 ; CHECK: @test6
  61 ; CHECK: getelementptr [4 x i32]* %M, i64 0, i64 2
  62 }
  63
  64 define i32* @test7(i32* %I, i64 %C, i64 %D) {
  65         %A = getelementptr i32* %I, i64 %C              ; <i32*> [#uses=1]
  66         %B = getelementptr i32* %A, i64 %D              ; <i32*> [#uses=1]
  67         ret i32* %B
  68 ; CHECK: @test7
  69 ; CHECK: %A.sum = add i64 %C, %D
  70 ; CHECK: getelementptr i32* %I, i64 %A.sum
  71 }
  72
  73 define i8* @test8([10 x i32]* %X) {
  74         ;; Fold into the cast.
  75         %A = getelementptr [10 x i32]* %X, i64 0, i64 0         ; <i32*> [#uses=1]
  76         %B = bitcast i32* %A to i8*             ; <i8*> [#uses=1]
  77         ret i8* %B
  78 ; CHECK: @test8
  79 ; CHECK: bitcast [10 x i32]* %X to i8*
  80 }
  81
  82 define i32 @test9() {
  83         %A = getelementptr { i32, double }* null, i32 0, i32 1          ; <double*> [#uses=1]
  84         %B = ptrtoint double* %A to i32         ; <i32> [#uses=1]
  85         ret i32 %B
  86 ; CHECK: @test9
  87 ; CHECK: ret i32 8
  88 }
  89
  90 define i1 @test10({ i32, i32 }* %x, { i32, i32 }* %y) {
  91         %tmp.1 = getelementptr { i32, i32 }* %x, i32 0, i32 1           ; <i32*> [#uses=1]
  92         %tmp.3 = getelementptr { i32, i32 }* %y, i32 0, i32 1           ; <i32*> [#uses=1]
  93         ;; seteq x, y
  94         %tmp.4 = icmp eq i32* %tmp.1, %tmp.3            ; <i1> [#uses=1]
  95         ret i1 %tmp.4
  96 ; CHECK: @test10
  97 ; CHECK: icmp eq %pair* %x, %y
  98 }
  99
 100 define i1 @test11({ i32, i32 }* %X) {
 101         %P = getelementptr { i32, i32 }* %X, i32 0, i32 0               ; <i32*> [#uses=1]
 102         %Q = icmp eq i32* %P, null              ; <i1> [#uses=1]
 103         ret i1 %Q
 104 ; CHECK: @test11
 105 ; CHECK: icmp eq %pair* %X, null
 106 }
 107
 108
 109 ; PR4748
 110 define i32 @test12(%struct.A* %a) {
 111 entry:
 112   %g3 = getelementptr %struct.A* %a, i32 0, i32 1
 113   store i32 10, i32* %g3, align 4
 114
 115   %g4 = getelementptr %struct.A* %a, i32 0, i32 0
 116
 117   %new_a = bitcast %struct.B* %g4 to %struct.A*
 118
 119   %g5 = getelementptr %struct.A* %new_a, i32 0, i32 1
 120   %a_a = load i32* %g5, align 4
 121   ret i32 %a_a
 122 ; CHECK:      @test12
 123 ; CHECK:      getelementptr %struct.A* %a, i64 0, i32 1
 124 ; CHECK-NEXT: store i32 10, i32* %g3
 125 ; CHECK-NEXT: ret i32 10
 126 }
 127
 128
 129 ; PR2235
 130 %S = type { i32, [ 100 x i32] }
 131 define i1 @test13(i64 %X, %S* %P) {
 132         %A = getelementptr inbounds %S* %P, i32 0, i32 1, i64 %X
 133         %B = getelementptr inbounds %S* %P, i32 0, i32 0
 134         %C = icmp eq i32* %A, %B
 135         ret i1 %C
 136 ; CHECK: @test13
 137 ; CHECK:    %C = icmp eq i64 %X, -1
 138 }
 139
 140
 141 @G = external global [3 x i8]           ; <[3 x i8]*> [#uses=1]
 142 define i8* @test14(i32 %Idx) {
 143         %idx = zext i32 %Idx to i64             ; <i64> [#uses=1]
 144         %tmp = getelementptr i8* getelementptr ([3 x i8]* @G, i32 0, i32 0), i64 %idx
 145         ret i8* %tmp
 146 ; CHECK: @test14
 147 ; CHECK: getelementptr [3 x i8]* @G, i64 0, i64 %idx
 148 }
 149
 150
 151 ; Test folding of constantexpr geps into normal geps.
 152 @Array = external global [40 x i32]             ; <[40 x i32]*> [#uses=2]
 153 define i32 *@test15(i64 %X) {
 154         %A = getelementptr i32* getelementptr ([40 x i32]* @Array, i64 0, i64 0), i64 %X
 155         ret i32* %A
 156 ; CHECK: @test15
 157 ; CHECK: getelementptr [40 x i32]* @Array, i64 0, i64 %X
 158 }
 159
 160
 161 define i32* @test16(i32* %X, i32 %Idx) {
 162         %R = getelementptr i32* %X, i32 %Idx
 163         ret i32* %R
 164 ; CHECK: @test16
 165 ; CHECK: sext i32 %Idx to i64
 166 }
 167
 168
 169 define i1 @test17(i16* %P, i32 %I, i32 %J) {
 170         %X = getelementptr inbounds i16* %P, i32 %I
 171         %Y = getelementptr inbounds i16* %P, i32 %J
 172         %C = icmp ult i16* %X, %Y
 173         ret i1 %C
 174 ; CHECK: @test17
 175 ; CHECK: %C = icmp slt i32 %I, %J
 176 }
 177
 178 define i1 @test18(i16* %P, i32 %I) {
 179         %X = getelementptr inbounds i16* %P, i32 %I
 180         %C = icmp ult i16* %X, %P
 181         ret i1 %C
 182 ; CHECK: @test18
 183 ; CHECK: %C = icmp slt i32 %I, 0
 184 }
 185
 186 define i32 @test19(i32* %P, i32 %A, i32 %B) {
 187         %tmp.4 = getelementptr inbounds i32* %P, i32 %A
 188         %tmp.9 = getelementptr inbounds i32* %P, i32 %B
 189         %tmp.10 = icmp eq i32* %tmp.4, %tmp.9
 190         %tmp.11 = zext i1 %tmp.10 to i32
 191         ret i32 %tmp.11
 192 ; CHECK: @test19
 193 ; CHECK: icmp eq i32 %A, %B
 194 }
 195
 196 define i32 @test20(i32* %P, i32 %A, i32 %B) {
 197         %tmp.4 = getelementptr inbounds i32* %P, i32 %A
 198         %tmp.6 = icmp eq i32* %tmp.4, %P
 199         %tmp.7 = zext i1 %tmp.6 to i32
 200         ret i32 %tmp.7
 201 ; CHECK: @test20
 202 ; CHECK: icmp eq i32 %A, 0
 203 }
 204
 205
 206