test/Analysis/MemorySSA/invariant-groups.ll

   1 ; RUN: opt -basicaa -print-memoryssa -verify-memoryssa -analyze < %s 2>&1 | FileCheck %s
   2 ;
   3 ; Currently, MemorySSA doesn't support invariant groups. So, we should ignore
   4 ; launder.invariant.group intrinsics entirely. We'll need to pay attention to
   5 ; them when/if we decide to support invariant groups.
   6
   7 @g = external global i32
   8
   9 define i32 @foo(i32* %a) {
  10 ; CHECK: 1 = MemoryDef(liveOnEntry)
  11 ; CHECK-NEXT: store i32 0
  12   store i32 0, i32* %a, align 4, !invariant.group !0
  13
  14 ; CHECK: 2 = MemoryDef(1)
  15 ; CHECK-NEXT: store i32 1
  16   store i32 1, i32* @g, align 4
  17
  18   %1 = bitcast i32* %a to i8*
  19 ; CHECK:  3 = MemoryDef(2)
  20 ; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  21   %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  22   %a32 = bitcast i8* %a8 to i32*
  23
  24 ; This have to be MemoryUse(2), because we can't skip the barrier based on
  25 ; invariant.group.
  26 ; CHECK: MemoryUse(2)
  27 ; CHECK-NEXT: %2 = load i32
  28   %2 = load i32, i32* %a32, align 4, !invariant.group !0
  29   ret i32 %2
  30 }
  31
  32 define i32 @skipBarrier(i32* %a) {
  33 ; CHECK: 1 = MemoryDef(liveOnEntry)
  34 ; CHECK-NEXT: store i32 0
  35   store i32 0, i32* %a, align 4, !invariant.group !0
  36
  37   %1 = bitcast i32* %a to i8*
  38 ; CHECK: 2 = MemoryDef(1)
  39 ; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  40   %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  41   %a32 = bitcast i8* %a8 to i32*
  42
  43 ; We can skip the barrier only if the "skip" is not based on !invariant.group.
  44 ; CHECK: MemoryUse(1)
  45 ; CHECK-NEXT: %2 = load i32
  46   %2 = load i32, i32* %a32, align 4, !invariant.group !0
  47   ret i32 %2
  48 }
  49
  50 define i32 @skipBarrier2(i32* %a) {
  51
  52 ; CHECK: MemoryUse(liveOnEntry)
  53 ; CHECK-NEXT: %v = load i32
  54   %v = load i32, i32* %a, align 4, !invariant.group !0
  55
  56   %1 = bitcast i32* %a to i8*
  57 ; CHECK: 1 = MemoryDef(liveOnEntry)
  58 ; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  59   %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  60   %a32 = bitcast i8* %a8 to i32*
  61
  62 ; We can skip the barrier only if the "skip" is not based on !invariant.group.
  63 ; CHECK: MemoryUse(liveOnEntry)
  64 ; CHECK-NEXT: %v2 = load i32
  65   %v2 = load i32, i32* %a32, align 4, !invariant.group !0
  66 ; CHECK: 2 = MemoryDef(1)
  67 ; CHECK-NEXT: store i32 1
  68   store i32 1, i32* @g, align 4
  69
  70 ; FIXME: based on invariant.group it should be MemoryUse(liveOnEntry)
  71 ; CHECK: MemoryUse(2)
  72 ; CHECK-NEXT: %v3 = load i32
  73   %v3 = load i32, i32* %a32, align 4, !invariant.group !0
  74   %add = add nsw i32 %v2, %v3
  75   %add2 = add nsw i32 %add, %v
  76   ret i32 %add2
  77 }
  78
  79 define i32 @handleInvariantGroups(i32* %a) {
  80 ; CHECK: 1 = MemoryDef(liveOnEntry)
  81 ; CHECK-NEXT: store i32 0
  82   store i32 0, i32* %a, align 4, !invariant.group !0
  83
  84 ; CHECK: 2 = MemoryDef(1)
  85 ; CHECK-NEXT: store i32 1
  86   store i32 1, i32* @g, align 4
  87   %1 = bitcast i32* %a to i8*
  88 ; CHECK: 3 = MemoryDef(2)
  89 ; CHECK-NEXT: %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  90   %a8 = call i8* @llvm.launder.invariant.group.p0i8(i8* %1)
  91   %a32 = bitcast i8* %a8 to i32*
  92
  93 ; CHECK: MemoryUse(2)
  94 ; CHECK-NEXT: %2 = load i32
  95   %2 = load i32, i32* %a32, align 4, !invariant.group !0
  96
  97 ; CHECK: 4 = MemoryDef(3)
  98 ; CHECK-NEXT: store i32 2
  99   store i32 2, i32* @g, align 4
 100
 101 ; FIXME: This can be changed to MemoryUse(2)
 102 ; CHECK: MemoryUse(4)
 103 ; CHECK-NEXT: %3 = load i32
 104   %3 = load i32, i32* %a32, align 4, !invariant.group !0
 105   %add = add nsw i32 %2, %3
 106   ret i32 %add
 107 }
 108
 109 define i32 @loop(i1 %a) {
 110 entry:
 111   %0 = alloca i32, align 4
 112 ; CHECK: 1 = MemoryDef(liveOnEntry)
 113 ; CHECK-NEXT: store i32 4
 114   store i32 4, i32* %0, !invariant.group !0
 115 ; CHECK: 2 = MemoryDef(1)
 116 ; CHECK-NEXT: call void @clobber
 117   call void @clobber(i32* %0)
 118   br i1 %a, label %Loop.Body, label %Loop.End
 119
 120 Loop.Body:
 121 ; FIXME: MemoryUse(1)
 122 ; CHECK: MemoryUse(2)
 123 ; CHECK-NEXT: %1 = load i32
 124   %1 = load i32, i32* %0, !invariant.group !0
 125   br i1 %a, label %Loop.End, label %Loop.Body
 126
 127 Loop.End:
 128 ; FIXME: MemoryUse(1)
 129 ; CHECK: MemoryUse(2)
 130 ; CHECK-NEXT: %2 = load
 131   %2 = load i32, i32* %0, align 4, !invariant.group !0
 132   br i1 %a, label %Ret, label %Loop.Body
 133
 134 Ret:
 135   ret i32 %2
 136 }
 137
 138 define i8 @loop2(i8* %p) {
 139 entry:
 140 ; CHECK: 1 = MemoryDef(liveOnEntry)
 141 ; CHECK-NEXT: store i8
 142   store i8 4, i8* %p, !invariant.group !0
 143 ; CHECK: 2 = MemoryDef(1)
 144 ; CHECK-NEXT: call void @clobber
 145   call void @clobber8(i8* %p)
 146
 147 ; CHECK: 3 = MemoryDef(2)
 148 ; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 149   %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 150   br i1 undef, label %Loop.Body, label %Loop.End
 151
 152 Loop.Body:
 153 ; 5 = MemoryPhi({entry,3},{Loop.Body,4},{Loop.End,6})
 154 ; CHECK: MemoryUse(6)
 155 ; CHECK-NEXT: %0 = load i8
 156   %0 = load i8, i8* %after, !invariant.group !0
 157
 158 ; FIXME: MemoryUse(1)
 159 ; CHECK: MemoryUse(6)
 160 ; CHECK-NEXT: %1 = load i8
 161   %1 = load i8, i8* %p, !invariant.group !0
 162
 163 ; CHECK: 4 = MemoryDef(6)
 164   store i8 4, i8* %after, !invariant.group !0
 165
 166   br i1 undef, label %Loop.End, label %Loop.Body
 167
 168 Loop.End:
 169 ; 6 = MemoryPhi({entry,3},{Loop.Body,4})
 170 ; CHECK: MemoryUse(5)
 171 ; CHECK-NEXT: %2 = load
 172   %2 = load i8, i8* %after, align 4, !invariant.group !0
 173
 174 ; FIXME: MemoryUse(1)
 175 ; CHECK: MemoryUse(5)
 176 ; CHECK-NEXT: %3 = load
 177   %3 = load i8, i8* %p, align 4, !invariant.group !0
 178   br i1 undef, label %Ret, label %Loop.Body
 179
 180 Ret:
 181   ret i8 %3
 182 }
 183
 184
 185 define i8 @loop3(i8* %p) {
 186 entry:
 187 ; CHECK: 1 = MemoryDef(liveOnEntry)
 188 ; CHECK-NEXT: store i8
 189   store i8 4, i8* %p, !invariant.group !0
 190 ; CHECK: 2 = MemoryDef(1)
 191 ; CHECK-NEXT: call void @clobber
 192   call void @clobber8(i8* %p)
 193
 194 ; CHECK: 3 = MemoryDef(2)
 195 ; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 196   %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 197   br i1 undef, label %Loop.Body, label %Loop.End
 198
 199 Loop.Body:
 200 ; CHECK: 8 = MemoryPhi({entry,3},{Loop.Body,4},{Loop.next,5},{Loop.End,6})
 201 ; CHECK: MemoryUse(8)
 202 ; CHECK-NEXT: %0 = load i8
 203   %0 = load i8, i8* %after, !invariant.group !0
 204
 205 ; CHECK: 4 = MemoryDef(8)
 206 ; CHECK-NEXT: call void @clobber8
 207   call void @clobber8(i8* %after)
 208
 209 ; FIXME: MemoryUse(8)
 210 ; CHECK: MemoryUse(4)
 211 ; CHECK-NEXT: %1 = load i8
 212   %1 = load i8, i8* %after, !invariant.group !0
 213
 214   br i1 undef, label %Loop.next, label %Loop.Body
 215 Loop.next:
 216 ; CHECK: 5 = MemoryDef(4)
 217 ; CHECK-NEXT: call void @clobber8
 218   call void @clobber8(i8* %after)
 219
 220 ; FIXME: MemoryUse(8)
 221 ; CHECK: MemoryUse(5)
 222 ; CHECK-NEXT: %2 = load i8
 223   %2 = load i8, i8* %after, !invariant.group !0
 224
 225   br i1 undef, label %Loop.End, label %Loop.Body
 226
 227 Loop.End:
 228 ; CHECK: 7 = MemoryPhi({entry,3},{Loop.next,5})
 229 ; CHECK: MemoryUse(7)
 230 ; CHECK-NEXT: %3 = load
 231   %3 = load i8, i8* %after, align 4, !invariant.group !0
 232
 233 ; CHECK: 6 = MemoryDef(7)
 234 ; CHECK-NEXT: call void @clobber8
 235   call void @clobber8(i8* %after)
 236
 237 ; FIXME: MemoryUse(7)
 238 ; CHECK: MemoryUse(6)
 239 ; CHECK-NEXT: %4 = load
 240   %4 = load i8, i8* %after, align 4, !invariant.group !0
 241   br i1 undef, label %Ret, label %Loop.Body
 242
 243 Ret:
 244   ret i8 %3
 245 }
 246
 247 define i8 @loop4(i8* %p) {
 248 entry:
 249 ; CHECK: 1 = MemoryDef(liveOnEntry)
 250 ; CHECK-NEXT: store i8
 251   store i8 4, i8* %p, !invariant.group !0
 252 ; CHECK: 2 = MemoryDef(1)
 253 ; CHECK-NEXT: call void @clobber
 254   call void @clobber8(i8* %p)
 255 ; CHECK: 3 = MemoryDef(2)
 256 ; CHECK-NEXT: %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 257   %after = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
 258   br i1 undef, label %Loop.Pre, label %Loop.End
 259
 260 Loop.Pre:
 261 ; CHECK: MemoryUse(2)
 262 ; CHECK-NEXT: %0 = load i8
 263   %0 = load i8, i8* %after, !invariant.group !0
 264   br label %Loop.Body
 265 Loop.Body:
 266 ; CHECK: 6 = MemoryPhi({Loop.Pre,3},{Loop.Body,4},{Loop.End,5})
 267 ; CHECK-NEXT: MemoryUse(6)
 268 ; CHECK-NEXT: %1 = load i8
 269   %1 = load i8, i8* %after, !invariant.group !0
 270
 271 ; FIXME: MemoryUse(2)
 272 ; CHECK: MemoryUse(6)
 273 ; CHECK-NEXT: %2 = load i8
 274   %2 = load i8, i8* %p, !invariant.group !0
 275
 276 ; CHECK: 4 = MemoryDef(6)
 277   store i8 4, i8* %after, !invariant.group !0
 278   br i1 undef, label %Loop.End, label %Loop.Body
 279
 280 Loop.End:
 281 ; CHECK: 5 = MemoryPhi({entry,3},{Loop.Body,4})
 282 ; CHECK-NEXT: MemoryUse(5)
 283 ; CHECK-NEXT: %3 = load
 284   %3 = load i8, i8* %after, align 4, !invariant.group !0
 285
 286 ; FIXME: MemoryUse(2)
 287 ; CHECK: MemoryUse(5)
 288 ; CHECK-NEXT: %4 = load
 289   %4 = load i8, i8* %p, align 4, !invariant.group !0
 290   br i1 undef, label %Ret, label %Loop.Body
 291
 292 Ret:
 293   ret i8 %3
 294 }
 295
 296 ; In the future we would like to CSE barriers if there is no clobber between.
 297 ; CHECK-LABEL: define i8 @optimizable()
 298 define i8 @optimizable() {
 299 entry:
 300   %ptr = alloca i8
 301 ; CHECK: 1 = MemoryDef(liveOnEntry)
 302 ; CHECK-NEXT: store i8 42, i8* %ptr, !invariant.group !0
 303   store i8 42, i8* %ptr, !invariant.group !0
 304 ; CHECK: 2 = MemoryDef(1)
 305 ; CHECK-NEXT: call i8* @llvm.launder.invariant.group
 306   %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
 307 ; FIXME: This one could be CSEd.
 308 ; CHECK: 3 = MemoryDef(2)
 309 ; CHECK: call i8* @llvm.launder.invariant.group
 310   %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
 311 ; CHECK: 4 = MemoryDef(3)
 312 ; CHECK-NEXT: call void @clobber8(i8* %ptr)
 313   call void @clobber8(i8* %ptr)
 314 ; CHECK: 5 = MemoryDef(4)
 315 ; CHECK-NEXT: call void @use(i8* %ptr2)
 316   call void @use(i8* %ptr2)
 317 ; CHECK: 6 = MemoryDef(5)
 318 ; CHECK-NEXT: call void @use(i8* %ptr3)
 319   call void @use(i8* %ptr3)
 320 ; CHECK: MemoryUse(6)
 321 ; CHECK-NEXT: load i8, i8* %ptr3, {{.*}}!invariant.group
 322   %v = load i8, i8* %ptr3, !invariant.group !0
 323
 324   ret i8 %v
 325 }
 326
 327 ; CHECK-LABEL: define i8 @unoptimizable2()
 328 define i8 @unoptimizable2() {
 329   %ptr = alloca i8
 330 ; CHECK: 1 = MemoryDef(liveOnEntry)
 331 ; CHECK-NEXT: store i8 42, i8* %ptr, !invariant.group !0
 332   store i8 42, i8* %ptr, !invariant.group !0
 333 ; CHECK: 2 = MemoryDef(1)
 334 ; CHECK-NEXT: call i8* @llvm.launder.invariant.group
 335   %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
 336 ; CHECK: 3 = MemoryDef(2)
 337   store i8 43, i8* %ptr
 338 ; CHECK: 4 = MemoryDef(3)
 339 ; CHECK-NEXT: call i8* @llvm.launder.invariant.group
 340   %ptr3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
 341 ; CHECK: 5 = MemoryDef(4)
 342 ; CHECK-NEXT: call void @clobber8(i8* %ptr)
 343   call void @clobber8(i8* %ptr)
 344 ; 6 = MemoryDef(5)
 345 ; CHECK-NEXT  call void @use(i8* %ptr2)
 346   call void @use(i8* %ptr2)
 347 ; CHECK: 7 = MemoryDef(6)
 348 ; CHECK-NEXT: call void @use(i8* %ptr3)
 349   call void @use(i8* %ptr3)
 350 ; CHECK: MemoryUse(7)
 351 ; CHECK-NEXT: %v = load i8, i8* %ptr3, !invariant.group !0
 352   %v = load i8, i8* %ptr3, !invariant.group !0
 353   ret i8 %v
 354 }
 355
 356
 357 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 358 declare void @clobber(i32*)
 359 declare void @clobber8(i8*)
 360 declare void @use(i8* readonly)
 361
 362 !0 = !{!"group1"}