llvm/test/Transforms/StraightLineStrengthReduce/slsr-gep.ll

   1 ; RUN: opt < %s -passes=slsr,gvn -S | FileCheck %s
   2 ; RUN: opt < %s -passes='slsr,gvn' -S | FileCheck %s
   3
   4 target datalayout = "e-i64:64-v16:16-v32:32-n16:32:64-p:64:64:64-p1:32:32:32-p2:128:128:128:32"
   5
   6 ; foo(input[0]);
   7 ; foo(input[s]);
   8 ; foo(input[s * 2]);
   9 ;   =>
  10 ; p0 = &input[0];
  11 ; foo(*p);
  12 ; p1 = p0 + s;
  13 ; foo(*p1);
  14 ; p2 = p1 + s;
  15 ; foo(*p2);
  16 define void @slsr_gep(ptr %input, i64 %s) {
  17 ; CHECK-LABEL: @slsr_gep(
  18   ; v0 = input[0];
  19   call void @foo(ptr %input)
  20
  21   ; v1 = input[s];
  22   %p1 = getelementptr inbounds i32, ptr %input, i64 %s
  23 ; CHECK: %p1 = getelementptr inbounds i32, ptr %input, i64 %s
  24   call void @foo(ptr %p1)
  25
  26   ; v2 = input[s * 2];
  27   %s2 = shl nsw i64 %s, 1
  28   %p2 = getelementptr inbounds i32, ptr %input, i64 %s2
  29 ; CHECK: %p2 = getelementptr inbounds i32, ptr %p1, i64 %s
  30   call void @foo(ptr %p2)
  31
  32   ret void
  33 }
  34
  35 ; foo(input[0]);
  36 ; foo(input[(long)s]);
  37 ; foo(input[(long)(s * 2)]);
  38 ;   =>
  39 ; p0 = &input[0];
  40 ; foo(*p);
  41 ; p1 = p0 + (long)s;
  42 ; foo(*p1);
  43 ; p2 = p1 + (long)s;
  44 ; foo(*p2);
  45 define void @slsr_gep_sext(ptr %input, i32 %s) {
  46 ; CHECK-LABEL: @slsr_gep_sext(
  47   ; v0 = input[0];
  48   call void @foo(ptr %input)
  49
  50   ; v1 = input[s];
  51   %t = sext i32 %s to i64
  52   %p1 = getelementptr inbounds i32, ptr %input, i64 %t
  53 ; CHECK: %p1 = getelementptr inbounds i32, ptr %input, i64 %t
  54   call void @foo(ptr %p1)
  55
  56   ; v2 = input[s * 2];
  57   %s2 = shl nsw i32 %s, 1
  58   %t2 = sext i32 %s2 to i64
  59   %p2 = getelementptr inbounds i32, ptr %input, i64 %t2
  60 ; CHECK: %p2 = getelementptr inbounds i32, ptr %p1, i64 %t
  61   call void @foo(ptr %p2)
  62
  63   ret void
  64 }
  65
  66 ; int input[10][5];
  67 ; foo(input[s][t]);
  68 ; foo(input[s * 2][t]);
  69 ; foo(input[s * 3][t]);
  70 ;   =>
  71 ; p0 = &input[s][t];
  72 ; foo(*p0);
  73 ; p1 = p0 + 5s;
  74 ; foo(*p1);
  75 ; p2 = p1 + 5s;
  76 ; foo(*p2);
  77 define void @slsr_gep_2d(ptr %input, i64 %s, i64 %t) {
  78 ; CHECK-LABEL: @slsr_gep_2d(
  79   ; v0 = input[s][t];
  80   %p0 = getelementptr inbounds [10 x [5 x i32]], ptr %input, i64 0, i64 %s, i64 %t
  81   call void @foo(ptr %p0)
  82
  83   ; v1 = input[s * 2][t];
  84   %s2 = shl nsw i64 %s, 1
  85 ; CHECK: [[BUMP:%[a-zA-Z0-9]+]] = mul i64 %s, 5
  86   %p1 = getelementptr inbounds [10 x [5 x i32]], ptr %input, i64 0, i64 %s2, i64 %t
  87 ; CHECK: %p1 = getelementptr inbounds i32, ptr %p0, i64 [[BUMP]]
  88   call void @foo(ptr %p1)
  89
  90   ; v3 = input[s * 3][t];
  91   %s3 = mul nsw i64 %s, 3
  92   %p2 = getelementptr inbounds [10 x [5 x i32]], ptr %input, i64 0, i64 %s3, i64 %t
  93 ; CHECK: %p2 = getelementptr inbounds i32, ptr %p1, i64 [[BUMP]]
  94   call void @foo(ptr %p2)
  95
  96   ret void
  97 }
  98
  99 %struct.S = type <{ i64, i32 }>
 100
 101 ; In this case, the bump
 102 ;     = (char *)&input[s * 2][t].f1 - (char *)&input[s][t].f1
 103 ;     = 60 * s
 104 ; which may not be divisible by typeof(input[s][t].f1) = 8. Therefore, we
 105 ; rewrite the candidates using byte offset instead of index offset as in
 106 ; @slsr_gep_2d.
 107 define void @slsr_gep_uglygep(ptr %input, i64 %s, i64 %t) {
 108 ; CHECK-LABEL: @slsr_gep_uglygep(
 109   ; v0 = input[s][t].f1;
 110   %p0 = getelementptr inbounds [10 x [5 x %struct.S]], ptr %input, i64 0, i64 %s, i64 %t, i32 0
 111   call void @bar(ptr %p0)
 112
 113   ; v1 = input[s * 2][t].f1;
 114   %s2 = shl nsw i64 %s, 1
 115 ; CHECK: [[BUMP:%[a-zA-Z0-9]+]] = mul i64 %s, 60
 116   %p1 = getelementptr inbounds [10 x [5 x %struct.S]], ptr %input, i64 0, i64 %s2, i64 %t, i32 0
 117 ; CHECK: %p1 = getelementptr inbounds i8, ptr %p0, i64 [[BUMP]]
 118   call void @bar(ptr %p1)
 119
 120   ; v2 = input[s * 3][t].f1;
 121   %s3 = mul nsw i64 %s, 3
 122   %p2 = getelementptr inbounds [10 x [5 x %struct.S]], ptr %input, i64 0, i64 %s3, i64 %t, i32 0
 123 ; CHECK: %p2 = getelementptr inbounds i8, ptr %p1, i64 [[BUMP]]
 124   call void @bar(ptr %p2)
 125
 126   ret void
 127 }
 128
 129 define void @slsr_out_of_bounds_gep(ptr %input, i32 %s) {
 130 ; CHECK-LABEL: @slsr_out_of_bounds_gep(
 131   ; v0 = input[0];
 132   call void @foo(ptr %input)
 133
 134   ; v1 = input[(long)s];
 135   %t = sext i32 %s to i64
 136   %p1 = getelementptr i32, ptr %input, i64 %t
 137 ; CHECK: %p1 = getelementptr i32, ptr %input, i64 %t
 138   call void @foo(ptr %p1)
 139
 140   ; v2 = input[(long)(s * 2)];
 141   %s2 = shl nsw i32 %s, 1
 142   %t2 = sext i32 %s2 to i64
 143   %p2 = getelementptr i32, ptr %input, i64 %t2
 144 ; CHECK: %p2 = getelementptr i32, ptr %p1, i64 %t
 145   call void @foo(ptr %p2)
 146
 147   ret void
 148 }
 149
 150 define void @slsr_gep_128bit_index(ptr %input, i128 %s) {
 151 ; CHECK-LABEL: @slsr_gep_128bit_index(
 152   ; p0 = &input[0]
 153   call void @foo(ptr %input)
 154
 155   ; p1 = &input[s << 125]
 156   %s125 = shl nsw i128 %s, 125
 157   %p1 = getelementptr inbounds i32, ptr %input, i128 %s125
 158 ; CHECK: %p1 = getelementptr inbounds i32, ptr %input, i128 %s125
 159   call void @foo(ptr %p1)
 160
 161   ; p2 = &input[s << 126]
 162   %s126 = shl nsw i128 %s, 126
 163   %p2 = getelementptr inbounds i32, ptr %input, i128 %s126
 164 ; CHECK: %p2 = getelementptr inbounds i32, ptr %input, i128 %s126
 165   call void @foo(ptr %p2)
 166
 167   ret void
 168 }
 169
 170 define void @slsr_gep_32bit_pointer(ptr addrspace(1) %input, i64 %s) {
 171 ; CHECK-LABEL: @slsr_gep_32bit_pointer(
 172   ; p1 = &input[s]
 173   %p1 = getelementptr inbounds i32, ptr addrspace(1) %input, i64 %s
 174   call void @baz(ptr addrspace(1) %p1)
 175
 176   ; p2 = &input[s * 2]
 177   %s2 = mul nsw i64 %s, 2
 178   %p2 = getelementptr inbounds i32, ptr addrspace(1) %input, i64 %s2
 179   ; %s2 is wider than the pointer size of addrspace(1), so do not factor it.
 180 ; CHECK: %p2 = getelementptr inbounds i32, ptr addrspace(1) %input, i64 %s2
 181   call void @baz(ptr addrspace(1) %p2)
 182
 183   ret void
 184 }
 185
 186 define void @slsr_gep_fat_pointer(ptr addrspace(2) %input, i32 %s) {
 187   ; p1 = &input[s]
 188   %p1 = getelementptr inbounds i32, ptr addrspace(2) %input, i32 %s
 189   call void @baz2(ptr addrspace(2) %p1)
 190
 191   ; p2 = &input[s * 2]
 192   %s2 = mul nsw i32 %s, 2
 193   %p2 = getelementptr inbounds i32, ptr addrspace(2) %input, i32 %s2
 194 ; CHECK: %p2 = getelementptr inbounds i32, ptr addrspace(2) %p1, i32 %s
 195   ; Use index bitwidth, not pointer size (i128)
 196   call void @baz2(ptr addrspace(2) %p2)
 197
 198   ret void
 199 }
 200
 201
 202 declare void @foo(ptr)
 203 declare void @bar(ptr)
 204 declare void @baz(ptr addrspace(1))
 205 declare void @baz2(ptr addrspace(2))