forked from OSchip/llvm-project
258 lines
9.4 KiB
LLVM
258 lines
9.4 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
|
; RUN: opt -simplifycfg -simplifycfg-require-and-preserve-domtree=1 -S < %s | FileCheck %s
|
|
|
|
define void @ifconvertstore(i32* %A, i32 %B, i32 %C, i32 %D) {
|
|
; CHECK-LABEL: @ifconvertstore(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: store i32 [[B:%.*]], i32* [[A:%.*]], align 4
|
|
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
|
|
; CHECK-NEXT: [[SPEC_STORE_SELECT:%.*]] = select i1 [[CMP]], i32 [[C:%.*]], i32 [[B]], !prof [[PROF0:![0-9]+]]
|
|
; CHECK-NEXT: store i32 [[SPEC_STORE_SELECT]], i32* [[A]], align 4
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
entry:
|
|
; First store to the location.
|
|
store i32 %B, i32* %A
|
|
%cmp = icmp sgt i32 %D, 42
|
|
br i1 %cmp, label %if.then, label %ret.end, !prof !0
|
|
|
|
; Make sure we speculate stores like the following one. It is cheap compared to
|
|
; a mispredicated branch.
|
|
if.then:
|
|
store i32 %C, i32* %A
|
|
br label %ret.end
|
|
|
|
ret.end:
|
|
ret void
|
|
}
|
|
|
|
; Store to a different location.
|
|
|
|
define void @noifconvertstore1(i32* %A1, i32* %A2, i32 %B, i32 %C, i32 %D) {
|
|
; CHECK-LABEL: @noifconvertstore1(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: store i32 [[B:%.*]], i32* [[A1:%.*]], align 4
|
|
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[D:%.*]], 42
|
|
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
|
|
; CHECK: if.then:
|
|
; CHECK-NEXT: store i32 [[C:%.*]], i32* [[A2:%.*]], align 4
|
|
; CHECK-NEXT: br label [[RET_END]]
|
|
; CHECK: ret.end:
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
entry:
|
|
store i32 %B, i32* %A1
|
|
%cmp = icmp sgt i32 %D, 42
|
|
br i1 %cmp, label %if.then, label %ret.end
|
|
|
|
if.then:
|
|
store i32 %C, i32* %A2
|
|
br label %ret.end
|
|
|
|
ret.end:
|
|
ret void
|
|
}
|
|
|
|
; This function could store to our address, so we can't repeat the first store a second time.
|
|
declare void @unknown_fun()
|
|
|
|
define void @noifconvertstore2(i32* %A, i32 %B, i32 %C, i32 %D) {
|
|
; CHECK-LABEL: @noifconvertstore2(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: store i32 [[B:%.*]], i32* [[A:%.*]], align 4
|
|
; CHECK-NEXT: call void @unknown_fun()
|
|
; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[D:%.*]], 42
|
|
; CHECK-NEXT: br i1 [[CMP6]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
|
|
; CHECK: if.then:
|
|
; CHECK-NEXT: store i32 [[C:%.*]], i32* [[A]], align 4
|
|
; CHECK-NEXT: br label [[RET_END]]
|
|
; CHECK: ret.end:
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
entry:
|
|
; First store to the location.
|
|
store i32 %B, i32* %A
|
|
call void @unknown_fun()
|
|
%cmp6 = icmp sgt i32 %D, 42
|
|
br i1 %cmp6, label %if.then, label %ret.end
|
|
|
|
if.then:
|
|
store i32 %C, i32* %A
|
|
br label %ret.end
|
|
|
|
ret.end:
|
|
ret void
|
|
}
|
|
|
|
; Make sure we don't speculate volatile stores.
|
|
|
|
define void @noifconvertstore_volatile(i32* %A, i32 %B, i32 %C, i32 %D) {
|
|
; CHECK-LABEL: @noifconvertstore_volatile(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: store i32 [[B:%.*]], i32* [[A:%.*]], align 4
|
|
; CHECK-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[D:%.*]], 42
|
|
; CHECK-NEXT: br i1 [[CMP6]], label [[IF_THEN:%.*]], label [[RET_END:%.*]]
|
|
; CHECK: if.then:
|
|
; CHECK-NEXT: store volatile i32 [[C:%.*]], i32* [[A]], align 4
|
|
; CHECK-NEXT: br label [[RET_END]]
|
|
; CHECK: ret.end:
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
entry:
|
|
; First store to the location.
|
|
store i32 %B, i32* %A
|
|
%cmp6 = icmp sgt i32 %D, 42
|
|
br i1 %cmp6, label %if.then, label %ret.end
|
|
|
|
if.then:
|
|
store volatile i32 %C, i32* %A
|
|
br label %ret.end
|
|
|
|
ret.end:
|
|
ret void
|
|
}
|
|
|
|
|
|
;; Speculate a store, preceded by a local, non-escaping load
|
|
define i32 @load_before_store_noescape(i64 %i, i32 %b) {
|
|
; CHECK-LABEL: @load_before_store_noescape(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[A:%.*]] = alloca [2 x i32], align 8
|
|
; CHECK-NEXT: [[TMP0:%.*]] = bitcast [2 x i32]* [[A]] to i64*
|
|
; CHECK-NEXT: store i64 4294967296, i64* [[TMP0]], align 8
|
|
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 [[I:%.*]]
|
|
; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[B:%.*]]
|
|
; CHECK-NEXT: [[SPEC_STORE_SELECT:%.*]] = select i1 [[CMP]], i32 [[B]], i32 [[TMP1]]
|
|
; CHECK-NEXT: store i32 [[SPEC_STORE_SELECT]], i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 0
|
|
; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4
|
|
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 1
|
|
; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[ARRAYIDX2]], align 4
|
|
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP2]], [[TMP3]]
|
|
; CHECK-NEXT: ret i32 [[ADD]]
|
|
;
|
|
entry:
|
|
%a = alloca [2 x i32], align 8
|
|
%0 = bitcast [2 x i32]* %a to i64*
|
|
store i64 4294967296, i64* %0, align 8
|
|
%arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 %i
|
|
%1 = load i32, i32* %arrayidx, align 4
|
|
%cmp = icmp slt i32 %1, %b
|
|
br i1 %cmp, label %if.then, label %if.end
|
|
|
|
if.then:
|
|
store i32 %b, i32* %arrayidx, align 4
|
|
br label %if.end
|
|
|
|
if.end:
|
|
%arrayidx1 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 0
|
|
%2 = load i32, i32* %arrayidx1, align 4
|
|
%arrayidx2 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 1
|
|
%3 = load i32, i32* %arrayidx2, align 4
|
|
%add = add nsw i32 %2, %3
|
|
ret i32 %add
|
|
}
|
|
|
|
;; Don't speculate a store, preceded by a local, escaping load
|
|
define i32 @load_before_store_escape(i64 %i, i32 %b) {
|
|
; CHECK-LABEL: @load_before_store_escape(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[A:%.*]] = alloca [2 x i32], align 8
|
|
; CHECK-NEXT: [[TMP0:%.*]] = bitcast [2 x i32]* [[A]] to i64*
|
|
; CHECK-NEXT: store i64 4294967296, i64* [[TMP0]], align 8
|
|
; CHECK-NEXT: call void @fork_some_threads([2 x i32]* [[A]])
|
|
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 [[I:%.*]]
|
|
; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[B:%.*]]
|
|
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
|
|
; CHECK: if.then:
|
|
; CHECK-NEXT: store i32 [[B]], i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: br label [[IF_END]]
|
|
; CHECK: if.end:
|
|
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 0
|
|
; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4
|
|
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 1
|
|
; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[ARRAYIDX2]], align 4
|
|
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP2]], [[TMP3]]
|
|
; CHECK-NEXT: call void @join_some_threads()
|
|
; CHECK-NEXT: ret i32 [[ADD]]
|
|
;
|
|
entry:
|
|
%a = alloca [2 x i32], align 8
|
|
%0 = bitcast [2 x i32]* %a to i64*
|
|
store i64 4294967296, i64* %0, align 8
|
|
call void @fork_some_threads([2 x i32]* %a)
|
|
%arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 %i
|
|
%1 = load i32, i32* %arrayidx, align 4
|
|
%cmp = icmp slt i32 %1, %b
|
|
br i1 %cmp, label %if.then, label %if.end
|
|
|
|
if.then:
|
|
store i32 %b, i32* %arrayidx, align 4
|
|
br label %if.end
|
|
|
|
if.end:
|
|
%arrayidx1 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 0
|
|
%2 = load i32, i32* %arrayidx1, align 4
|
|
%arrayidx2 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 1
|
|
%3 = load i32, i32* %arrayidx2, align 4
|
|
%add = add nsw i32 %2, %3
|
|
call void @join_some_threads()
|
|
ret i32 %add
|
|
}
|
|
|
|
declare void @fork_some_threads([2 x i32] *);
|
|
declare void @join_some_threads();
|
|
|
|
; Don't speculate if it's not the only instruction in the block (not counting
|
|
; the terminator)
|
|
define i32 @not_alone_in_block(i64 %i, i32 %b) {
|
|
; CHECK-LABEL: @not_alone_in_block(
|
|
; CHECK-NEXT: entry:
|
|
; CHECK-NEXT: [[A:%.*]] = alloca [2 x i32], align 8
|
|
; CHECK-NEXT: [[TMP0:%.*]] = bitcast [2 x i32]* [[A]] to i64*
|
|
; CHECK-NEXT: store i64 4294967296, i64* [[TMP0]], align 8
|
|
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 [[I:%.*]]
|
|
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 0
|
|
; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[TMP1]], [[B:%.*]]
|
|
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
|
|
; CHECK: if.then:
|
|
; CHECK-NEXT: store i32 [[B]], i32* [[ARRAYIDX]], align 4
|
|
; CHECK-NEXT: store i32 [[B]], i32* [[ARRAYIDX1]], align 4
|
|
; CHECK-NEXT: br label [[IF_END]]
|
|
; CHECK: if.end:
|
|
; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARRAYIDX1]], align 4
|
|
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[A]], i64 0, i64 1
|
|
; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[ARRAYIDX2]], align 4
|
|
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP2]], [[TMP3]]
|
|
; CHECK-NEXT: ret i32 [[ADD]]
|
|
;
|
|
entry:
|
|
%a = alloca [2 x i32], align 8
|
|
%0 = bitcast [2 x i32]* %a to i64*
|
|
store i64 4294967296, i64* %0, align 8
|
|
%arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 %i
|
|
%arrayidx1 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 0
|
|
%1 = load i32, i32* %arrayidx, align 4
|
|
%cmp = icmp slt i32 %1, %b
|
|
br i1 %cmp, label %if.then, label %if.end
|
|
|
|
if.then:
|
|
store i32 %b, i32* %arrayidx, align 4
|
|
store i32 %b, i32* %arrayidx1, align 4
|
|
br label %if.end
|
|
|
|
if.end:
|
|
%2 = load i32, i32* %arrayidx1, align 4
|
|
%arrayidx2 = getelementptr inbounds [2 x i32], [2 x i32]* %a, i64 0, i64 1
|
|
%3 = load i32, i32* %arrayidx2, align 4
|
|
%add = add nsw i32 %2, %3
|
|
ret i32 %add
|
|
}
|
|
|
|
; CHECK: !0 = !{!"branch_weights", i32 3, i32 5}
|
|
!0 = !{!"branch_weights", i32 3, i32 5}
|
|
|