llvm/test/Transforms/InstCombine/memrchr-3.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
   3 ;
   4 ; Verify that memrchr calls with one or more constant arguments are folded
   5 ; as expected.
   6
   7 declare ptr @memrchr(ptr, i32, i64)
   8
   9 @ax = external global [0 x i8]
  10 @a12345 = constant [5 x i8] c"\01\02\03\04\05"
  11 @a123123 = constant [6 x i8] c"\01\02\03\01\02\03"
  12
  13
  14 ; Fold memrchr(ax, C, 0) to null.
  15
  16 define ptr @fold_memrchr_ax_c_0(i32 %C) {
  17 ; CHECK-LABEL: @fold_memrchr_ax_c_0(
  18 ; CHECK-NEXT:    ret ptr null
  19 ;
  20
  21   %ret = call ptr @memrchr(ptr @ax, i32 %C, i64 0)
  22   ret ptr %ret
  23 }
  24
  25
  26 ; Fold memrchr(a12345, 3, 0) to null.
  27
  28 define ptr @fold_memrchr_a12345_3_0() {
  29 ; CHECK-LABEL: @fold_memrchr_a12345_3_0(
  30 ; CHECK-NEXT:    ret ptr null
  31 ;
  32
  33   %ret = call ptr @memrchr(ptr @a12345, i32 3, i64 0)
  34   ret ptr %ret
  35 }
  36
  37
  38 ; Fold memrchr(a12345, 1, 1) to a12345.
  39
  40 define ptr @fold_memrchr_a12345_1_1() {
  41 ; CHECK-LABEL: @fold_memrchr_a12345_1_1(
  42 ; CHECK-NEXT:    ret ptr @a12345
  43 ;
  44   %ret = call ptr @memrchr(ptr @a12345, i32 1, i64 1)
  45   ret ptr %ret
  46 }
  47
  48
  49 ; Fold memrchr(a12345, 5, 1) to null.
  50
  51 define ptr @fold_memrchr_a12345_5_1() {
  52 ; CHECK-LABEL: @fold_memrchr_a12345_5_1(
  53 ; CHECK-NEXT:    ret ptr null
  54 ;
  55   %ret = call ptr @memrchr(ptr @a12345, i32 5, i64 1)
  56   ret ptr %ret
  57 }
  58
  59
  60 ; Fold memrchr(a123123, 1, 1) to a123123.
  61
  62 define ptr @fold_memrchr_a123123_1_1() {
  63 ; CHECK-LABEL: @fold_memrchr_a123123_1_1(
  64 ; CHECK-NEXT:    ret ptr @a123123
  65 ;
  66   %ret = call ptr @memrchr(ptr @a123123, i32 1, i64 1)
  67   ret ptr %ret
  68 }
  69
  70
  71 ; Fold memrchr(a123123, 3, 1) to null.
  72
  73 define ptr @fold_memrchr_a123123_3_1() {
  74 ; CHECK-LABEL: @fold_memrchr_a123123_3_1(
  75 ; CHECK-NEXT:    ret ptr null
  76 ;
  77   %ret = call ptr @memrchr(ptr @a123123, i32 3, i64 1)
  78   ret ptr %ret
  79 }
  80
  81
  82 ; Fold memrchr(ax, C, 1) to *ax == C ? ax : null.
  83
  84 define ptr @fold_memrchr_ax_c_1(i32 %C) {
  85 ; CHECK-LABEL: @fold_memrchr_ax_c_1(
  86 ; CHECK-NEXT:    [[MEMRCHR_CHAR0:%.*]] = load i8, ptr @ax, align 1
  87 ; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[C:%.*]] to i8
  88 ; CHECK-NEXT:    [[MEMRCHR_CHAR0CMP:%.*]] = icmp eq i8 [[MEMRCHR_CHAR0]], [[TMP1]]
  89 ; CHECK-NEXT:    [[MEMRCHR_SEL:%.*]] = select i1 [[MEMRCHR_CHAR0CMP]], ptr @ax, ptr null
  90 ; CHECK-NEXT:    ret ptr [[MEMRCHR_SEL]]
  91 ;
  92   %ret = call ptr @memrchr(ptr @ax, i32 %C, i64 1)
  93   ret ptr %ret
  94 }
  95
  96
  97 ; Fold memrchr(a12345, 5, 5) to a12345 + 4.
  98
  99 define ptr @fold_memrchr_a12345_5_5() {
 100 ; CHECK-LABEL: @fold_memrchr_a12345_5_5(
 101 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a12345, i64 4)
 102 ;
 103
 104   %ret = call ptr @memrchr(ptr @a12345, i32 5, i64 5)
 105   ret ptr %ret
 106 }
 107
 108
 109 ; Fold memrchr(a12345, 5, 4) to null.
 110
 111 define ptr @fold_memrchr_a12345_5_4() {
 112 ; CHECK-LABEL: @fold_memrchr_a12345_5_4(
 113 ; CHECK-NEXT:    ret ptr null
 114 ;
 115
 116   %ret = call ptr @memrchr(ptr @a12345, i32 5, i64 4)
 117   ret ptr %ret
 118 }
 119
 120
 121 ; Fold memrchr(a12345, 4, 5) to a12345 + 3.
 122
 123 define ptr @fold_memrchr_a12345_4_5() {
 124 ; CHECK-LABEL: @fold_memrchr_a12345_4_5(
 125 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a12345, i64 3)
 126 ;
 127
 128   %ret = call ptr @memrchr(ptr @a12345, i32 4, i64 5)
 129   ret ptr %ret
 130 }
 131
 132
 133 ; Fold memrchr(a12345 + 1, 1, 4) to null.
 134
 135 define ptr @fold_memrchr_a12345p1_1_4() {
 136 ; CHECK-LABEL: @fold_memrchr_a12345p1_1_4(
 137 ; CHECK-NEXT:    ret ptr null
 138 ;
 139
 140   %ptr = getelementptr [5 x i8], ptr @a12345, i32 0, i32 1
 141   %ret = call ptr @memrchr(ptr %ptr, i32 1, i64 4)
 142   ret ptr %ret
 143 }
 144
 145
 146 ; Fold memrchr(a12345 + 1, 2, 4) to a12345 + 1.
 147
 148 define ptr @fold_memrchr_a12345p1_2_4() {
 149 ; CHECK-LABEL: @fold_memrchr_a12345p1_2_4(
 150 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a12345, i64 1)
 151 ;
 152
 153   %ptr = getelementptr [5 x i8], ptr @a12345, i32 0, i32 1
 154   %ret = call ptr @memrchr(ptr %ptr, i32 2, i64 4)
 155   ret ptr %ret
 156 }
 157
 158
 159 ; Fold memrchr(a12345, 2, 5) to a12345 + 1.
 160
 161 define ptr @fold_memrchr_a12345_2_5() {
 162 ; CHECK-LABEL: @fold_memrchr_a12345_2_5(
 163 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a12345, i64 1)
 164 ;
 165
 166   %ret = call ptr @memrchr(ptr @a12345, i32 2, i64 5)
 167   ret ptr %ret
 168 }
 169
 170
 171 ; Fold memrchr(a12345, 0, %N) to null.
 172
 173 define ptr @fold_memrchr_a12345_0_n(i64 %N) {
 174 ; CHECK-LABEL: @fold_memrchr_a12345_0_n(
 175 ; CHECK-NEXT:    ret ptr null
 176 ;
 177
 178   %ret = call ptr @memrchr(ptr @a12345, i32 0, i64 %N)
 179   ret ptr %ret
 180 }
 181
 182
 183 ; Fold memrchr(a12345, 3, n) to n < 3 ? null : s + 2.
 184
 185 define ptr @fold_memrchr_a12345_3_n(i64 %n) {
 186 ; CHECK-LABEL: @fold_memrchr_a12345_3_n(
 187 ; CHECK-NEXT:    [[MEMRCHR_CMP:%.*]] = icmp ult i64 [[N:%.*]], 3
 188 ; CHECK-NEXT:    [[MEMRCHR_SEL:%.*]] = select i1 [[MEMRCHR_CMP]], ptr null, ptr getelementptr inbounds (i8, ptr @a12345, i64 2)
 189 ; CHECK-NEXT:    ret ptr [[MEMRCHR_SEL]]
 190 ;
 191
 192   %ret = call ptr @memrchr(ptr @a12345, i32 3, i64 %n)
 193   ret ptr %ret
 194 }
 195
 196
 197 ; Fold memrchr(a12345, 5, n) to n < 5 ? null : s + 4.
 198
 199 define ptr @fold_memrchr_a12345_5_n(i64 %n) {
 200 ; CHECK-LABEL: @fold_memrchr_a12345_5_n(
 201 ; CHECK-NEXT:    [[MEMRCHR_CMP:%.*]] = icmp ult i64 [[N:%.*]], 5
 202 ; CHECK-NEXT:    [[MEMRCHR_SEL:%.*]] = select i1 [[MEMRCHR_CMP]], ptr null, ptr getelementptr inbounds (i8, ptr @a12345, i64 4)
 203 ; CHECK-NEXT:    ret ptr [[MEMRCHR_SEL]]
 204 ;
 205
 206   %ret = call ptr @memrchr(ptr @a12345, i32 5, i64 %n)
 207   ret ptr %ret
 208 }
 209
 210
 211 ; Fold memrchr(a123123, 3, 5) to a123123 + 2.
 212
 213 define ptr @fold_memrchr_a123123_3_5() {
 214 ; CHECK-LABEL: @fold_memrchr_a123123_3_5(
 215 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a123123, i64 2)
 216 ;
 217
 218   %ret = call ptr @memrchr(ptr @a123123, i32 3, i64 5)
 219   ret ptr %ret
 220 }
 221
 222
 223 ; Fold memrchr(a123123, 3, 6) to a123123 + 5.
 224
 225 define ptr @fold_memrchr_a123123_3_6() {
 226 ; CHECK-LABEL: @fold_memrchr_a123123_3_6(
 227 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a123123, i64 5)
 228 ;
 229
 230   %ret = call ptr @memrchr(ptr @a123123, i32 3, i64 6)
 231   ret ptr %ret
 232 }
 233
 234 ; Fold memrchr(a123123, 2, 6) to a123123 + 4.
 235
 236 define ptr @fold_memrchr_a123123_2_6() {
 237 ; CHECK-LABEL: @fold_memrchr_a123123_2_6(
 238 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a123123, i64 4)
 239 ;
 240
 241   %ret = call ptr @memrchr(ptr @a123123, i32 2, i64 6)
 242   ret ptr %ret
 243 }
 244
 245 ; Fold memrchr(a123123, 1, 6) to a123123 + 3.
 246
 247 define ptr @fold_memrchr_a123123_1_6() {
 248 ; CHECK-LABEL: @fold_memrchr_a123123_1_6(
 249 ; CHECK-NEXT:    ret ptr getelementptr inbounds (i8, ptr @a123123, i64 3)
 250 ;
 251
 252   %ret = call ptr @memrchr(ptr @a123123, i32 1, i64 6)
 253   ret ptr %ret
 254 }
 255
 256
 257 ; Fold memrchr(a123123, 0, 6) to null.
 258
 259 define ptr @fold_memrchr_a123123_0_6() {
 260 ; CHECK-LABEL: @fold_memrchr_a123123_0_6(
 261 ; CHECK-NEXT:    ret ptr null
 262 ;
 263
 264   %ret = call ptr @memrchr(ptr @a123123, i32 0, i64 6)
 265   ret ptr %ret
 266 }
 267
 268
 269 ; Fold memrchr(a123123, 0, n) to null
 270
 271 define ptr @fold_memrchr_a123123_0_n(i64 %n) {
 272 ; CHECK-LABEL: @fold_memrchr_a123123_0_n(
 273 ; CHECK-NEXT:    ret ptr null
 274 ;
 275
 276   %ret = call ptr @memrchr(ptr @a123123, i32 0, i64 %n)
 277   ret ptr %ret
 278 }
 279
 280
 281 ; Don't fold memrchr(a123123, 3, n) (although it's possible to fold the call
 282 ; for a small number of occurrences of the character greater than one, it's
 283 ; less and less profitable as the number grows).
 284
 285 define ptr @call_memrchr_a123123_3_n(i64 %n) {
 286 ; CHECK-LABEL: @call_memrchr_a123123_3_n(
 287 ; CHECK-NEXT:    [[RET:%.*]] = call ptr @memrchr(ptr nonnull @a123123, i32 3, i64 [[N:%.*]])
 288 ; CHECK-NEXT:    ret ptr [[RET]]
 289 ;
 290
 291   %ret = call ptr @memrchr(ptr @a123123, i32 3, i64 %n)
 292   ret ptr %ret
 293 }
 294
 295
 296 ; Same as above but for 2.
 297
 298 define ptr @call_memrchr_a123123_2_n(i64 %n) {
 299 ; CHECK-LABEL: @call_memrchr_a123123_2_n(
 300 ; CHECK-NEXT:    [[RET:%.*]] = call ptr @memrchr(ptr nonnull @a123123, i32 2, i64 [[N:%.*]])
 301 ; CHECK-NEXT:    ret ptr [[RET]]
 302 ;
 303
 304   %ret = call ptr @memrchr(ptr @a123123, i32 2, i64 %n)
 305   ret ptr %ret
 306 }
 307
 308
 309 ; And again for 1 to exercise the other edge case.
 310
 311 define ptr @call_memrchr_a123123_1_n(i64 %n) {
 312 ; CHECK-LABEL: @call_memrchr_a123123_1_n(
 313 ; CHECK-NEXT:    [[RET:%.*]] = call ptr @memrchr(ptr nonnull @a123123, i32 1, i64 [[N:%.*]])
 314 ; CHECK-NEXT:    ret ptr [[RET]]
 315 ;
 316
 317   %ret = call ptr @memrchr(ptr @a123123, i32 1, i64 %n)
 318   ret ptr %ret
 319 }