blob: 01ac9240d92fb8d56d887a43ac2cadaec130ca02 [file]
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
; RUN: opt -S -passes='normalize<no-rename-all>' -verify-each < %s | FileCheck %s
; Reordering must keep every memory access in program order. SSA operands do
; not tie a load to a later store that overwrites the memory it reads.
; Regression test for https://github.com/llvm/llvm-project/issues/236128.
; The load must stay above the store that overwrites its value.
define i32 @load_before_store() {
; CHECK-LABEL: define i32 @load_before_store() {
; CHECK-NEXT: [[BB76827:.*:]]
; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 42, ptr [[P]], align 4
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: store i32 7, ptr [[P]], align 4
; CHECK-NEXT: ret i32 [[X]]
;
%p = alloca i32, align 4
store i32 42, ptr %p, align 4
%x = load i32, ptr %p, align 4
store i32 7, ptr %p, align 4
ret i32 %x
}
; The load has no user in its own block, so reordering reaches it only after
; every other instruction there. It must still stay above the store.
define i32 @load_used_in_successor(ptr %p) {
; CHECK-LABEL: define i32 @load_used_in_successor(
; CHECK-SAME: ptr [[P:%.*]]) {
; CHECK-NEXT: [[BB42578:.*:]]
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: store i32 7, ptr [[P]], align 4
; CHECK-NEXT: br label %[[BB17254:.*]]
; CHECK: [[BB17254]]:
; CHECK-NEXT: ret i32 [[X]]
;
entry:
%x = load i32, ptr %p, align 4
store i32 7, ptr %p, align 4
br label %next
next:
ret i32 %x
}
; The load's only user is a PHI. Reordering never walks from PHIs, so it
; reaches the load only after every other instruction in the block. The load
; must still stay above the store.
define i32 @load_used_by_phi(ptr %p, i32 %n) {
; CHECK-LABEL: define i32 @load_used_by_phi(
; CHECK-SAME: ptr [[P:%.*]], i32 [[N:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PREV:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[X:%.*]], %[[LOOP]] ]
; CHECK-NEXT: [[I:%.*]] = phi i32 [ 0, %[[ENTRY]] ], [ [[I_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT: [[X]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: store i32 [[I]], ptr [[P]], align 4
; CHECK-NEXT: [[I_NEXT]] = add i32 1, [[I]]
; CHECK-NEXT: [[DONE:%.*]] = icmp eq i32 [[I_NEXT]], [[N]]
; CHECK-NEXT: br i1 [[DONE]], label %[[EXIT:.*]], label %[[LOOP]]
; CHECK: [[EXIT]]:
; CHECK-NEXT: ret i32 [[PREV]]
;
entry:
br label %loop
loop:
%prev = phi i32 [ 0, %entry ], [ %x, %loop ]
%i = phi i32 [ 0, %entry ], [ %i.next, %loop ]
%x = load i32, ptr %p, align 4
store i32 %i, ptr %p, align 4
%i.next = add i32 %i, 1
%done = icmp eq i32 %i.next, %n
br i1 %done, label %exit, label %loop
exit:
ret i32 %prev
}
declare void @overwrite(ptr)
; A call can overwrite the memory read by an earlier load.
define i32 @load_before_writing_call() {
; CHECK-LABEL: define i32 @load_before_writing_call() {
; CHECK-NEXT: [[BB54946:.*:]]
; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 42, ptr [[P]], align 4
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: call void @overwrite(ptr [[P]])
; CHECK-NEXT: ret i32 [[X]]
;
%p = alloca i32, align 4
store i32 42, ptr %p, align 4
%x = load i32, ptr %p, align 4
call void @overwrite(ptr %p)
ret i32 %x
}
declare i32 @read(ptr) nounwind willreturn memory(argmem: read)
; A call without side effects can still read memory that a later store changes.
define i32 @reading_call_before_store() {
; CHECK-LABEL: define i32 @reading_call_before_store() {
; CHECK-NEXT: [[BB76827:.*:]]
; CHECK-NEXT: [[P:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 42, ptr [[P]], align 4
; CHECK-NEXT: [[X:%.*]] = call i32 @read(ptr [[P]])
; CHECK-NEXT: store i32 7, ptr [[P]], align 4
; CHECK-NEXT: ret i32 [[X]]
;
%p = alloca i32, align 4
store i32 42, ptr %p, align 4
%x = call i32 @read(ptr %p)
store i32 7, ptr %p, align 4
ret i32 %x
}